pax_global_header00006660000000000000000000000064135636173470014531gustar00rootroot0000000000000052 comment=0a49ae08f76de7f886a3dbed4422711c2fa39d10 anbox-0.0~git20191115/000077500000000000000000000000001356361734700142255ustar00rootroot00000000000000anbox-0.0~git20191115/.clang-format000066400000000000000000000006611356361734700166030ustar00rootroot00000000000000# Defines the Chromium style for automatic reformatting. # http://clang.llvm.org/docs/ClangFormatStyleOptions.html BasedOnStyle: Google # This defaults to 'Auto'. Explicitly set it for a while, so that # 'vector >' in existing files gets formatted to # 'vector>'. ('Auto' means that clang-format will only use # 'int>>' if the file already contains at least one such instance.) Standard: Cpp11 ColumnLimit: 0 anbox-0.0~git20191115/.github/000077500000000000000000000000001356361734700155655ustar00rootroot00000000000000anbox-0.0~git20191115/.github/ISSUE_TEMPLATE.md000066400000000000000000000014361356361734700202760ustar00rootroot000000000000001. Please check that no similar bug is already reported. Have a look on the list of open bugs at https://github.com/anbox/anbox/issues 2. Make sure you are running the latest version of Anbox before reporting an issue. Update snap to latest: `snap refresh --devmode --edge anbox` 3. Make sure you have debug logs enabled: `sudo snap set anbox debug.enable=true` 4. Reproduce the error while debug logs enabled. 5. Run the anbox logs collection utility and attach the tar file. `sudo /snap/bin/anbox.collect-bug-info ` 6. ** Please paste the result of `anbox system-info` below:**
anbox system-info output ``` [please paste printout of `anbox system-info` here] ```
**Please describe your problem:** **What were you expecting?:** **Additional info:** anbox-0.0~git20191115/.github/stale.yml000066400000000000000000000016361356361734700174260ustar00rootroot00000000000000# Number of days of inactivity before an issue becomes stale daysUntilStale: 120 # Number of days of inactivity before a stale issue is closed daysUntilClose: 7 # Issues with these labels will never be considered stale exemptLabels: - android - app-support - bug - build - container - distro-support - documentation - duplicate - enhancement - help wanted - kernel - not-snap - question - session manager - sigill - startup - tools - undecided - upstream-bug # Label to use when marking an issue as stale staleLabel: decaying # Comment to post when marking an issue as stale. Set to `false` to disable markComment: > This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions. # Comment to post when closing a stale issue. Set to `false` to disable closeComment: false anbox-0.0~git20191115/.gitignore000066400000000000000000000004611356361734700162160ustar00rootroot00000000000000build*/ parts/ stage/ prime/ android-images/ *.snap CMakeLists.txt.user *.o.cmd *.symvers *.o *.ko *.ko.cmd *.mod.c *.mod.o modules.order .tmp_versions .idea debian/anbox-modules-dkms.debhelper.log debian/anbox-modules-dkms.substvars debian/anbox-modules-dkms/ debian/debhelper-build-stamp debian/files anbox-0.0~git20191115/.travis.yml000066400000000000000000000001471356361734700163400ustar00rootroot00000000000000language: cpp os: linux sudo: required services: - docker script: - scripts/build-with-docker.sh anbox-0.0~git20191115/AUTHORS000066400000000000000000000001651356361734700152770ustar00rootroot00000000000000People contributed to Anbox in an alphabetical sorted list: Marius Gripsgard Ricardo Mendoza Simon Fels Thomas Voß anbox-0.0~git20191115/Android.mk000066400000000000000000000074501356361734700161440ustar00rootroot00000000000000LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) LOCAL_MODULE := libprocess-cpp-minimal LOCAL_SRC_FILES := \ external/process-cpp-minimal/src/core/posix/process.cpp \ external/process-cpp-minimal/src/core/posix/process_group.cpp \ external/process-cpp-minimal/src/core/posix/signal.cpp \ external/process-cpp-minimal/src/core/posix/signalable.cpp \ external/process-cpp-minimal/src/core/posix/standard_stream.cpp \ external/process-cpp-minimal/src/core/posix/wait.cpp \ external/process-cpp-minimal/src/core/posix/fork.cpp \ external/process-cpp-minimal/src/core/posix/exec.cpp \ external/process-cpp-minimal/src/core/posix/child_process.cpp LOCAL_CFLAGS := \ -DANDROID \ -fexceptions LOCAL_C_INCLUDES += \ $(LOCAL_PATH)/external/process-cpp-minimal/include include $(BUILD_STATIC_LIBRARY) include $(CLEAR_VARS) LOCAL_MODULE_CLASS := EXECUTABLES LOCAL_MODULE := anboxd LOCAL_INIT_RC := android/anboxd.rc LOCAL_SRC_FILES := \ android/service/main.cpp \ android/service/daemon.cpp \ android/service/host_connector.cpp \ android/service/local_socket_connection.cpp \ android/service/message_processor.cpp \ android/service/activity_manager_interface.cpp \ android/service/android_api_skeleton.cpp \ android/service/platform_service_interface.cpp \ android/service/platform_service.cpp \ android/service/platform_api_stub.cpp \ src/anbox/common/fd.cpp \ src/anbox/common/wait_handle.cpp \ src/anbox/rpc/message_processor.cpp \ src/anbox/rpc/pending_call_cache.cpp \ src/anbox/rpc/channel.cpp \ src/anbox/protobuf/anbox_rpc.proto \ src/anbox/protobuf/anbox_bridge.proto proto_header_dir := $(call local-generated-sources-dir)/proto/$(LOCAL_PATH)/src/anbox/protobuf LOCAL_C_INCLUDES += \ $(proto_header_dir) \ $(LOCAL_PATH)/external/process-cpp-minimal/include \ $(LOCAL_PATH)/src \ $(LOCAL_PATH)/android/service LOCAL_EXPORT_C_INCLUDE_DIRS += $(proto_header_dir) LOCAL_STATIC_LIBRARIES := \ libprocess-cpp-minimal LOCAL_SHARED_LIBRARIES := \ liblog \ libprotobuf-cpp-lite \ libsysutils \ libbinder \ libcutils \ libutils LOCAL_CFLAGS := \ -fexceptions \ -std=c++1y include $(BUILD_EXECUTABLE) include $(CLEAR_VARS) LOCAL_MODULE_RELATIVE_PATH := hw LOCAL_SHARED_LIBRARIES := \ liblog \ lib_renderControl_enc \ libOpenglSystemCommon LOCAL_SRC_FILES := \ android/hwcomposer/hwcomposer.cpp LOCAL_MODULE := hwcomposer.anbox LOCAL_CFLAGS:= -DLOG_TAG=\"hwcomposer\" LOCAL_C_INCLUDES += \ $(LOCAL_PATH)/android/opengl/host/include/libOpenglRender \ $(LOCAL_PATH)/android/opengl/shared/OpenglCodecCommon \ $(LOCAL_PATH)/android/opengl/system/renderControl_enc \ $(LOCAL_PATH)/android/opengl/system/OpenglSystemCommon LOCAL_MODULE_TAGS := optional include $(BUILD_SHARED_LIBRARY) include $(CLEAR_VARS) LOCAL_MODULE := audio.primary.goldfish LOCAL_MODULE_RELATIVE_PATH := hw LOCAL_MODULE_TAGS := optional LOCAL_SHARED_LIBRARIES := libcutils liblog LOCAL_SRC_FILES := \ android/audio/audio_hw.cpp LOCAL_C_INCLUDES += \ $(LOCAL_PATH)/src LOCAL_SHARED_LIBRARIES += libdl LOCAL_CFLAGS := -Wno-unused-parameter include $(BUILD_SHARED_LIBRARY) # Include the Android.mk files below will override LOCAL_PATH so we # have to take a copy of it here. TMP_PATH := $(LOCAL_PATH) include $(TMP_PATH)/android/appmgr/Android.mk include $(TMP_PATH)/android/fingerprint/Android.mk include $(TMP_PATH)/android/power/Android.mk include $(TMP_PATH)/android/qemu-props/Android.mk include $(TMP_PATH)/android/qemud/Android.mk include $(TMP_PATH)/android/sensors/Android.mk include $(TMP_PATH)/android/opengl/Android.mk include $(TMP_PATH)/android/gps/Android.mk include $(TMP_PATH)/android/lights/Android.mk include $(TMP_PATH)/android/camera/Android.mk include $(TMP_PATH)/android/vibrator/Android.mk anbox-0.0~git20191115/CMakeLists.txt000066400000000000000000000137451356361734700167770ustar00rootroot00000000000000project(anbox C CXX) cmake_minimum_required(VERSION 2.8.2) include(CTest) include(GNUInstallDirs) if (NOT CMAKE_BUILD_TYPE) message(STATUS "No build type selected, default to RelWithDebInfo") set(CMAKE_BUILD_TYPE "RelWithDebInfo") endif() set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -pedantic -Wno-variadic-macros -Wextra -fPIC") # By default, all symbols are visible in the library. We strip out things we don't # want at link time, by running a version script (see unity-scopes.map and the # setting of LINK_FLAGS below). set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=default") set(C_AND_CXX_WARNINGS "-pedantic -Wall -Wextra") # Some additional warnings not included by the general flags set above. set(EXTRA_C_WARNINGS "-Wcast-align -Wcast-qual -Wformat -Wredundant-decls -Wswitch-default") set(EXTRA_CXX_WARNINGS "-Wnon-virtual-dtor -Wold-style-cast") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_AND_CXX_WARNINGS}") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_C_WARNINGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 ${C_AND_CXX_WARNINGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_C_WARNINGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXX_WARNINGS}") # -fno-permissive causes warnings with clang, so we only enable it for gcc if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-permissive") endif() string(TOLOWER "${CMAKE_BUILD_TYPE}" cmake_build_type_lower) if ("${cmake_build_type_lower}" STREQUAL "release" OR "${cmake_build_type_lower}" STREQUAL "relwithdebinfo") option(Werror "Treat warnings as errors" ON) else() option(Werror "Treat warnings as errors" OFF) endif() if (${Werror}) message(STATUS "Treat warnings as errors") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror") if ("${cmake_build_type_lower}" STREQUAL "release" OR "${cmake_build_type_lower}" STREQUAL "relwithdebinfo") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-error=deprecated-declarations") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=deprecated-declarations") endif() endif() set(CMAKE_INCLUDE_CURRENT_DIR ON) find_package(Boost COMPONENTS filesystem log serialization system thread program_options) find_package(PkgConfig) find_package(Threads) find_package(EGL REQUIRED) find_package(GLESv2 REQUIRED) find_package(Protobuf REQUIRED) pkg_check_modules(SDL2 sdl2 REQUIRED) pkg_check_modules(SDL2_IMAGE SDL2_image REQUIRED) pkg_check_modules(DBUS dbus-1 REQUIRED) pkg_check_modules(LXC lxc REQUIRED) pkg_check_modules(PROPERTIES_CPP properties-cpp REQUIRED) pkg_check_modules(LIBSYSTEMD libsystemd REQUIRED) message(STATUS "LXC version: ${LXC_VERSION}") if (${LXC_VERSION} VERSION_LESS 3.0) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DENABLE_LXC2_SUPPORT") message(STATUS "Building with LXC 2.x compatibility support") endif() option(ENABLE_X11 "Enable X11 support" ON) if (ENABLE_X11) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DX11_SUPPORT") endif() option(ENABLE_WAYLAND "Enable wayland support" ON) if (ENABLE_WAYLAND) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DWAYLAND_SUPPORT") endif() option(ENABLE_MIR "Enable mir support" OFF) if (ENABLE_MIR) pkg_check_modules(MIRCLIENT mirclient REQUIRED) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DMIR_SUPPORT") endif() set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DEGL_NO_X11") if((Protobuf_VERSION VERSION_GREATER "3.7") OR (Protobuf_VERSION VERSION_EQUAL "3.7")) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_PROTOBUF_CALLBACK_HEADER") endif() ##################################################################### # Enable code coverage calculation with gcov/gcovr/lcov # Usage: # * Switch build type to coverage (use ccmake or cmake-gui) # * Invoke make, make test, make coverage # * Find html report in subdir coveragereport # * Find xml report feasible for jenkins in coverage.xml ##################################################################### IF(CMAKE_BUILD_TYPE MATCHES [cC][oO][vV][eE][rR][aA][gG][eE]) SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftest-coverage -fprofile-arcs" ) SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ftest-coverage -fprofile-arcs" ) SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -ftest-coverage -fprofile-arcs" ) SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -ftest-coverage -fprofile-arcs" ) ENDIF(CMAKE_BUILD_TYPE MATCHES [cC][oO][vV][eE][rR][aA][gG][eE]) find_package(GMock) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -fPIC") if (NOT ANBOX_VERSION) exec_program("git" ${CMAKE_SOURCE_DIR} ARGS "rev-parse --short HEAD" OUTPUT_VARIABLE GIT_COMMIT_HASH) set(ANBOX_VERSION "local-${GIT_COMMIT_HASH}") endif() if (ANBOX_VERSION_SUFFIX) set(ANBOX_VERSION "${ANBOX_VERSION}-${ANBOX_VERSION_SUFFIX}") endif() set(ANBOX_RESOURCE_DIR "${CMAKE_INSTALL_DATADIR}/anbox") set(ANBOX_RESOURCE_DIR_FULL "${CMAKE_INSTALL_FULL_DATADIR}/anbox") set(ANBOX_STATEDIR_FULL "${CMAKE_INSTALL_FULL_LOCALSTATEDIR}/lib/anbox") configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/anbox/build/config.h.in ${CMAKE_CURRENT_SOURCE_DIR}/src/anbox/build/config.h) add_subdirectory(external) add_subdirectory(src) add_subdirectory(tests) add_subdirectory(android) if (NOT "${HOST_CMAKE_C_COMPILER}" STREQUAL "") message(STATUS "Host C compiler: ${HOST_CMAKE_C_COMPILER}") message(STATUS "Host C compiler: ${HOST_CMAKE_CXX_COMPILER}") endif() option(SNAP_CONFINEMENT "Enable snap confinement support" OFF) if (SNAP_CONFINEMENT) message(STATUS "Building with support for snap confinement") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DENABLE_SNAP_CONFINEMENT") endif() install(FILES data/ui/loading-screen.png DESTINATION ${ANBOX_RESOURCE_DIR}/ui) # uninstall target configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" IMMEDIATE @ONLY) add_custom_target(uninstall "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake") anbox-0.0~git20191115/COPYING.GPL000066400000000000000000001043741356361734700157120ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. 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 them 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 prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. 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. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey 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; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If 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 convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU 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 that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. 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. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS 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. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. 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 state 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 3 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, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program 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, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU 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 Lesser General Public License instead of this License. But first, please read . anbox-0.0~git20191115/README.md000066400000000000000000000125451356361734700155130ustar00rootroot00000000000000[![Snap Status](https://build.snapcraft.io/badge/anbox/anbox.svg)](https://build.snapcraft.io/user/anbox/anbox) [![Build Status](https://travis-ci.org/anbox/anbox.svg?branch=master)](https://travis-ci.org/anbox/anbox) # Anbox Anbox is a container-based approach to boot a full Android system on a regular GNU/Linux system like Ubuntu. In other words: Anbox will let you run Android on your Linux system without the slowness of virtualization. ## Overview Anbox uses Linux namespaces (user, pid, uts, net, mount, ipc) to run a full Android system in a container and provide Android applications on any GNU/Linux-based platform. The Android inside the container has no direct access to any hardware. All hardware access is going through the anbox daemon on the host. We're reusing what Android implemented within the QEMU-based emulator for OpenGL ES accelerated rendering. The Android system inside the container uses different pipes to communicate with the host system and sends all hardware access commands through these. For more details have a look at the following documentation pages: * [Android Hardware OpenGL ES emulation design overview](https://android.googlesource.com/platform/external/qemu/+/emu-master-dev/android/android-emugl/DESIGN) * [Android QEMU fast pipes](https://android.googlesource.com/platform/external/qemu/+/emu-master-dev/android/docs/ANDROID-QEMU-PIPE.TXT) * [The Android "qemud" multiplexing daemon](https://android.googlesource.com/platform/external/qemu/+/emu-master-dev/android/docs/ANDROID-QEMUD.TXT) * [Android qemud services](https://android.googlesource.com/platform/external/qemu/+/emu-master-dev/android/docs/ANDROID-QEMUD-SERVICES.TXT) Anbox is currently suited for the desktop use case but can be used on mobile operating systems like Ubuntu Touch, Sailfish OS or Lune OS too. However as the mapping of Android applications is currently desktop specific this needs additional work to supported stacked window user interfaces too. The Android runtime environment ships with a minimal customized Android system image based on the [Android Open Source Project](https://source.android.com/). The used image is currently based on Android 7.1.1 ## Installation See our [installation instructions](docs/install.md) for details. ## Supported Linux Distributions At the moment we officially support the following Linux distributions: * Ubuntu 16.04 (xenial) * Ubuntu 18.04 (bionic) However all other distributions supporting snap packages should work as well as long as they provide the mandatory kernel modules (see kernel/). ## Install and Run Android Applications TBD ## Build from source ### Requirements To build the Anbox runtime itself there is nothing special to know. We're using cmake as build system. A few build dependencies need to be present on your host system: * libdbus * google-mock * google-test * libboost * libboost-filesystem * libboost-log * libboost-iostreams * libboost-program-options * libboost-system * libboost-test * libboost-thread * libcap * libsystemd * mesa (libegl1, libgles2) * libsdl2 * libprotobuf * protobuf-compiler * lxc (>= 3.0) On an Ubuntu system you can install all build dependencies with the following command: ``` $ sudo apt install build-essential cmake cmake-data debhelper dbus google-mock \ libboost-dev libboost-filesystem-dev libboost-log-dev libboost-iostreams-dev \ libboost-program-options-dev libboost-system-dev libboost-test-dev \ libboost-thread-dev libcap-dev libsystemd-dev libegl1-mesa-dev \ libgles2-mesa-dev libglm-dev libgtest-dev liblxc1 \ libproperties-cpp-dev libprotobuf-dev libsdl2-dev libsdl2-image-dev lxc-dev \ pkg-config protobuf-compiler ``` We recommend Ubuntu 18.04 (bionic) with **GCC 7.x** as your build environment. ### Build Afterwards you can build Anbox with ``` $ git clone https://github.com/anbox/anbox.git $ cd anbox $ mkdir build $ cd build $ cmake .. $ make ``` A simple ``` $ sudo make install ``` will install the necessary bits into your system. If you want to build the anbox snap instead you can do this with the following steps: ``` $ mkdir android-images $ cp /path/to/android.img android-images/android.img $ snapcraft ``` The result will be a .snap file you can install on a system supporting snaps ``` $ snap install --dangerous --devmode anbox_1_amd64.snap ``` ## Run Anbox Running Anbox from a local build requires a few more things you need to know about. Please have a look at the ["Runtime Setup"](docs/runtime-setup.md) documentation. ## Documentation You will find additional documentation for Anbox in the *docs* subdirectory of the project source. Interesting things to have a look at * [Runtime Setup](docs/runtime-setup.md) * [Build Android image](docs/build-android.md) * [Generate Android emugl source](docs/generate-emugl-source.md) ## Reporting bugs If you have found an issue with Anbox, please [file a bug](https://github.com/anbox/anbox/issues/new). ## Get in Touch If you want to get in contact with the developers please feel free to join the *#anbox* IRC channel on [Freenode](https://freenode.net/). ## Copyright and Licensing Anbox reuses code from other projects like the Android QEMU emulator. These projects are available in the external/ subdirectory with the licensing terms included. The Anbox source itself, if not stated differently in the relevant source files, is licensed under the terms of the GPLv3 license. anbox-0.0~git20191115/android/000077500000000000000000000000001356361734700156455ustar00rootroot00000000000000anbox-0.0~git20191115/android/CMakeLists.txt000066400000000000000000000026161356361734700204120ustar00rootroot00000000000000include_directories( ${CMAKE_SOURCE_DIR} ${CMAKE_SOURCE_DIR}/src ${CMAKE_BINARY_DIR}/src) set(ANBOXD_SOURCES ${CMAKE_SOURCE_DIR}/src/anbox/rpc/message_processor.cpp ${CMAKE_SOURCE_DIR}/src/anbox/rpc/pending_call_cache.cpp ${CMAKE_SOURCE_DIR}/src/anbox/common/fd.cpp service/activity_manager_interface.cpp service/platform_service.cpp service/platform_service_interface.cpp service/platform_api_stub.cpp service/android_api_skeleton.cpp service/message_processor.cpp service/local_socket_connection.cpp service/host_connector.cpp service/daemon.cpp service/main.cpp) add_executable(anboxd ${ANBOXD_SOURCES}) target_link_libraries(anboxd pthread process-cpp anbox-protobuf) set(HWCOMPOSER_SOURCES hwcomposer/hwcomposer.cpp) add_library(hwcomposer.anbox SHARED ${HWCOMPOSER_SOURCES}) set(AUDIO_SOURCES audio/audio_hw.cpp) add_library(audio.goldfish SHARED ${AUDIO_SOURCES}) # As we're adding Android specific bits in this project we can't # build this safely within default build anymore. We keep this # for easy integration into used IDEs. set_target_properties(anboxd PROPERTIES EXCLUDE_FROM_ALL 1 EXCLUDE_FROM_DEFAULT_BUILD 1) set_target_properties(hwcomposer.anbox PROPERTIES EXCLUDE_FROM_ALL 1 EXCLUDE_FROM_DEFAULT_BUILD 1) set_target_properties(audio.goldfish PROPERTIES EXCLUDE_FROM_ALL 1 EXCLUDE_FROM_DEFAULT_BUILD 1) anbox-0.0~git20191115/android/anboxd.rc000066400000000000000000000002161356361734700174450ustar00rootroot00000000000000service anboxd /system/bin/anboxd class core service anbox-log-dumper /system/bin/logcat -f /data/system.log -r 2048 -n 4 class core anbox-0.0~git20191115/android/appmgr/000077500000000000000000000000001356361734700171335ustar00rootroot00000000000000anbox-0.0~git20191115/android/appmgr/Android.mk000066400000000000000000000007011356361734700210420ustar00rootroot00000000000000LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) LOCAL_MODULE_TAGS := optional LOCAL_STATIC_JAVA_LIBRARIES := \ android-common \ android-support-v13 LOCAL_SRC_FILES := $(call all-java-files-under, src) # LOCAL_SDK_VERSION := current LOCAL_PACKAGE_NAME := AnboxAppMgr LOCAL_CERTIFICATE := shared LOCAL_PRIVILEGED_MODULE := true LOCAL_OVERRIDES_PACKAGES := \ Home \ Launcher2 \ Launcher3 \ LatinIME \ QuickSearchBox include $(BUILD_PACKAGE) anbox-0.0~git20191115/android/appmgr/AndroidManifest.xml000066400000000000000000000025561356361734700227340ustar00rootroot00000000000000 anbox-0.0~git20191115/android/appmgr/res/000077500000000000000000000000001356361734700177245ustar00rootroot00000000000000anbox-0.0~git20191115/android/appmgr/res/layout/000077500000000000000000000000001356361734700212415ustar00rootroot00000000000000anbox-0.0~git20191115/android/appmgr/res/layout/app_view.xml000066400000000000000000000013161356361734700235760ustar00rootroot00000000000000 anbox-0.0~git20191115/android/appmgr/res/layout/list_item_icon_text.xml000066400000000000000000000027551356361734700260410ustar00rootroot00000000000000 anbox-0.0~git20191115/android/appmgr/res/values/000077500000000000000000000000001356361734700212235ustar00rootroot00000000000000anbox-0.0~git20191115/android/appmgr/res/values/dimens.xml000066400000000000000000000003231356361734700232220ustar00rootroot00000000000000 16dp 16dp anbox-0.0~git20191115/android/appmgr/res/values/strings.xml000066400000000000000000000001301356361734700234300ustar00rootroot00000000000000 Anbox Application Manager anbox-0.0~git20191115/android/appmgr/src/000077500000000000000000000000001356361734700177225ustar00rootroot00000000000000anbox-0.0~git20191115/android/appmgr/src/org/000077500000000000000000000000001356361734700205115ustar00rootroot00000000000000anbox-0.0~git20191115/android/appmgr/src/org/anbox/000077500000000000000000000000001356361734700216205ustar00rootroot00000000000000anbox-0.0~git20191115/android/appmgr/src/org/anbox/appmgr/000077500000000000000000000000001356361734700231065ustar00rootroot00000000000000anbox-0.0~git20191115/android/appmgr/src/org/anbox/appmgr/AppListAdapter.java000066400000000000000000000056361356361734700266400ustar00rootroot00000000000000/* * The MIT License (MIT) * * Copyright 2016 Arnab Chakraborty. http://arnab.ch * * Permission is hereby granted, free of charge, to any person obtaining a copy of this * software and associated documentation files (the "Software"), to deal in the Software * without restriction, including without limitation the rights to use, copy, modify, * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be included in all copies * or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ package org.anbox.appmgr; import android.annotation.TargetApi; import android.content.Context; import android.os.Build; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; import android.widget.ArrayAdapter; import android.widget.ImageView; import android.widget.TextView; import java.util.ArrayList; import java.util.Collection; /** * Created by Arnab Chakraborty */ public class AppListAdapter extends ArrayAdapter { private final LayoutInflater mInflater; public AppListAdapter (Context context) { super(context, android.R.layout.simple_list_item_2); mInflater = LayoutInflater.from(context); } public void setData(ArrayList data) { clear(); if (data != null) { addAll(data); } } @Override @TargetApi(Build.VERSION_CODES.HONEYCOMB) public void addAll(Collection items) { //If the platform supports it, use addAll, otherwise add in loop if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) { super.addAll(items); }else{ for(AppModel item: items){ super.add(item); } } } /** * Populate new items in the list. */ @Override public View getView(int position, View convertView, ViewGroup parent) { View view; if (convertView == null) { view = mInflater.inflate(R.layout.list_item_icon_text, parent, false); } else { view = convertView; } AppModel item = getItem(position); ((ImageView)view.findViewById(R.id.icon)).setImageDrawable(item.getIcon()); ((TextView)view.findViewById(R.id.text)).setText(item.getLabel()); return view; } } anbox-0.0~git20191115/android/appmgr/src/org/anbox/appmgr/AppListFragment.java000066400000000000000000000050171356361734700270140ustar00rootroot00000000000000/* * The MIT License (MIT) * * Copyright 2016 Arnab Chakraborty. http://arnab.ch * * Permission is hereby granted, free of charge, to any person obtaining a copy of this * software and associated documentation files (the "Software"), to deal in the Software * without restriction, including without limitation the rights to use, copy, modify, * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be included in all copies * or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ package org.anbox.appmgr; import android.os.Bundle; import android.support.v4.app.ListFragment; import android.support.v4.app.LoaderManager; import android.support.v4.content.Loader; import java.util.ArrayList; /** * Created by Arnab Chakraborty */ public class AppListFragment extends ListFragment implements LoaderManager.LoaderCallbacks> { AppListAdapter mAdapter; @Override public void onActivityCreated(Bundle savedInstanceState) { super.onActivityCreated(savedInstanceState); setEmptyText("No Applications"); mAdapter = new AppListAdapter(getActivity()); setListAdapter(mAdapter); // till the data is loaded display a spinner setListShown(false); // create the loader to load the apps list in background getLoaderManager().initLoader(0, null, this); } @Override public Loader> onCreateLoader(int id, Bundle bundle) { return new AppsLoader(getActivity()); } @Override public void onLoadFinished(Loader> loader, ArrayList apps) { mAdapter.setData(apps); if (isResumed()) { setListShown(true); } else { setListShownNoAnimation(true); } } @Override public void onLoaderReset(Loader> loader) { mAdapter.setData(null); } } anbox-0.0~git20191115/android/appmgr/src/org/anbox/appmgr/AppModel.java000066400000000000000000000062321356361734700254550ustar00rootroot00000000000000/* * The MIT License (MIT) * * Copyright 2016 Arnab Chakraborty. http://arnab.ch * * Permission is hereby granted, free of charge, to any person obtaining a copy of this * software and associated documentation files (the "Software"), to deal in the Software * without restriction, including without limitation the rights to use, copy, modify, * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be included in all copies * or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ package org.anbox.appmgr; import android.content.Context; import android.content.pm.ApplicationInfo; import android.graphics.drawable.Drawable; import java.io.File; /** * @credit http://developer.android.com/reference/android/content/AsyncTaskLoader.html */ public class AppModel { private final Context mContext; private final ApplicationInfo mInfo; private String mAppLabel; private Drawable mIcon; private boolean mMounted; private final File mApkFile; public AppModel(Context context, ApplicationInfo info) { mContext = context; mInfo = info; mApkFile = new File(info.sourceDir); } public ApplicationInfo getAppInfo() { return mInfo; } public String getApplicationPackageName() { return getAppInfo().packageName; } public String getLabel() { return mAppLabel; } public Drawable getIcon() { if (mIcon == null) { if (mApkFile.exists()) { mIcon = mInfo.loadIcon(mContext.getPackageManager()); return mIcon; } else { mMounted = false; } } else if (!mMounted) { // If the app wasn't mounted but is now mounted, reload // its icon. if (mApkFile.exists()) { mMounted = true; mIcon = mInfo.loadIcon(mContext.getPackageManager()); return mIcon; } } else { return mIcon; } return mContext.getResources().getDrawable(android.R.drawable.sym_def_app_icon); } void loadLabel(Context context) { if (mAppLabel == null || !mMounted) { if (!mApkFile.exists()) { mMounted = false; mAppLabel = mInfo.packageName; } else { mMounted = true; CharSequence label = mInfo.loadLabel(context.getPackageManager()); mAppLabel = label != null ? label.toString() : mInfo.packageName; } } } } anbox-0.0~git20191115/android/appmgr/src/org/anbox/appmgr/AppViewActivity.java000066400000000000000000000023431356361734700270430ustar00rootroot00000000000000/* * Copyright (C) 2016 Simon Fels * * This program is free software: you can redistribute it and/or modify it * under the terms of the GNU General Public License version 3, as published * by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranties of * MERCHANTABILITY, SATISFACTORY QUALITY, 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, see . * */ package org.anbox.appmgr; import android.os.Bundle; import android.util.Log; import android.support.v4.app.FragmentActivity; public final class AppViewActivity extends FragmentActivity { private static final String TAG = "AnboxAppView"; @Override public void onCreate(Bundle info) { super.onCreate(info); setContentView(R.layout.app_view); Log.i(TAG, "Created application view activity"); } @Override public void onDestroy() { Log.i(TAG, "Destroying application view activity"); super.onDestroy(); } } anbox-0.0~git20191115/android/appmgr/src/org/anbox/appmgr/AppsGridFragment.java000066400000000000000000000057361356361734700271610ustar00rootroot00000000000000/* * The MIT License (MIT) * * Copyright 2016 Arnab Chakraborty. http://arnab.ch * * Permission is hereby granted, free of charge, to any person obtaining a copy of this * software and associated documentation files (the "Software"), to deal in the Software * without restriction, including without limitation the rights to use, copy, modify, * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be included in all copies * or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ package org.anbox.appmgr; import android.content.Intent; import android.os.Bundle; import android.support.v4.app.LoaderManager; import android.support.v4.content.Loader; import android.view.View; import android.widget.GridView; import java.util.ArrayList; /** * Created by Arnab Chakraborty */ public class AppsGridFragment extends GridFragment implements LoaderManager.LoaderCallbacks> { AppListAdapter mAdapter; @Override public void onActivityCreated(Bundle savedInstanceState) { super.onActivityCreated(savedInstanceState); setEmptyText("No Applications"); mAdapter = new AppListAdapter(getActivity()); setGridAdapter(mAdapter); // till the data is loaded display a spinner setGridShown(false); // create the loader to load the apps list in background getLoaderManager().initLoader(0, null, this); } @Override public Loader> onCreateLoader(int id, Bundle bundle) { return new AppsLoader(getActivity()); } @Override public void onLoadFinished(Loader> loader, ArrayList apps) { mAdapter.setData(apps); if (isResumed()) { setGridShown(true); } else { setGridShownNoAnimation(true); } } @Override public void onLoaderReset(Loader> loader) { mAdapter.setData(null); } @Override public void onGridItemClick(GridView g, View v, int position, long id) { AppModel app = (AppModel) getGridAdapter().getItem(position); if (app != null) { Intent intent = getActivity().getPackageManager().getLaunchIntentForPackage(app.getApplicationPackageName()); if (intent != null) { startActivity(intent); } } } } anbox-0.0~git20191115/android/appmgr/src/org/anbox/appmgr/AppsLoader.java000066400000000000000000000135311356361734700260060ustar00rootroot00000000000000/* * The MIT License (MIT) * * Copyright 2016 Arnab Chakraborty. http://arnab.ch * * Permission is hereby granted, free of charge, to any person obtaining a copy of this * software and associated documentation files (the "Software"), to deal in the Software * without restriction, including without limitation the rights to use, copy, modify, * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be included in all copies * or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ package org.anbox.appmgr; import android.content.Context; import android.content.pm.ApplicationInfo; import android.content.pm.PackageManager; import android.support.v4.content.AsyncTaskLoader; import java.text.Collator; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Comparator; /** * @credit http://developer.android.com/reference/android/content/AsyncTaskLoader.html */ public class AppsLoader extends AsyncTaskLoader> { ArrayList mInstalledApps; final PackageManager mPm; PackageIntentReceiver mPackageObserver; public AppsLoader(Context context) { super(context); mPm = context.getPackageManager(); } @Override public ArrayList loadInBackground() { // retrieve the list of installed applications List apps = mPm.getInstalledApplications(0); if (apps == null) { apps = new ArrayList(); } final Context context = getContext(); // create corresponding apps and load their labels ArrayList items = new ArrayList(apps.size()); for (int i = 0; i < apps.size(); i++) { String pkg = apps.get(i).packageName; // only apps which are launchable if (context.getPackageManager().getLaunchIntentForPackage(pkg) != null) { AppModel app = new AppModel(context, apps.get(i)); app.loadLabel(context); items.add(app); } } // sort the list Collections.sort(items, ALPHA_COMPARATOR); return items; } @Override public void deliverResult(ArrayList apps) { if (isReset()) { // An async query came in while the loader is stopped. We // don't need the result. if (apps != null) { onReleaseResources(apps); } } ArrayList oldApps = apps; mInstalledApps = apps; if (isStarted()) { // If the Loader is currently started, we can immediately // deliver its results. super.deliverResult(apps); } // At this point we can release the resources associated with // 'oldApps' if needed; now that the new result is delivered we // know that it is no longer in use. if (oldApps != null) { onReleaseResources(oldApps); } } @Override protected void onStartLoading() { if (mInstalledApps != null) { // If we currently have a result available, deliver it // immediately. deliverResult(mInstalledApps); } // watch for changes in app install and uninstall operation if (mPackageObserver == null) { mPackageObserver = new PackageIntentReceiver(this); } if (takeContentChanged() || mInstalledApps == null ) { // If the data has changed since the last time it was loaded // or is not currently available, start a load. forceLoad(); } } @Override protected void onStopLoading() { // Attempt to cancel the current load task if possible. cancelLoad(); } @Override public void onCanceled(ArrayList apps) { super.onCanceled(apps); // At this point we can release the resources associated with 'apps' // if needed. onReleaseResources(apps); } @Override protected void onReset() { // Ensure the loader is stopped onStopLoading(); // At this point we can release the resources associated with 'apps' // if needed. if (mInstalledApps != null) { onReleaseResources(mInstalledApps); mInstalledApps = null; } // Stop monitoring for changes. if (mPackageObserver != null) { getContext().unregisterReceiver(mPackageObserver); mPackageObserver = null; } } /** * Helper method to do the cleanup work if needed, for example if we're * using Cursor, then we should be closing it here * * @param apps */ protected void onReleaseResources(ArrayList apps) { // do nothing } /** * Perform alphabetical comparison of application entry objects. */ public static final Comparator ALPHA_COMPARATOR = new Comparator() { private final Collator sCollator = Collator.getInstance(); @Override public int compare(AppModel object1, AppModel object2) { return sCollator.compare(object1.getLabel(), object2.getLabel()); } }; } anbox-0.0~git20191115/android/appmgr/src/org/anbox/appmgr/GridFragment.java000066400000000000000000000347371356361734700263400ustar00rootroot00000000000000package org.anbox.appmgr; /* * Created by Thomas Barrasso on 9/11/12. * Copyright (c) 2012 Loupe Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ import android.content.Context; import android.content.res.Resources; import android.os.Build; import android.os.Bundle; import android.os.Handler; import android.support.v4.app.Fragment; import android.util.TypedValue; import android.view.Gravity; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; import android.view.animation.AnimationUtils; import android.widget.AdapterView; import android.widget.FrameLayout; import android.widget.GridView; import android.widget.LinearLayout; import android.widget.ListAdapter; import android.widget.ListView; import android.widget.ProgressBar; import android.widget.TextView; /** * Based on {@link android.app.ListFragment} but adapted for {@link GridView}. */ public class GridFragment extends Fragment { static final int INTERNAL_EMPTY_ID = 0x00ff0001; static final int INTERNAL_PROGRESS_CONTAINER_ID = 0x00ff0002; static final int INTERNAL_LIST_CONTAINER_ID = 0x00ff0003; final private Handler mHandler = new Handler(); final private Runnable mRequestFocus = new Runnable() { public void run() { mGrid.focusableViewAvailable(mGrid); } }; final private AdapterView.OnItemClickListener mOnClickListener = new AdapterView.OnItemClickListener() { public void onItemClick(AdapterView parent, View v, int position, long id) { onGridItemClick((GridView) parent, v, position, id); } }; ListAdapter mAdapter; GridView mGrid; View mEmptyView; TextView mStandardEmptyView; View mProgressContainer; View mGridContainer; CharSequence mEmptyText; boolean mGridShown; public GridFragment() { } /** * Provide default implementation to return a simple grid view. Subclasses * can override to replace with their own layout. If doing so, the * returned view hierarchy must have a GridView whose id * is {@link android.R.id#list android.R.id.list} and can optionally * have a sibling view id {@link android.R.id#empty android.R.id.empty} * that is to be shown when the grid is empty. * *

If you are overriding this method with your own custom content, * consider including the standard layout {@link android.R.layout#list_content} * in your layout file, so that you continue to retain all of the standard * behavior of ListFragment. In particular, this is currently the only * way to have the built-in indeterminant progress state be shown. */ @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { final Context context = getActivity(); FrameLayout root = new FrameLayout(context); // ------------------------------------------------------------------ LinearLayout pframe = new LinearLayout(context); pframe.setId(INTERNAL_PROGRESS_CONTAINER_ID); pframe.setOrientation(LinearLayout.VERTICAL); pframe.setVisibility(View.GONE); pframe.setGravity(Gravity.CENTER); ProgressBar progress = new ProgressBar(context, null, android.R.attr.progressBarStyleLarge); pframe.addView(progress, new FrameLayout.LayoutParams( ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT)); root.addView(pframe, new FrameLayout.LayoutParams( ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)); // ------------------------------------------------------------------ FrameLayout lframe = new FrameLayout(context); lframe.setId(INTERNAL_LIST_CONTAINER_ID); TextView tv = new TextView(getActivity()); tv.setId(INTERNAL_EMPTY_ID); tv.setGravity(Gravity.CENTER); lframe.addView(tv, new FrameLayout.LayoutParams( ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)); GridView lv = new GridView(getActivity()); lv.setId(android.R.id.list); lv.setDrawSelectorOnTop(false); lv.setColumnWidth(convertDpToPixels(60, getActivity())); lv.setStretchMode(GridView.STRETCH_COLUMN_WIDTH); lv.setNumColumns(GridView.AUTO_FIT); lv.setHorizontalSpacing(convertDpToPixels(20, getActivity())); lv.setVerticalSpacing(convertDpToPixels(20, getActivity())); lv.setSmoothScrollbarEnabled(true); // disable overscroll if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) { lv.setOverScrollMode(ListView.OVER_SCROLL_NEVER); } lframe.addView(lv, new FrameLayout.LayoutParams( ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)); root.addView(lframe, new FrameLayout.LayoutParams( ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)); // ------------------------------------------------------------------ root.setLayoutParams(new FrameLayout.LayoutParams( ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)); return root; } /** * Attach to grid view once the view hierarchy has been created. */ @Override public void onViewCreated(View view, Bundle savedInstanceState) { super.onViewCreated(view, savedInstanceState); ensureGrid(); } /** * Detach from {@link GridView} */ @Override public void onDestroyView() { mHandler.removeCallbacks(mRequestFocus); mGrid = null; mGridShown = false; mEmptyView = mProgressContainer = mGridContainer = null; mStandardEmptyView = null; super.onDestroyView(); } public static int convertDpToPixels(float dp, Context context){ Resources resources = context.getResources(); return (int) TypedValue.applyDimension( TypedValue.COMPLEX_UNIT_DIP, dp, resources.getDisplayMetrics() ); } /** * This method will be called when an item in the grid is selected. * Subclasses should override. Subclasses can call * getGridView().getItemAtPosition(position) if they need to access the * data associated with the selected item. * * @param g The {@link GridView} where the click happened * @param v The view that was clicked within the {@link GridView} * @param position The position of the view in the grid * @param id The row id of the item that was clicked */ public void onGridItemClick(GridView g, View v, int position, long id) { } /** * Provide the cursor for the {@link GridView}. */ public void setGridAdapter(ListAdapter adapter) { final boolean hadAdapter = (mAdapter != null); mAdapter = adapter; if (mGrid != null) { mGrid.setAdapter(adapter); if (!mGridShown && !hadAdapter) { // The grid was hidden, and previously didn't have an // adapter. It is now time to show it. setGridShown(true, (getView().getWindowToken() != null)); } } } /** * Set the currently selected grid item to the specified * position with the adapter's data * * @param position */ public void setSelection(int position) { ensureGrid(); mGrid.setSelection(position); } /** * Get the position of the currently selected grid item. */ public int getSelectedItemPosition() { ensureGrid(); return mGrid.getSelectedItemPosition(); } /** * Get the cursor row ID of the currently selected grid item. */ public long getSelectedItemId() { ensureGrid(); return mGrid.getSelectedItemId(); } /** * Get the activity's {@link GridView} widget. */ public GridView getGridView() { ensureGrid(); return mGrid; } /** * The default content for a ListFragment has a TextView that can * be shown when the grid is empty. If you would like to have it * shown, call this method to supply the text it should use. */ public void setEmptyText(CharSequence text) { ensureGrid(); if (mStandardEmptyView == null) { throw new IllegalStateException("Can't be used with a custom content view"); } mStandardEmptyView.setText(text); if (mEmptyText == null) { mGrid.setEmptyView(mStandardEmptyView); } mEmptyText = text; } /** * Control whether the grid is being displayed. You can make it not * displayed if you are waiting for the initial data to show in it. During * this time an indeterminant progress indicator will be shown instead. * *

Applications do not normally need to use this themselves. The default * behavior of ListFragment is to start with the grid not being shown, only * showing it once an adapter is given with {@link #setGridAdapter(ListAdapter)}. * If the grid at that point had not been shown, when it does get shown * it will be do without the user ever seeing the hidden state. * * @param shown If true, the grid view is shown; if false, the progress * indicator. The initial value is true. */ public void setGridShown(boolean shown) { setGridShown(shown, true); } /** * Like {@link #setGridShown(boolean)}, but no animation is used when * transitioning from the previous state. */ public void setGridShownNoAnimation(boolean shown) { setGridShown(shown, false); } /** * Control whether the grid is being displayed. You can make it not * displayed if you are waiting for the initial data to show in it. During * this time an indeterminant progress indicator will be shown instead. * * @param shown If true, the grid view is shown; if false, the progress * indicator. The initial value is true. * @param animate If true, an animation will be used to transition to the * new state. */ private void setGridShown(boolean shown, boolean animate) { ensureGrid(); if (mProgressContainer == null) { throw new IllegalStateException("Can't be used with a custom content view"); } if (mGridShown == shown) { return; } mGridShown = shown; if (shown) { if (animate) { mProgressContainer.startAnimation(AnimationUtils.loadAnimation( getActivity(), android.R.anim.fade_out)); mGridContainer.startAnimation(AnimationUtils.loadAnimation( getActivity(), android.R.anim.fade_in)); } else { mProgressContainer.clearAnimation(); mGridContainer.clearAnimation(); } mProgressContainer.setVisibility(View.GONE); mGridContainer.setVisibility(View.VISIBLE); } else { if (animate) { mProgressContainer.startAnimation(AnimationUtils.loadAnimation( getActivity(), android.R.anim.fade_in)); mGridContainer.startAnimation(AnimationUtils.loadAnimation( getActivity(), android.R.anim.fade_out)); } else { mProgressContainer.clearAnimation(); mGridContainer.clearAnimation(); } mProgressContainer.setVisibility(View.VISIBLE); mGridContainer.setVisibility(View.GONE); } } /** * Get the ListAdapter associated with this activity's {@link GridView}. */ public ListAdapter getGridAdapter() { return mAdapter; } private void ensureGrid() { if (mGrid != null) { return; } View root = getView(); if (root == null) { throw new IllegalStateException("Content view not yet created"); } if (root instanceof GridView) { mGrid = (GridView) root; } else { mStandardEmptyView = (TextView)root.findViewById(INTERNAL_EMPTY_ID); if (mStandardEmptyView == null) { mEmptyView = root.findViewById(android.R.id.empty); } else { mStandardEmptyView.setVisibility(View.GONE); } mProgressContainer = root.findViewById(INTERNAL_PROGRESS_CONTAINER_ID); mGridContainer = root.findViewById(INTERNAL_LIST_CONTAINER_ID); View rawGridView = root.findViewById(android.R.id.list); if (!(rawGridView instanceof GridView)) { if (rawGridView == null) { throw new RuntimeException( "Your content must have a GridView whose id attribute is " + "'android.R.id.list'"); } throw new RuntimeException( "Content has view with id attribute 'android.R.id.list' " + "that is not a GridView class"); } mGrid = (GridView) rawGridView; if (mEmptyView != null) { mGrid.setEmptyView(mEmptyView); } else if (mEmptyText != null) { mStandardEmptyView.setText(mEmptyText); mGrid.setEmptyView(mStandardEmptyView); } } mGridShown = true; mGrid.setOnItemClickListener(mOnClickListener); if (mAdapter != null) { ListAdapter adapter = mAdapter; mAdapter = null; setGridAdapter(adapter); } else { // We are starting without an adapter, so assume we won't // have our data right away and start with the progress indicator. if (mProgressContainer != null) { setGridShown(false, false); } } mHandler.post(mRequestFocus); } } anbox-0.0~git20191115/android/appmgr/src/org/anbox/appmgr/LauncherActivity.java000066400000000000000000000025521356361734700272330ustar00rootroot00000000000000/* * Copyright (C) 2016 Simon Fels * * This program is free software: you can redistribute it and/or modify it * under the terms of the GNU General Public License version 3, as published * by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranties of * MERCHANTABILITY, SATISFACTORY QUALITY, 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, see . * */ package org.anbox.appmgr; import android.app.Activity; import android.os.Bundle; import android.util.Log; import android.content.Intent; public final class LauncherActivity extends Activity { private static final String TAG = "AnboxAppMgr"; @Override public void onCreate(Bundle info) { super.onCreate(info); Intent intent = new Intent(this, LauncherService.class); startService(intent); Log.i(TAG, "Created launcher activity"); } @Override public void onDestroy() { Log.i(TAG, "Destroyed launcher activity"); Intent intent = new Intent(this, LauncherService.class); stopService(intent); super.onDestroy(); } } anbox-0.0~git20191115/android/appmgr/src/org/anbox/appmgr/LauncherService.java000066400000000000000000000037671356361734700270500ustar00rootroot00000000000000/* * Copyright (C) 2016 Simon Fels * * This program is free software: you can redistribute it and/or modify it * under the terms of the GNU General Public License version 3, as published * by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranties of * MERCHANTABILITY, SATISFACTORY QUALITY, 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, see . * */ package org.anbox.appmgr; import android.app.Service; import android.util.Log; import android.content.Intent; import android.content.IntentFilter; import android.os.IBinder; public final class LauncherService extends Service { public static final String TAG = "AnboxAppMgr"; private PlatformService mPlatformService; private PackageEventReceiver mPkgEventReceiver; public LauncherService() { super(); Log.i(TAG, "Service created"); } @Override public void onCreate() { mPlatformService = new PlatformService(getBaseContext()); // Send the current list of applications over to the host so // it can rebuild its list of available applications. mPlatformService.sendApplicationListUpdate(); IntentFilter filter = new IntentFilter(); filter.addAction(Intent.ACTION_PACKAGE_ADDED); filter.addAction(Intent.ACTION_PACKAGE_CHANGED); filter.addAction(Intent.ACTION_PACKAGE_REMOVED); filter.addDataScheme("package"); mPkgEventReceiver = new PackageEventReceiver(); registerReceiver(mPkgEventReceiver, filter); Log.i(TAG, "Service started"); } @Override public void onDestroy() { Log.i(TAG, "Service stopped"); } @Override public IBinder onBind(Intent intent) { return null; } } anbox-0.0~git20191115/android/appmgr/src/org/anbox/appmgr/MainApplication.java000066400000000000000000000014321356361734700270210ustar00rootroot00000000000000/* * Copyright (C) 2016 Simon Fels * * This program is free software: you can redistribute it and/or modify it * under the terms of the GNU General Public License version 3, as published * by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranties of * MERCHANTABILITY, SATISFACTORY QUALITY, 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, see . * */ package org.anbox.appmgr; import android.app.Application; public final class MainApplication extends Application { } anbox-0.0~git20191115/android/appmgr/src/org/anbox/appmgr/PackageEventReceiver.java000066400000000000000000000040331356361734700277730ustar00rootroot00000000000000/* * Copyright (C) 2016 Simon Fels * * This program is free software: you can redistribute it and/or modify it * under the terms of the GNU General Public License version 3, as published * by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranties of * MERCHANTABILITY, SATISFACTORY QUALITY, 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, see . * */ package org.anbox.appmgr; import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.net.Uri; import android.util.Log; public class PackageEventReceiver extends BroadcastReceiver { private static final String TAG = "AnboxAppMgr"; private PlatformService mPlatformService; private String getPackageName(Intent intent) { Uri uri = intent.getData(); String package_name = (uri != null ? uri.getSchemeSpecificPart() : null); return package_name; } @Override public void onReceive(Context context, Intent intent) { if (mPlatformService == null) mPlatformService = new PlatformService(context); if (intent.getAction() == Intent.ACTION_PACKAGE_ADDED || intent.getAction() == Intent.ACTION_PACKAGE_CHANGED) { // Send updated list of applications to the host so that it // can update the list of applications available for the user. mPlatformService.sendApplicationListUpdate(); } else if (intent.getAction() == Intent.ACTION_PACKAGE_REMOVED) { // Only send notification when package got removed and not replaced if (!intent.getBooleanExtra(Intent.EXTRA_REPLACING, false)) { mPlatformService.notifyPackageRemoved(getPackageName(intent)); } } } } anbox-0.0~git20191115/android/appmgr/src/org/anbox/appmgr/PackageIntentReceiver.java000066400000000000000000000047101356361734700301550ustar00rootroot00000000000000/* * The MIT License (MIT) * * Copyright 2016 Arnab Chakraborty. http://arnab.ch * * Permission is hereby granted, free of charge, to any person obtaining a copy of this * software and associated documentation files (the "Software"), to deal in the Software * without restriction, including without limitation the rights to use, copy, modify, * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be included in all copies * or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ package org.anbox.appmgr; import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; /** * Helper class to look for interesting changes to the installed apps * so that the loader can be updated. * * @Credit http://developer.android.com/reference/android/content/AsyncTaskLoader.html */ public class PackageIntentReceiver extends BroadcastReceiver { final AppsLoader mLoader; public PackageIntentReceiver(AppsLoader loader) { mLoader = loader; IntentFilter filter = new IntentFilter(Intent.ACTION_PACKAGE_ADDED); filter.addAction(Intent.ACTION_PACKAGE_REMOVED); filter.addAction(Intent.ACTION_PACKAGE_CHANGED); filter.addDataScheme("package"); mLoader.getContext().registerReceiver(this, filter); // Register for events related to sdcard installation. IntentFilter sdFilter = new IntentFilter(); sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE); sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE); mLoader.getContext().registerReceiver(this, sdFilter); } @Override public void onReceive(Context context, Intent intent) { // Tell the loader about the change. mLoader.onContentChanged(); } } anbox-0.0~git20191115/android/appmgr/src/org/anbox/appmgr/PlatformService.java000066400000000000000000000132731356361734700270640ustar00rootroot00000000000000/* * Copyright (C) 2016 Simon Fels * * This program is free software: you can redistribute it and/or modify it * under the terms of the GNU General Public License version 3, as published * by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranties of * MERCHANTABILITY, SATISFACTORY QUALITY, 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, see . * */ package org.anbox.appmgr; import android.os.ServiceManager; import android.os.IBinder; import android.os.Parcel; import android.os.RemoteException; import android.util.Log; import android.content.Intent; import android.content.Context; import android.content.pm.PackageManager; import android.content.pm.ApplicationInfo; import android.net.Uri; import android.graphics.drawable.Drawable; import android.graphics.drawable.BitmapDrawable; import android.graphics.Bitmap; import android.graphics.Bitmap.Config; import android.graphics.Canvas; import java.util.List; import java.io.ByteArrayOutputStream; public final class PlatformService { private static final String TAG = "AnboxAppMgr"; private static final String SERVICE_NAME = "org.anbox.PlatformService"; private static final String DESCRIPTOR = "org.anbox.IPlatformService"; private static final int TRANSACTION_updateApplicationList = (IBinder.FIRST_CALL_TRANSACTION + 2); private IBinder mService = null; private PackageManager mPm = null; private void connectService() { if (mService != null) return; mService = ServiceManager.getService(SERVICE_NAME); } public PlatformService(Context context) { if (context != null) { mPm = context.getPackageManager(); } else { Log.w(TAG, "No context available"); } Log.i(TAG, "Connected to platform service"); } public void notifyPackageRemoved(String packageName) { connectService(); if (mService == null) return; Log.i(TAG, "Sending package removed notification to host service"); Parcel data = Parcel.obtain(); data.writeInterfaceToken(DESCRIPTOR); // No added or updated applications to report data.writeInt(0); // .. but a single removed application data.writeInt(1); data.writeString(packageName); Parcel reply = Parcel.obtain(); try { mService.transact(TRANSACTION_updateApplicationList, data, reply, 0); } catch (RemoteException ex) { Log.w(TAG, "Failed to send updatePackageList request to remote binder service: " + ex.getMessage()); } } public void sendApplicationListUpdate() { connectService(); if (mPm == null || mService == null) return; Parcel data = Parcel.obtain(); data.writeInterfaceToken(DESCRIPTOR); List apps = mPm.getInstalledApplications(0); data.writeInt(apps.size()); for (int n = 0; n < apps.size(); n++) { ApplicationInfo appInfo = apps.get(n); Intent launchIntent = mPm.getLaunchIntentForPackage(appInfo.packageName); if (launchIntent == null) continue; Drawable icon = null; try { icon = mPm.getApplicationIcon(appInfo.packageName); } catch (PackageManager.NameNotFoundException ex) { continue; } if (icon == null) continue; String name = appInfo.name; CharSequence label = appInfo.loadLabel(mPm); if (label != null) name = label.toString(); data.writeString(name); data.writeString(appInfo.packageName); data.writeString(launchIntent.getAction()); if (launchIntent.getData() != null) data.writeString(launchIntent.getData().toString()); else data.writeString(""); data.writeString(launchIntent.getType()); data.writeString(launchIntent.getComponent().getPackageName()); data.writeString(launchIntent.getComponent().getClassName()); data.writeInt(launchIntent.getCategories().size()); for (String category : launchIntent.getCategories()) data.writeString(category); Bitmap iconBitmap = drawableToBitmap(icon); ByteArrayOutputStream outStream = new ByteArrayOutputStream(); iconBitmap.compress(Bitmap.CompressFormat.PNG, 90, outStream); data.writeByteArray(outStream.toByteArray()); } // We don't have any removed applications to include in the update data.writeInt(0); Parcel reply = Parcel.obtain(); try { mService.transact(TRANSACTION_updateApplicationList, data, reply, 0); } catch (RemoteException ex) { Log.w(TAG, "Failed to send updatePackageList request to remote binder service: " + ex.getMessage()); } } private Bitmap drawableToBitmap(Drawable drawable) { if (drawable instanceof BitmapDrawable) return ((BitmapDrawable)drawable).getBitmap(); Bitmap bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Config.ARGB_8888); Canvas canvas = new Canvas(bitmap); drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight()); drawable.draw(canvas); return bitmap; } } anbox-0.0~git20191115/android/audio/000077500000000000000000000000001356361734700167465ustar00rootroot00000000000000anbox-0.0~git20191115/android/audio/MODULE_LICENSE_APACHE2000066400000000000000000000000001356361734700220710ustar00rootroot00000000000000anbox-0.0~git20191115/android/audio/NOTICE000066400000000000000000000247071356361734700176640ustar00rootroot00000000000000 Copyright (c) 2008-2009, The Android Open Source Project Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS anbox-0.0~git20191115/android/audio/audio_hw.cpp000066400000000000000000000474411356361734700212630ustar00rootroot00000000000000/* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define LOG_TAG "audio_hw_generic" #define LOG_NDEBUG 0 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "anbox/audio/client_info.h" #define AUDIO_DEVICE_NAME "/dev/anbox_audio" #define OUT_SAMPLING_RATE 44100 #define OUT_BUFFER_SIZE 4096 #define OUT_LATENCY_MS 20 #define IN_SAMPLING_RATE 8000 #define IN_BUFFER_SIZE 320 struct generic_audio_device { struct audio_hw_device device; pthread_mutex_t lock; struct audio_stream_out *output; struct audio_stream_in *input; bool mic_mute; }; struct generic_stream_out { struct audio_stream_out stream; struct generic_audio_device *dev; audio_devices_t device; int fd; }; struct generic_stream_in { struct audio_stream_in stream; struct generic_audio_device *dev; audio_devices_t device; int fd; }; static uint32_t out_get_sample_rate(const struct audio_stream *stream) { return OUT_SAMPLING_RATE; } static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate) { return -ENOSYS; } static size_t out_get_buffer_size(const struct audio_stream *stream) { return OUT_BUFFER_SIZE; } static audio_channel_mask_t out_get_channels(const struct audio_stream *stream) { return AUDIO_CHANNEL_OUT_STEREO; } static audio_format_t out_get_format(const struct audio_stream *stream) { return AUDIO_FORMAT_PCM_16_BIT; } static int out_set_format(struct audio_stream *stream, audio_format_t format) { return -ENOSYS; } static int out_standby(struct audio_stream *stream) { return 0; } static int out_dump(const struct audio_stream *stream, int fd) { struct generic_stream_out *out = (struct generic_stream_out *)stream; dprintf(fd, "\tout_dump:\n" "\t\tsample rate: %u\n" "\t\tbuffer size: %u\n" "\t\tchannel mask: %08x\n" "\t\tformat: %d\n" "\t\tdevice: %08x\n" "\t\taudio dev: %p\n\n", out_get_sample_rate(stream), out_get_buffer_size(stream), out_get_channels(stream), out_get_format(stream), out->device, out->dev); return 0; } static int out_set_parameters(struct audio_stream *stream, const char *kvpairs) { struct generic_stream_out *out = (struct generic_stream_out *)stream; struct str_parms *parms; char value[32]; int ret; long val; char *end; parms = str_parms_create_str(kvpairs); ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value)); if (ret >= 0) { errno = 0; val = strtol(value, &end, 10); if (errno == 0 && (end != NULL) && (*end == '\0') && ((int)val == val)) { out->device = (int)val; } else { ret = -EINVAL; } } str_parms_destroy(parms); return ret; } static char *out_get_parameters(const struct audio_stream *stream, const char *keys) { struct generic_stream_out *out = (struct generic_stream_out *)stream; struct str_parms *query = str_parms_create_str(keys); char *str; char value[256]; struct str_parms *reply = str_parms_create(); int ret; ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value)); if (ret >= 0) { str_parms_add_int(reply, AUDIO_PARAMETER_STREAM_ROUTING, out->device); str = strdup(str_parms_to_str(reply)); } else { str = strdup(keys); } str_parms_destroy(query); str_parms_destroy(reply); return str; } static uint32_t out_get_latency(const struct audio_stream_out *stream) { return OUT_LATENCY_MS; } static int out_set_volume(struct audio_stream_out *stream, float left, float right) { return -ENOSYS; } static ssize_t out_write(struct audio_stream_out *stream, const void *buffer, size_t bytes) { struct generic_stream_out *out = (struct generic_stream_out *)stream; struct generic_audio_device *adev = out->dev; pthread_mutex_lock(&adev->lock); if (out->fd >= 0) bytes = write(out->fd, buffer, bytes); pthread_mutex_unlock(&adev->lock); return bytes; } static int out_get_render_position(const struct audio_stream_out *stream, uint32_t *dsp_frames) { return -ENOSYS; } static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect) { return 0; } static int out_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect) { return 0; } static int out_get_next_write_timestamp(const struct audio_stream_out *stream, int64_t *timestamp) { return -ENOSYS; } static uint32_t in_get_sample_rate(const struct audio_stream *stream) { return IN_SAMPLING_RATE; } static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate) { return -ENOSYS; } static size_t in_get_buffer_size(const struct audio_stream *stream) { return IN_BUFFER_SIZE; } static audio_channel_mask_t in_get_channels(const struct audio_stream *stream) { return AUDIO_CHANNEL_IN_MONO; } static audio_format_t in_get_format(const struct audio_stream *stream) { return AUDIO_FORMAT_PCM_16_BIT; } static int in_set_format(struct audio_stream *stream, audio_format_t format) { return -ENOSYS; } static int in_standby(struct audio_stream *stream) { return 0; } static int in_dump(const struct audio_stream *stream, int fd) { struct generic_stream_in *in = (struct generic_stream_in *)stream; dprintf(fd, "\tin_dump:\n" "\t\tsample rate: %u\n" "\t\tbuffer size: %u\n" "\t\tchannel mask: %08x\n" "\t\tformat: %d\n" "\t\tdevice: %08x\n" "\t\taudio dev: %p\n\n", in_get_sample_rate(stream), in_get_buffer_size(stream), in_get_channels(stream), in_get_format(stream), in->device, in->dev); return 0; } static int in_set_parameters(struct audio_stream *stream, const char *kvpairs) { struct generic_stream_in *in = (struct generic_stream_in *)stream; struct str_parms *parms; char value[32]; int ret; long val; char *end; parms = str_parms_create_str(kvpairs); ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value)); if (ret >= 0) { errno = 0; val = strtol(value, &end, 10); if ((errno == 0) && (end != NULL) && (*end == '\0') && ((int)val == val)) { in->device = (int)val; } else { ret = -EINVAL; } } str_parms_destroy(parms); return ret; } static char *in_get_parameters(const struct audio_stream *stream, const char *keys) { struct generic_stream_in *in = (struct generic_stream_in *)stream; struct str_parms *query = str_parms_create_str(keys); char *str; char value[256]; struct str_parms *reply = str_parms_create(); int ret; ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value)); if (ret >= 0) { str_parms_add_int(reply, AUDIO_PARAMETER_STREAM_ROUTING, in->device); str = strdup(str_parms_to_str(reply)); } else { str = strdup(keys); } str_parms_destroy(query); str_parms_destroy(reply); return str; } static int in_set_gain(struct audio_stream_in *stream, float gain) { return 0; } static ssize_t in_read(struct audio_stream_in *stream, void *buffer, size_t bytes) { struct generic_stream_in *in = (struct generic_stream_in *)stream; struct generic_audio_device *adev = in->dev; pthread_mutex_lock(&adev->lock); if (in->fd >= 0) bytes = read(in->fd, buffer, bytes); if (adev->mic_mute && (bytes > 0)) { memset(buffer, 0, bytes); } pthread_mutex_unlock(&adev->lock); return bytes; } static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream) { return 0; } static int in_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect) { return 0; } static int in_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect) { return 0; } static int connect_audio_server(const anbox::audio::ClientInfo::Type &type) { int fd = socket(AF_LOCAL, SOCK_STREAM, 0); if (fd < 0) return -errno; struct sockaddr_un addr; memset(&addr, 0, sizeof(addr)); addr.sun_family = AF_UNIX; strncpy(addr.sun_path, AUDIO_DEVICE_NAME, sizeof(addr.sun_path)); if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) { close(fd); return -errno; } // We will send out client type information to the server and the // server will either deny the request by closing the connection // or by sending us the approved client details back. anbox::audio::ClientInfo client_info{type}; if (::write(fd, &client_info, sizeof(client_info)) < 0) { close(fd); return -EIO; } auto bytes_read = ::read(fd, &client_info, sizeof(client_info)); if (bytes_read < 0) { close(fd); return -EIO; } // FIXME once we have real client details we need to check if we // got everything we need or if anything is missing. ALOGE("Successfully connected Anbox audio server"); return fd; } static int adev_open_output_stream(struct audio_hw_device *dev, audio_io_handle_t handle, audio_devices_t devices, audio_output_flags_t flags, struct audio_config *config, struct audio_stream_out **stream_out, const char *address __unused) { struct generic_audio_device *adev = (struct generic_audio_device *)dev; struct generic_stream_out *out; int ret = 0, fd = 0; pthread_mutex_lock(&adev->lock); if (adev->output != NULL) { ret = -ENOSYS; goto error; } fd = connect_audio_server(anbox::audio::ClientInfo::Type::Playback); if (fd < 0) { ret = fd; ALOGE("Failed to connect with Anbox audio servers (err %d)", ret); goto error; } if ((config->format != AUDIO_FORMAT_PCM_16_BIT) || (config->channel_mask != AUDIO_CHANNEL_OUT_STEREO) || (config->sample_rate != OUT_SAMPLING_RATE)) { ALOGE("Error opening output stream format %d, channel_mask %04x, sample_rate %u", config->format, config->channel_mask, config->sample_rate); config->format = AUDIO_FORMAT_PCM_16_BIT; config->channel_mask = AUDIO_CHANNEL_OUT_STEREO; config->sample_rate = OUT_SAMPLING_RATE; ret = -EINVAL; goto error; } out = (struct generic_stream_out *)calloc(1, sizeof(struct generic_stream_out)); out->fd = fd; out->stream.common.get_sample_rate = out_get_sample_rate; out->stream.common.set_sample_rate = out_set_sample_rate; out->stream.common.get_buffer_size = out_get_buffer_size; out->stream.common.get_channels = out_get_channels; out->stream.common.get_format = out_get_format; out->stream.common.set_format = out_set_format; out->stream.common.standby = out_standby; out->stream.common.dump = out_dump; out->stream.common.set_parameters = out_set_parameters; out->stream.common.get_parameters = out_get_parameters; out->stream.common.add_audio_effect = out_add_audio_effect; out->stream.common.remove_audio_effect = out_remove_audio_effect; out->stream.get_latency = out_get_latency; out->stream.set_volume = out_set_volume; out->stream.write = out_write; out->stream.get_render_position = out_get_render_position; out->stream.get_next_write_timestamp = out_get_next_write_timestamp; out->dev = adev; out->device = devices; adev->output = (struct audio_stream_out *)out; *stream_out = &out->stream; error: pthread_mutex_unlock(&adev->lock); return ret; } static void adev_close_output_stream(struct audio_hw_device *dev, struct audio_stream_out *stream) { struct generic_audio_device *adev = (struct generic_audio_device *)dev; pthread_mutex_lock(&adev->lock); if (stream == adev->output) { free(stream); adev->output = NULL; } pthread_mutex_unlock(&adev->lock); } static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs) { return 0; } static char *adev_get_parameters(const struct audio_hw_device *dev, const char *keys) { return strdup(""); } static int adev_init_check(const struct audio_hw_device *dev) { return 0; } static int adev_set_voice_volume(struct audio_hw_device *dev, float volume) { return 0; } static int adev_set_master_volume(struct audio_hw_device *dev, float volume) { return -ENOSYS; } static int adev_get_master_volume(struct audio_hw_device *dev, float *volume) { return -ENOSYS; } static int adev_set_master_mute(struct audio_hw_device *dev, bool muted) { return -ENOSYS; } static int adev_get_master_mute(struct audio_hw_device *dev, bool *muted) { return -ENOSYS; } static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode) { return 0; } static int adev_set_mic_mute(struct audio_hw_device *dev, bool state) { struct generic_audio_device *adev = (struct generic_audio_device *)dev; pthread_mutex_lock(&adev->lock); adev->mic_mute = state; pthread_mutex_unlock(&adev->lock); return 0; } static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state) { struct generic_audio_device *adev = (struct generic_audio_device *)dev; pthread_mutex_lock(&adev->lock); *state = adev->mic_mute; pthread_mutex_unlock(&adev->lock); return 0; } static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev, const struct audio_config *config) { return IN_BUFFER_SIZE; } static int adev_open_input_stream(struct audio_hw_device *dev, audio_io_handle_t handle, audio_devices_t devices, struct audio_config *config, struct audio_stream_in **stream_in, audio_input_flags_t flags __unused, const char *address __unused, audio_source_t source __unused) { struct generic_audio_device *adev = (struct generic_audio_device *)dev; struct generic_stream_in *in; int ret = 0, fd = 0; pthread_mutex_lock(&adev->lock); if (adev->input != NULL) { ret = -ENOSYS; goto error; } if ((config->format != AUDIO_FORMAT_PCM_16_BIT) || (config->channel_mask != AUDIO_CHANNEL_IN_MONO) || (config->sample_rate != IN_SAMPLING_RATE)) { ALOGE("Error opening input stream format %d, channel_mask %04x, sample_rate %u", config->format, config->channel_mask, config->sample_rate); config->format = AUDIO_FORMAT_PCM_16_BIT; config->channel_mask = AUDIO_CHANNEL_IN_MONO; config->sample_rate = IN_SAMPLING_RATE; ret = -EINVAL; goto error; } fd = connect_audio_server(anbox::audio::ClientInfo::Type::Recording); if (fd < 0) { ret = fd; ALOGE("Failed to connect with Anbox audio servers (err %d)", ret); goto error; } in = (struct generic_stream_in *)calloc(1, sizeof(struct generic_stream_in)); in->fd = fd; in->stream.common.get_sample_rate = in_get_sample_rate; in->stream.common.set_sample_rate = in_set_sample_rate; in->stream.common.get_buffer_size = in_get_buffer_size; in->stream.common.get_channels = in_get_channels; in->stream.common.get_format = in_get_format; in->stream.common.set_format = in_set_format; in->stream.common.standby = in_standby; in->stream.common.dump = in_dump; in->stream.common.set_parameters = in_set_parameters; in->stream.common.get_parameters = in_get_parameters; in->stream.common.add_audio_effect = in_add_audio_effect; in->stream.common.remove_audio_effect = in_remove_audio_effect; in->stream.set_gain = in_set_gain; in->stream.read = in_read; in->stream.get_input_frames_lost = in_get_input_frames_lost; in->dev = adev; in->device = devices; adev->input = (struct audio_stream_in *)in; *stream_in = &in->stream; error: pthread_mutex_unlock(&adev->lock); return ret; } static void adev_close_input_stream(struct audio_hw_device *dev, struct audio_stream_in *stream) { struct generic_audio_device *adev = (struct generic_audio_device *)dev; pthread_mutex_lock(&adev->lock); if (stream == adev->input) { free(stream); adev->input = NULL; } pthread_mutex_unlock(&adev->lock); } static int adev_dump(const audio_hw_device_t *dev, int fd) { struct generic_audio_device *adev = (struct generic_audio_device *)dev; const size_t SIZE = 256; char buffer[SIZE]; dprintf(fd, "\nadev_dump:\n" "\tmic_mute: %s\n" "\toutput: %p\n" "\tinput: %p\n\n", adev->mic_mute ? "true" : "false", adev->output, adev->input); if (adev->output != NULL) out_dump((const struct audio_stream *)adev->output, fd); if (adev->input != NULL) in_dump((const struct audio_stream *)adev->input, fd); return 0; } static int adev_close(hw_device_t *dev) { struct generic_audio_device *adev = (struct generic_audio_device *)dev; adev_close_output_stream((struct audio_hw_device *)dev, adev->output); adev_close_input_stream((struct audio_hw_device *)dev, adev->input); free(dev); return 0; } static int adev_open(const hw_module_t *module, const char *name, hw_device_t **device) { struct generic_audio_device *adev; if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0) return -EINVAL; adev = (struct generic_audio_device*) calloc(1, sizeof(struct generic_audio_device)); adev->device.common.tag = HARDWARE_DEVICE_TAG; adev->device.common.version = AUDIO_DEVICE_API_VERSION_2_0; adev->device.common.module = (struct hw_module_t *)module; adev->device.common.close = adev_close; adev->device.init_check = adev_init_check; adev->device.set_voice_volume = adev_set_voice_volume; adev->device.set_master_volume = adev_set_master_volume; adev->device.get_master_volume = adev_get_master_volume; adev->device.set_master_mute = adev_set_master_mute; adev->device.get_master_mute = adev_get_master_mute; adev->device.set_mode = adev_set_mode; adev->device.set_mic_mute = adev_set_mic_mute; adev->device.get_mic_mute = adev_get_mic_mute; adev->device.set_parameters = adev_set_parameters; adev->device.get_parameters = adev_get_parameters; adev->device.get_input_buffer_size = adev_get_input_buffer_size; adev->device.open_output_stream = adev_open_output_stream; adev->device.close_output_stream = adev_close_output_stream; adev->device.open_input_stream = adev_open_input_stream; adev->device.close_input_stream = adev_close_input_stream; adev->device.dump = adev_dump; *device = &adev->device.common; return 0; } static struct hw_module_methods_t hal_module_methods = { .open = adev_open, }; struct audio_module HAL_MODULE_INFO_SYM = { .common = { .tag = HARDWARE_MODULE_TAG, .module_api_version = AUDIO_MODULE_API_VERSION_0_1, .hal_api_version = HARDWARE_HAL_API_VERSION, .id = AUDIO_HARDWARE_MODULE_ID, .name = "Anbox audio HW HAL", .author = "The Android Open Source Project", .methods = &hal_module_methods, }, }; anbox-0.0~git20191115/android/camera/000077500000000000000000000000001356361734700170755ustar00rootroot00000000000000anbox-0.0~git20191115/android/camera/Android.mk000066400000000000000000000105701356361734700210110ustar00rootroot00000000000000# Copyright (C) 2011 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) # Emulator camera module######################################################## emulator_camera_module_relative_path := hw emulator_camera_cflags := -fno-short-enums -DQEMU_HARDWARE emulator_camera_cflags += -Wno-unused-parameter -Wno-missing-field-initializers emulator_camera_clang_flags := -Wno-c++11-narrowing emulator_camera_shared_libraries := \ libbinder \ liblog \ libutils \ libcutils \ libcamera_client \ libui \ libdl \ libjpeg \ libcamera_metadata emulator_camera_c_includes := external/jpeg \ frameworks/native/include/media/hardware \ $(LOCAL_PATH)/../opengl/system/OpenglSystemCommon \ $(call include-path-for, camera) emulator_camera_src := \ EmulatedCameraHal.cpp \ EmulatedCameraFactory.cpp \ EmulatedCameraHotplugThread.cpp \ EmulatedBaseCamera.cpp \ EmulatedCamera.cpp \ EmulatedCameraDevice.cpp \ EmulatedQemuCamera.cpp \ EmulatedQemuCameraDevice.cpp \ EmulatedFakeCamera.cpp \ EmulatedFakeCameraDevice.cpp \ Converters.cpp \ PreviewWindow.cpp \ CallbackNotifier.cpp \ QemuClient.cpp \ JpegCompressor.cpp \ EmulatedCamera2.cpp \ EmulatedFakeCamera2.cpp \ EmulatedQemuCamera2.cpp \ fake-pipeline2/Scene.cpp \ fake-pipeline2/Sensor.cpp \ fake-pipeline2/JpegCompressor.cpp \ EmulatedCamera3.cpp \ EmulatedFakeCamera3.cpp # Emulated camera - goldfish / vbox_x86 build################################### LOCAL_MODULE_RELATIVE_PATH := ${emulator_camera_module_relative_path} LOCAL_CFLAGS := ${emulator_camera_cflags} LOCAL_CLANG_CFLAGS += ${emulator_camera_clang_flags} LOCAL_SHARED_LIBRARIES := ${emulator_camera_shared_libraries} LOCAL_C_INCLUDES += ${emulator_camera_c_includes} LOCAL_SRC_FILES := ${emulator_camera_src} ifeq ($(TARGET_PRODUCT),vbox_x86) LOCAL_MODULE := camera.vbox_x86 else LOCAL_MODULE := camera.goldfish endif include $(BUILD_SHARED_LIBRARY) # Emulator camera - ranchu build################################################ include ${CLEAR_VARS} LOCAL_MODULE_RELATIVE_PATH := ${emulator_camera_module_relative_path} LOCAL_CFLAGS := ${emulator_camera_cflags} LOCAL_CLANG_CFLAGS += ${emulator_camera_clang_flags} LOCAL_SHARED_LIBRARIES := ${emulator_camera_shared_libraries} LOCAL_C_INCLUDES += ${emulator_camera_c_includes} LOCAL_SRC_FILES := ${emulator_camera_src} LOCAL_MODULE := camera.ranchu include $(BUILD_SHARED_LIBRARY) # JPEG stub##################################################################### ifneq ($(TARGET_BUILD_PDK),true) include $(CLEAR_VARS) jpeg_module_relative_path := hw jpeg_cflags := -fno-short-enums -DQEMU_HARDWARE jpeg_cflags += -Wno-unused-parameter jpeg_clang_flags += -Wno-c++11-narrowing jpeg_shared_libraries := \ libcutils \ liblog \ libskia \ libandroid_runtime jpeg_c_includes := external/libjpeg-turbo \ external/skia/include/core/ \ frameworks/base/core/jni/android/graphics \ frameworks/native/include jpeg_src := JpegStub.cpp # JPEG stub - goldfish build#################################################### LOCAL_MODULE_RELATIVE_PATH := ${jpeg_module_relative_path} LOCAL_CFLAGS += ${jpeg_cflags} LOCAL_CLANG_CFLAGS += ${jpeg_clangflags} LOCAL_SHARED_LIBRARIES := ${jpeg_shared_libraries} LOCAL_C_INCLUDES += ${jpeg_c_includes} LOCAL_SRC_FILES := ${jpeg_src} LOCAL_MODULE := camera.goldfish.jpeg include $(BUILD_SHARED_LIBRARY) # JPEG stub - ranchu build###################################################### include ${CLEAR_VARS} LOCAL_MODULE := camera.ranchu.jpeg LOCAL_MODULE_RELATIVE_PATH := ${jpeg_module_relative_path} LOCAL_CFLAGS += ${jpeg_cflags} LOCAL_CLANG_CFLAGS += ${jpeg_clangflags} LOCAL_SHARED_LIBRARIES := ${jpeg_shared_libraries} LOCAL_C_INCLUDES += ${jpeg_c_includes} LOCAL_SRC_FILES := ${jpeg_src} include $(BUILD_SHARED_LIBRARY) endif # !PDK anbox-0.0~git20191115/android/camera/CallbackNotifier.cpp000077500000000000000000000230321356361734700230000ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * Contains implementation of a class CallbackNotifier that manages callbacks set * via set_callbacks, enable_msg_type, and disable_msg_type camera HAL API. */ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_CallbackNotifier" #include #include #include "EmulatedCameraDevice.h" #include "CallbackNotifier.h" #include "JpegCompressor.h" namespace android { /* String representation of camera messages. */ static const char* lCameraMessages[] = { "CAMERA_MSG_ERROR", "CAMERA_MSG_SHUTTER", "CAMERA_MSG_FOCUS", "CAMERA_MSG_ZOOM", "CAMERA_MSG_PREVIEW_FRAME", "CAMERA_MSG_VIDEO_FRAME", "CAMERA_MSG_POSTVIEW_FRAME", "CAMERA_MSG_RAW_IMAGE", "CAMERA_MSG_COMPRESSED_IMAGE", "CAMERA_MSG_RAW_IMAGE_NOTIFY", "CAMERA_MSG_PREVIEW_METADATA" }; static const int lCameraMessagesNum = sizeof(lCameraMessages) / sizeof(char*); /* Builds an array of strings for the given set of messages. * Param: * msg - Messages to get strings for, * strings - Array where to save strings * max - Maximum number of entries in the array. * Return: * Number of strings saved into the 'strings' array. */ static int GetMessageStrings(uint32_t msg, const char** strings, int max) { int index = 0; int out = 0; while (msg != 0 && out < max && index < lCameraMessagesNum) { while ((msg & 0x1) == 0 && index < lCameraMessagesNum) { msg >>= 1; index++; } if ((msg & 0x1) != 0 && index < lCameraMessagesNum) { strings[out] = lCameraMessages[index]; out++; msg >>= 1; index++; } } return out; } /* Logs messages, enabled by the mask. */ static void PrintMessages(uint32_t msg) { const char* strs[lCameraMessagesNum]; const int translated = GetMessageStrings(msg, strs, lCameraMessagesNum); for (int n = 0; n < translated; n++) { ALOGV(" %s", strs[n]); } } CallbackNotifier::CallbackNotifier() : mNotifyCB(NULL), mDataCB(NULL), mDataCBTimestamp(NULL), mGetMemoryCB(NULL), mCBOpaque(NULL), mLastFrameTimestamp(0), mFrameRefreshFreq(0), mMessageEnabler(0), mJpegQuality(90), mVideoRecEnabled(false), mTakingPicture(false) { } CallbackNotifier::~CallbackNotifier() { } /**************************************************************************** * Camera API ***************************************************************************/ void CallbackNotifier::setCallbacks(camera_notify_callback notify_cb, camera_data_callback data_cb, camera_data_timestamp_callback data_cb_timestamp, camera_request_memory get_memory, void* user) { ALOGV("%s: %p, %p, %p, %p (%p)", __FUNCTION__, notify_cb, data_cb, data_cb_timestamp, get_memory, user); Mutex::Autolock locker(&mObjectLock); mNotifyCB = notify_cb; mDataCB = data_cb; mDataCBTimestamp = data_cb_timestamp; mGetMemoryCB = get_memory; mCBOpaque = user; } void CallbackNotifier::enableMessage(uint msg_type) { ALOGV("%s: msg_type = 0x%x", __FUNCTION__, msg_type); PrintMessages(msg_type); Mutex::Autolock locker(&mObjectLock); mMessageEnabler |= msg_type; ALOGV("**** Currently enabled messages:"); PrintMessages(mMessageEnabler); } void CallbackNotifier::disableMessage(uint msg_type) { ALOGV("%s: msg_type = 0x%x", __FUNCTION__, msg_type); PrintMessages(msg_type); Mutex::Autolock locker(&mObjectLock); mMessageEnabler &= ~msg_type; ALOGV("**** Currently enabled messages:"); PrintMessages(mMessageEnabler); } status_t CallbackNotifier::enableVideoRecording(int fps) { ALOGV("%s: FPS = %d", __FUNCTION__, fps); Mutex::Autolock locker(&mObjectLock); mVideoRecEnabled = true; mLastFrameTimestamp = 0; mFrameRefreshFreq = 1000000000LL / fps; return NO_ERROR; } void CallbackNotifier::disableVideoRecording() { ALOGV("%s:", __FUNCTION__); Mutex::Autolock locker(&mObjectLock); mVideoRecEnabled = false; mLastFrameTimestamp = 0; mFrameRefreshFreq = 0; } void CallbackNotifier::releaseRecordingFrame(const void* opaque) { List::iterator it = mCameraMemoryTs.begin(); for( ; it != mCameraMemoryTs.end(); ++it ) { if ( (*it)->data == opaque ) { (*it)->release( *it ); mCameraMemoryTs.erase(it); break; } } } status_t CallbackNotifier::storeMetaDataInBuffers(bool enable) { // Return error if metadata is request, otherwise silently agree. return enable ? INVALID_OPERATION : NO_ERROR; } /**************************************************************************** * Public API ***************************************************************************/ void CallbackNotifier::cleanupCBNotifier() { Mutex::Autolock locker(&mObjectLock); mMessageEnabler = 0; mNotifyCB = NULL; mDataCB = NULL; mDataCBTimestamp = NULL; mGetMemoryCB = NULL; mCBOpaque = NULL; mLastFrameTimestamp = 0; mFrameRefreshFreq = 0; mJpegQuality = 90; mVideoRecEnabled = false; mTakingPicture = false; } void CallbackNotifier::onNextFrameAvailable(const void* frame, nsecs_t timestamp, EmulatedCameraDevice* camera_dev) { if (isMessageEnabled(CAMERA_MSG_VIDEO_FRAME) && isVideoRecordingEnabled() && isNewVideoFrameTime(timestamp)) { camera_memory_t* cam_buff = mGetMemoryCB(-1, camera_dev->getFrameBufferSize(), 1, NULL); if (NULL != cam_buff && NULL != cam_buff->data) { memcpy(cam_buff->data, frame, camera_dev->getFrameBufferSize()); mDataCBTimestamp(timestamp, CAMERA_MSG_VIDEO_FRAME, cam_buff, 0, mCBOpaque); mCameraMemoryTs.push_back( cam_buff ); } else { ALOGE("%s: Memory failure in CAMERA_MSG_VIDEO_FRAME", __FUNCTION__); } } if (isMessageEnabled(CAMERA_MSG_PREVIEW_FRAME)) { camera_memory_t* cam_buff = mGetMemoryCB(-1, camera_dev->getFrameBufferSize(), 1, NULL); if (NULL != cam_buff && NULL != cam_buff->data) { memcpy(cam_buff->data, frame, camera_dev->getFrameBufferSize()); mDataCB(CAMERA_MSG_PREVIEW_FRAME, cam_buff, 0, NULL, mCBOpaque); cam_buff->release(cam_buff); } else { ALOGE("%s: Memory failure in CAMERA_MSG_PREVIEW_FRAME", __FUNCTION__); } } if (mTakingPicture) { /* This happens just once. */ mTakingPicture = false; /* The sequence of callbacks during picture taking is: * - CAMERA_MSG_SHUTTER * - CAMERA_MSG_RAW_IMAGE_NOTIFY * - CAMERA_MSG_COMPRESSED_IMAGE */ if (isMessageEnabled(CAMERA_MSG_SHUTTER)) { mNotifyCB(CAMERA_MSG_SHUTTER, 0, 0, mCBOpaque); } if (isMessageEnabled(CAMERA_MSG_RAW_IMAGE_NOTIFY)) { mNotifyCB(CAMERA_MSG_RAW_IMAGE_NOTIFY, 0, 0, mCBOpaque); } if (isMessageEnabled(CAMERA_MSG_COMPRESSED_IMAGE)) { /* Compress the frame to JPEG. Note that when taking pictures, we * have requested camera device to provide us with NV21 frames. */ NV21JpegCompressor compressor; status_t res = compressor.compressRawImage(frame, camera_dev->getFrameWidth(), camera_dev->getFrameHeight(), mJpegQuality); if (res == NO_ERROR) { camera_memory_t* jpeg_buff = mGetMemoryCB(-1, compressor.getCompressedSize(), 1, NULL); if (NULL != jpeg_buff && NULL != jpeg_buff->data) { compressor.getCompressedImage(jpeg_buff->data); mDataCB(CAMERA_MSG_COMPRESSED_IMAGE, jpeg_buff, 0, NULL, mCBOpaque); jpeg_buff->release(jpeg_buff); } else { ALOGE("%s: Memory failure in CAMERA_MSG_VIDEO_FRAME", __FUNCTION__); } } else { ALOGE("%s: Compression failure in CAMERA_MSG_VIDEO_FRAME", __FUNCTION__); } } } } void CallbackNotifier::onCameraDeviceError(int err) { if (isMessageEnabled(CAMERA_MSG_ERROR) && mNotifyCB != NULL) { mNotifyCB(CAMERA_MSG_ERROR, err, 0, mCBOpaque); } } /**************************************************************************** * Private API ***************************************************************************/ bool CallbackNotifier::isNewVideoFrameTime(nsecs_t timestamp) { Mutex::Autolock locker(&mObjectLock); if ((timestamp - mLastFrameTimestamp) >= mFrameRefreshFreq) { mLastFrameTimestamp = timestamp; return true; } return false; } }; /* namespace android */ anbox-0.0~git20191115/android/camera/CallbackNotifier.h000077500000000000000000000220211356361734700224420ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef HW_EMULATOR_CAMERA_CALLBACK_NOTIFIER_H #define HW_EMULATOR_CAMERA_CALLBACK_NOTIFIER_H /* * Contains declaration of a class CallbackNotifier that manages callbacks set * via set_callbacks, enable_msg_type, and disable_msg_type camera HAL API. */ #include namespace android { class EmulatedCameraDevice; /* Manages callbacks set via set_callbacks, enable_msg_type, and disable_msg_type * camera HAL API. * * Objects of this class are contained in EmulatedCamera objects, and handle * relevant camera API callbacks. * Locking considerations. Apparently, it's not allowed to call callbacks * registered in this class, while holding a lock: recursion is quite possible, * which will cause a deadlock. */ class CallbackNotifier { public: /* Constructs CallbackNotifier instance. */ CallbackNotifier(); /* Destructs CallbackNotifier instance. */ ~CallbackNotifier(); /**************************************************************************** * Camera API ***************************************************************************/ public: /* Actual handler for camera_device_ops_t::set_callbacks callback. * This method is called by the containing emulated camera object when it is * handing the camera_device_ops_t::set_callbacks callback. */ void setCallbacks(camera_notify_callback notify_cb, camera_data_callback data_cb, camera_data_timestamp_callback data_cb_timestamp, camera_request_memory get_memory, void* user); /* Actual handler for camera_device_ops_t::enable_msg_type callback. * This method is called by the containing emulated camera object when it is * handing the camera_device_ops_t::enable_msg_type callback. */ void enableMessage(uint msg_type); /* Actual handler for camera_device_ops_t::disable_msg_type callback. * This method is called by the containing emulated camera object when it is * handing the camera_device_ops_t::disable_msg_type callback. */ void disableMessage(uint msg_type); /* Actual handler for camera_device_ops_t::store_meta_data_in_buffers * callback. This method is called by the containing emulated camera object * when it is handing the camera_device_ops_t::store_meta_data_in_buffers * callback. * Return: * NO_ERROR on success, or an appropriate error status. */ status_t storeMetaDataInBuffers(bool enable); /* Enables video recording. * This method is called by the containing emulated camera object when it is * handing the camera_device_ops_t::start_recording callback. * Param: * fps - Video frame frequency. This parameter determins when a frame * received via onNextFrameAvailable call will be pushed through the * callback. * Return: * NO_ERROR on success, or an appropriate error status. */ status_t enableVideoRecording(int fps); /* Disables video recording. * This method is called by the containing emulated camera object when it is * handing the camera_device_ops_t::stop_recording callback. */ void disableVideoRecording(); /* Releases video frame, sent to the framework. * This method is called by the containing emulated camera object when it is * handing the camera_device_ops_t::release_recording_frame callback. */ void releaseRecordingFrame(const void* opaque); /* Actual handler for camera_device_ops_t::msg_type_enabled callback. * This method is called by the containing emulated camera object when it is * handing the camera_device_ops_t::msg_type_enabled callback. * Note: this method doesn't grab a lock while checking message status, since * upon exit the status would be undefined anyway. So, grab a lock before * calling this method if you care about persisting a defined message status. * Return: * 0 if message is disabled, or non-zero value, if message is enabled. */ inline int isMessageEnabled(uint msg_type) { return mMessageEnabler & msg_type; } /* Checks id video recording is enabled. * This method is called by the containing emulated camera object when it is * handing the camera_device_ops_t::recording_enabled callback. * Note: this method doesn't grab a lock while checking video recordin status, * since upon exit the status would be undefined anyway. So, grab a lock * before calling this method if you care about persisting of a defined video * recording status. * Return: * true if video recording is enabled, or false if it is disabled. */ inline bool isVideoRecordingEnabled() { return mVideoRecEnabled; } /**************************************************************************** * Public API ***************************************************************************/ public: /* Resets the callback notifier. */ void cleanupCBNotifier(); /* Next frame is available in the camera device. * This is a notification callback that is invoked by the camera device when * a new frame is available. * Note that most likely this method is called in context of a worker thread * that camera device has created for frame capturing. * Param: * frame - Captured frame, or NULL if camera device didn't pull the frame * yet. If NULL is passed in this parameter use GetCurrentFrame method * of the camera device class to obtain the next frame. Also note that * the size of the frame that is passed here (as well as the frame * returned from the GetCurrentFrame method) is defined by the current * frame settings (width + height + pixel format) for the camera device. * timestamp - Frame's timestamp. * camera_dev - Camera device instance that delivered the frame. */ void onNextFrameAvailable(const void* frame, nsecs_t timestamp, EmulatedCameraDevice* camera_dev); /* Entry point for notifications that occur in camera device. * Param: * err - CAMERA_ERROR_XXX error code. */ void onCameraDeviceError(int err); /* Sets, or resets taking picture state. * This state control whether or not to notify the framework about compressed * image, shutter, and other picture related events. */ void setTakingPicture(bool taking) { mTakingPicture = taking; } /* Sets JPEG quality used to compress frame during picture taking. */ void setJpegQuality(int jpeg_quality) { mJpegQuality = jpeg_quality; } /**************************************************************************** * Private API ***************************************************************************/ protected: /* Checks if it's time to push new video frame. * Note that this method must be called while object is locked. * Param: * timestamp - Timestamp for the new frame. */ bool isNewVideoFrameTime(nsecs_t timestamp); /**************************************************************************** * Data members ***************************************************************************/ protected: /* Locks this instance for data change. */ Mutex mObjectLock; /* * Callbacks, registered in set_callbacks. */ camera_notify_callback mNotifyCB; camera_data_callback mDataCB; camera_data_timestamp_callback mDataCBTimestamp; camera_request_memory mGetMemoryCB; void* mCBOpaque; /* video frame queue for the CameraHeapMemory destruction */ List mCameraMemoryTs; /* Timestamp when last frame has been delivered to the framework. */ nsecs_t mLastFrameTimestamp; /* Video frequency in nanosec. */ nsecs_t mFrameRefreshFreq; /* Message enabler. */ uint32_t mMessageEnabler; /* JPEG quality used to compress frame during picture taking. */ int mJpegQuality; /* Video recording status. */ bool mVideoRecEnabled; /* Picture taking status. */ bool mTakingPicture; }; }; /* namespace android */ #endif /* HW_EMULATOR_CAMERA_CALLBACK_NOTIFIER_H */ anbox-0.0~git20191115/android/camera/Converters.cpp000077500000000000000000000130061356361734700217360ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * Contains implemenation of framebuffer conversion routines. */ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_Converter" #include #include "Converters.h" namespace android { static void _YUV420SToRGB565(const uint8_t* Y, const uint8_t* U, const uint8_t* V, int dUV, uint16_t* rgb, int width, int height) { const uint8_t* U_pos = U; const uint8_t* V_pos = V; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x += 2, U += dUV, V += dUV) { const uint8_t nU = *U; const uint8_t nV = *V; *rgb = YUVToRGB565(*Y, nU, nV); Y++; rgb++; *rgb = YUVToRGB565(*Y, nU, nV); Y++; rgb++; } if (y & 0x1) { U_pos = U; V_pos = V; } else { U = U_pos; V = V_pos; } } } static void _YUV420SToRGB32(const uint8_t* Y, const uint8_t* U, const uint8_t* V, int dUV, uint32_t* rgb, int width, int height) { const uint8_t* U_pos = U; const uint8_t* V_pos = V; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x += 2, U += dUV, V += dUV) { const uint8_t nU = *U; const uint8_t nV = *V; *rgb = YUVToRGB32(*Y, nU, nV); Y++; rgb++; *rgb = YUVToRGB32(*Y, nU, nV); Y++; rgb++; } if (y & 0x1) { U_pos = U; V_pos = V; } else { U = U_pos; V = V_pos; } } } void YV12ToRGB565(const void* yv12, void* rgb, int width, int height) { const int pix_total = width * height; const uint8_t* Y = reinterpret_cast(yv12); const uint8_t* U = Y + pix_total; const uint8_t* V = U + pix_total / 4; _YUV420SToRGB565(Y, U, V, 1, reinterpret_cast(rgb), width, height); } void YV12ToRGB32(const void* yv12, void* rgb, int width, int height) { const int pix_total = width * height; const uint8_t* Y = reinterpret_cast(yv12); const uint8_t* V = Y + pix_total; const uint8_t* U = V + pix_total / 4; _YUV420SToRGB32(Y, U, V, 1, reinterpret_cast(rgb), width, height); } void YU12ToRGB32(const void* yu12, void* rgb, int width, int height) { const int pix_total = width * height; const uint8_t* Y = reinterpret_cast(yu12); const uint8_t* U = Y + pix_total; const uint8_t* V = U + pix_total / 4; _YUV420SToRGB32(Y, U, V, 1, reinterpret_cast(rgb), width, height); } /* Common converter for YUV 4:2:0 interleaved to RGB565. * y, u, and v point to Y,U, and V panes, where U and V values are interleaved. */ static void _NVXXToRGB565(const uint8_t* Y, const uint8_t* U, const uint8_t* V, uint16_t* rgb, int width, int height) { _YUV420SToRGB565(Y, U, V, 2, rgb, width, height); } /* Common converter for YUV 4:2:0 interleaved to RGB32. * y, u, and v point to Y,U, and V panes, where U and V values are interleaved. */ static void _NVXXToRGB32(const uint8_t* Y, const uint8_t* U, const uint8_t* V, uint32_t* rgb, int width, int height) { _YUV420SToRGB32(Y, U, V, 2, rgb, width, height); } void NV12ToRGB565(const void* nv12, void* rgb, int width, int height) { const int pix_total = width * height; const uint8_t* y = reinterpret_cast(nv12); _NVXXToRGB565(y, y + pix_total, y + pix_total + 1, reinterpret_cast(rgb), width, height); } void NV12ToRGB32(const void* nv12, void* rgb, int width, int height) { const int pix_total = width * height; const uint8_t* y = reinterpret_cast(nv12); _NVXXToRGB32(y, y + pix_total, y + pix_total + 1, reinterpret_cast(rgb), width, height); } void NV21ToRGB565(const void* nv21, void* rgb, int width, int height) { const int pix_total = width * height; const uint8_t* y = reinterpret_cast(nv21); _NVXXToRGB565(y, y + pix_total + 1, y + pix_total, reinterpret_cast(rgb), width, height); } void NV21ToRGB32(const void* nv21, void* rgb, int width, int height) { const int pix_total = width * height; const uint8_t* y = reinterpret_cast(nv21); _NVXXToRGB32(y, y + pix_total + 1, y + pix_total, reinterpret_cast(rgb), width, height); } }; /* namespace android */ anbox-0.0~git20191115/android/camera/Converters.h000077500000000000000000000247711356361734700214160ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef HW_EMULATOR_CAMERA_CONVERTERS_H #define HW_EMULATOR_CAMERA_CONVERTERS_H #include #ifndef __BYTE_ORDER #error "could not determine byte order" #endif /* * Contains declaration of framebuffer conversion routines. * * NOTE: RGB and big/little endian considerations. Wherewer in this code RGB * pixels are represented as WORD, or DWORD, the color order inside the * WORD / DWORD matches the one that would occur if that WORD / DWORD would have * been read from the typecasted framebuffer: * * const uint32_t rgb = *reinterpret_cast(framebuffer); * * So, if this code runs on the little endian CPU, red color in 'rgb' would be * masked as 0x000000ff, and blue color would be masked as 0x00ff0000, while if * the code runs on a big endian CPU, the red color in 'rgb' would be masked as * 0xff000000, and blue color would be masked as 0x0000ff00, */ namespace android { /* * RGB565 color masks */ #if __BYTE_ORDER == __LITTLE_ENDIAN static const uint16_t kRed5 = 0x001f; static const uint16_t kGreen6 = 0x07e0; static const uint16_t kBlue5 = 0xf800; #else // __BYTE_ORDER static const uint16_t kRed5 = 0xf800; static const uint16_t kGreen6 = 0x07e0; static const uint16_t kBlue5 = 0x001f; #endif // __BYTE_ORDER static const uint32_t kBlack16 = 0x0000; static const uint32_t kWhite16 = kRed5 | kGreen6 | kBlue5; /* * RGB32 color masks */ #if __BYTE_ORDER == __LITTLE_ENDIAN static const uint32_t kRed8 = 0x000000ff; static const uint32_t kGreen8 = 0x0000ff00; static const uint32_t kBlue8 = 0x00ff0000; #else // __BYTE_ORDER static const uint32_t kRed8 = 0x00ff0000; static const uint32_t kGreen8 = 0x0000ff00; static const uint32_t kBlue8 = 0x000000ff; #endif // __BYTE_ORDER static const uint32_t kBlack32 = 0x00000000; static const uint32_t kWhite32 = kRed8 | kGreen8 | kBlue8; /* * Extracting, and saving color bytes from / to WORD / DWORD RGB. */ #if __BYTE_ORDER == __LITTLE_ENDIAN /* Extract red, green, and blue bytes from RGB565 word. */ #define R16(rgb) static_cast(rgb & kRed5) #define G16(rgb) static_cast((rgb & kGreen6) >> 5) #define B16(rgb) static_cast((rgb & kBlue5) >> 11) /* Make 8 bits red, green, and blue, extracted from RGB565 word. */ #define R16_32(rgb) static_cast(((rgb & kRed5) << 3) | ((rgb & kRed5) >> 2)) #define G16_32(rgb) static_cast(((rgb & kGreen6) >> 3) | ((rgb & kGreen6) >> 9)) #define B16_32(rgb) static_cast(((rgb & kBlue5) >> 8) | ((rgb & kBlue5) >> 14)) /* Extract red, green, and blue bytes from RGB32 dword. */ #define R32(rgb) static_cast(rgb & kRed8) #define G32(rgb) static_cast(((rgb & kGreen8) >> 8) & 0xff) #define B32(rgb) static_cast(((rgb & kBlue8) >> 16) & 0xff) /* Build RGB565 word from red, green, and blue bytes. */ #define RGB565(r, g, b) static_cast((((static_cast(b) << 6) | g) << 5) | r) /* Build RGB32 dword from red, green, and blue bytes. */ #define RGB32(r, g, b) static_cast((((static_cast(b) << 8) | g) << 8) | r) #else // __BYTE_ORDER /* Extract red, green, and blue bytes from RGB565 word. */ #define R16(rgb) static_cast((rgb & kRed5) >> 11) #define G16(rgb) static_cast((rgb & kGreen6) >> 5) #define B16(rgb) static_cast(rgb & kBlue5) /* Make 8 bits red, green, and blue, extracted from RGB565 word. */ #define R16_32(rgb) static_cast(((rgb & kRed5) >> 8) | ((rgb & kRed5) >> 14)) #define G16_32(rgb) static_cast(((rgb & kGreen6) >> 3) | ((rgb & kGreen6) >> 9)) #define B16_32(rgb) static_cast(((rgb & kBlue5) << 3) | ((rgb & kBlue5) >> 2)) /* Extract red, green, and blue bytes from RGB32 dword. */ #define R32(rgb) static_cast((rgb & kRed8) >> 16) #define G32(rgb) static_cast((rgb & kGreen8) >> 8) #define B32(rgb) static_cast(rgb & kBlue8) /* Build RGB565 word from red, green, and blue bytes. */ #define RGB565(r, g, b) static_cast((((static_cast(r) << 6) | g) << 5) | b) /* Build RGB32 dword from red, green, and blue bytes. */ #define RGB32(r, g, b) static_cast((((static_cast(r) << 8) | g) << 8) | b) #endif // __BYTE_ORDER /* An union that simplifies breaking 32 bit RGB into separate R, G, and B colors. */ typedef union RGB32_t { uint32_t color; struct { #if __BYTE_ORDER == __LITTLE_ENDIAN uint8_t r; uint8_t g; uint8_t b; uint8_t a; #else // __BYTE_ORDER uint8_t a; uint8_t b; uint8_t g; uint8_t r; #endif // __BYTE_ORDER }; } RGB32_t; /* Clips a value to the unsigned 0-255 range, treating negative values as zero. */ static __inline__ int clamp(int x) { if (x > 255) return 255; if (x < 0) return 0; return x; } /******************************************************************************** * Basics of RGB -> YUV conversion *******************************************************************************/ /* * RGB -> YUV conversion macros */ #define RGB2Y(r, g, b) (uint8_t)(((66 * (r) + 129 * (g) + 25 * (b) + 128) >> 8) + 16) #define RGB2U(r, g, b) (uint8_t)(((-38 * (r) - 74 * (g) + 112 * (b) + 128) >> 8) + 128) #define RGB2V(r, g, b) (uint8_t)(((112 * (r) - 94 * (g) - 18 * (b) + 128) >> 8) + 128) /* Converts R8 G8 B8 color to YUV. */ static __inline__ void R8G8B8ToYUV(uint8_t r, uint8_t g, uint8_t b, uint8_t* y, uint8_t* u, uint8_t* v) { *y = RGB2Y((int)r, (int)g, (int)b); *u = RGB2U((int)r, (int)g, (int)b); *v = RGB2V((int)r, (int)g, (int)b); } /* Converts RGB565 color to YUV. */ static __inline__ void RGB565ToYUV(uint16_t rgb, uint8_t* y, uint8_t* u, uint8_t* v) { R8G8B8ToYUV(R16_32(rgb), G16_32(rgb), B16_32(rgb), y, u, v); } /* Converts RGB32 color to YUV. */ static __inline__ void RGB32ToYUV(uint32_t rgb, uint8_t* y, uint8_t* u, uint8_t* v) { RGB32_t rgb_c; rgb_c.color = rgb; R8G8B8ToYUV(rgb_c.r, rgb_c.g, rgb_c.b, y, u, v); } /******************************************************************************** * Basics of YUV -> RGB conversion. * Note that due to the fact that guest uses RGB only on preview window, and the * RGB format that is used is RGB565, we can limit YUV -> RGB conversions to * RGB565 only. *******************************************************************************/ /* * YUV -> RGB conversion macros */ /* "Optimized" macros that take specialy prepared Y, U, and V values: * C = Y - 16 * D = U - 128 * E = V - 128 */ #define YUV2RO(C, D, E) clamp((298 * (C) + 409 * (E) + 128) >> 8) #define YUV2GO(C, D, E) clamp((298 * (C) - 100 * (D) - 208 * (E) + 128) >> 8) #define YUV2BO(C, D, E) clamp((298 * (C) + 516 * (D) + 128) >> 8) /* * Main macros that take the original Y, U, and V values */ #define YUV2R(y, u, v) clamp((298 * ((y)-16) + 409 * ((v)-128) + 128) >> 8) #define YUV2G(y, u, v) clamp((298 * ((y)-16) - 100 * ((u)-128) - 208 * ((v)-128) + 128) >> 8) #define YUV2B(y, u, v) clamp((298 * ((y)-16) + 516 * ((u)-128) + 128) >> 8) /* Converts YUV color to RGB565. */ static __inline__ uint16_t YUVToRGB565(int y, int u, int v) { /* Calculate C, D, and E values for the optimized macro. */ y -= 16; u -= 128; v -= 128; const uint16_t r = (YUV2RO(y,u,v) >> 3) & 0x1f; const uint16_t g = (YUV2GO(y,u,v) >> 2) & 0x3f; const uint16_t b = (YUV2BO(y,u,v) >> 3) & 0x1f; return RGB565(r, g, b); } /* Converts YUV color to RGB32. */ static __inline__ uint32_t YUVToRGB32(int y, int u, int v) { /* Calculate C, D, and E values for the optimized macro. */ y -= 16; u -= 128; v -= 128; RGB32_t rgb; rgb.r = YUV2RO(y,u,v) & 0xff; rgb.g = YUV2GO(y,u,v) & 0xff; rgb.b = YUV2BO(y,u,v) & 0xff; return rgb.color; } /* YUV pixel descriptor. */ struct YUVPixel { uint8_t Y; uint8_t U; uint8_t V; inline YUVPixel() : Y(0), U(0), V(0) { } inline explicit YUVPixel(uint16_t rgb565) { RGB565ToYUV(rgb565, &Y, &U, &V); } inline explicit YUVPixel(uint32_t rgb32) { RGB32ToYUV(rgb32, &Y, &U, &V); } inline void get(uint8_t* pY, uint8_t* pU, uint8_t* pV) const { *pY = Y; *pU = U; *pV = V; } }; /* Converts an YV12 framebuffer to RGB565 framebuffer. * Param: * yv12 - YV12 framebuffer. * rgb - RGB565 framebuffer. * width, height - Dimensions for both framebuffers. */ void YV12ToRGB565(const void* yv12, void* rgb, int width, int height); /* Converts an YV12 framebuffer to RGB32 framebuffer. * Param: * yv12 - YV12 framebuffer. * rgb - RGB32 framebuffer. * width, height - Dimensions for both framebuffers. */ void YV12ToRGB32(const void* yv12, void* rgb, int width, int height); /* Converts an YU12 framebuffer to RGB32 framebuffer. * Param: * yu12 - YU12 framebuffer. * rgb - RGB32 framebuffer. * width, height - Dimensions for both framebuffers. */ void YU12ToRGB32(const void* yu12, void* rgb, int width, int height); /* Converts an NV12 framebuffer to RGB565 framebuffer. * Param: * nv12 - NV12 framebuffer. * rgb - RGB565 framebuffer. * width, height - Dimensions for both framebuffers. */ void NV12ToRGB565(const void* nv12, void* rgb, int width, int height); /* Converts an NV12 framebuffer to RGB32 framebuffer. * Param: * nv12 - NV12 framebuffer. * rgb - RGB32 framebuffer. * width, height - Dimensions for both framebuffers. */ void NV12ToRGB32(const void* nv12, void* rgb, int width, int height); /* Converts an NV21 framebuffer to RGB565 framebuffer. * Param: * nv21 - NV21 framebuffer. * rgb - RGB565 framebuffer. * width, height - Dimensions for both framebuffers. */ void NV21ToRGB565(const void* nv21, void* rgb, int width, int height); /* Converts an NV21 framebuffer to RGB32 framebuffer. * Param: * nv21 - NV21 framebuffer. * rgb - RGB32 framebuffer. * width, height - Dimensions for both framebuffers. */ void NV21ToRGB32(const void* nv21, void* rgb, int width, int height); }; /* namespace android */ #endif /* HW_EMULATOR_CAMERA_CONVERTERS_H */ anbox-0.0~git20191115/android/camera/EmulatedBaseCamera.cpp000066400000000000000000000051051356361734700232460ustar00rootroot00000000000000/* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * Contains implementation of a class EmulatedBaseCamera that encapsulates * functionality common to all emulated camera device versions ("fake", * "webcam", "video file", "cam2.0" etc.). Instances of this class (for each * emulated camera) are created during the construction of the * EmulatedCameraFactory instance. This class serves as an entry point for all * camera API calls that are common across all versions of the * camera_device_t/camera_module_t structures. */ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_BaseCamera" #include #include "EmulatedBaseCamera.h" namespace android { EmulatedBaseCamera::EmulatedBaseCamera(int cameraId, uint32_t cameraVersion, struct hw_device_t* device, struct hw_module_t* module) : mCameraInfo(NULL), mCameraID(cameraId), mCameraDeviceVersion(cameraVersion) { /* * Initialize camera_device descriptor for this object. */ /* Common header */ device->tag = HARDWARE_DEVICE_TAG; device->version = cameraVersion; device->module = module; device->close = NULL; // Must be filled in by child implementation } EmulatedBaseCamera::~EmulatedBaseCamera() { } status_t EmulatedBaseCamera::getCameraInfo(struct camera_info* info) { ALOGV("%s", __FUNCTION__); info->device_version = mCameraDeviceVersion; if (mCameraDeviceVersion >= HARDWARE_DEVICE_API_VERSION(2, 0)) { info->static_camera_characteristics = mCameraInfo; } else { info->static_camera_characteristics = (camera_metadata_t*)0xcafef00d; } return NO_ERROR; } status_t EmulatedBaseCamera::plugCamera() { ALOGE("%s: not supported", __FUNCTION__); return INVALID_OPERATION; } status_t EmulatedBaseCamera::unplugCamera() { ALOGE("%s: not supported", __FUNCTION__); return INVALID_OPERATION; } camera_device_status_t EmulatedBaseCamera::getHotplugStatus() { return CAMERA_DEVICE_STATUS_PRESENT; } } /* namespace android */ anbox-0.0~git20191115/android/camera/EmulatedBaseCamera.h000066400000000000000000000102511356361734700227110ustar00rootroot00000000000000/* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef HW_EMULATOR_CAMERA_EMULATED_BASE_CAMERA_H #define HW_EMULATOR_CAMERA_EMULATED_BASE_CAMERA_H #include #include namespace android { /* * Contains declaration of a class EmulatedBaseCamera that encapsulates * functionality common to all emulated camera device versions ("fake", * "webcam", "video file", etc.). Instances of this class (for each emulated * camera) are created during the construction of the EmulatedCameraFactory * instance. This class serves as an entry point for all camera API calls that * are common across all versions of the camera_device_t/camera_module_t * structures. */ class EmulatedBaseCamera { public: EmulatedBaseCamera(int cameraId, uint32_t cameraVersion, struct hw_device_t* device, struct hw_module_t* module); virtual ~EmulatedBaseCamera(); /**************************************************************************** * Public API ***************************************************************************/ public: /* Initializes EmulatedCamera instance. * Return: * NO_ERROR on success, or an appropriate error status on failure. */ virtual status_t Initialize() = 0; /**************************************************************************** * Camera API implementation ***************************************************************************/ public: /* Creates connection to the emulated camera device. * This method is called in response to hw_module_methods_t::open callback. * NOTE: When this method is called the object is locked. * Note that failures in this method are reported as negative EXXX statuses. */ virtual status_t connectCamera(hw_device_t** device) = 0; /* Plug the connection for the emulated camera. Until it's plugged in * calls to connectCamera should fail with -ENODEV. */ virtual status_t plugCamera(); /* Unplug the connection from underneath the emulated camera. * This is similar to closing the camera, except that * all function calls into the camera device will return * -EPIPE errors until the camera is reopened. */ virtual status_t unplugCamera(); virtual camera_device_status_t getHotplugStatus(); /* Closes connection to the emulated camera. * This method is called in response to camera_device::close callback. * NOTE: When this method is called the object is locked. * Note that failures in this method are reported as negative EXXX statuses. */ virtual status_t closeCamera() = 0; /* Gets camera information. * This method is called in response to camera_module_t::get_camera_info * callback. * NOTE: When this method is called the object is locked. * Note that failures in this method are reported as negative EXXX statuses. */ virtual status_t getCameraInfo(struct camera_info* info) = 0; /**************************************************************************** * Data members ***************************************************************************/ protected: /* Fixed camera information for camera2 devices. Must be valid to access if * mCameraDeviceVersion is >= HARDWARE_DEVICE_API_VERSION(2,0) */ camera_metadata_t *mCameraInfo; /* Zero-based ID assigned to this camera. */ int mCameraID; private: /* Version of the camera device HAL implemented by this camera */ int mCameraDeviceVersion; }; } /* namespace android */ #endif /* HW_EMULATOR_CAMERA_EMULATED_BASE_CAMERA_H */ anbox-0.0~git20191115/android/camera/EmulatedCamera.cpp000077500000000000000000001025021356361734700224550ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * Contains implementation of a class EmulatedCamera that encapsulates * functionality common to all emulated cameras ("fake", "webcam", "video file", * etc.). Instances of this class (for each emulated camera) are created during * the construction of the EmulatedCameraFactory instance. This class serves as * an entry point for all camera API calls that defined by camera_device_ops_t * API. */ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_Camera" #include #include #include "EmulatedCamera.h" //#include "EmulatedFakeCameraDevice.h" #include "Converters.h" /* Defines whether we should trace parameter changes. */ #define DEBUG_PARAM 1 namespace android { #if DEBUG_PARAM /* Calculates and logs parameter changes. * Param: * current - Current set of camera parameters. * new_par - String representation of new parameters. */ static void PrintParamDiff(const CameraParameters& current, const char* new_par); #else #define PrintParamDiff(current, new_par) (void(0)) #endif /* DEBUG_PARAM */ /* A helper routine that adds a value to the camera parameter. * Param: * param - Camera parameter to add a value to. * val - Value to add. * Return: * A new string containing parameter with the added value on success, or NULL on * a failure. If non-NULL string is returned, the caller is responsible for * freeing it with 'free'. */ static char* AddValue(const char* param, const char* val); EmulatedCamera::EmulatedCamera(int cameraId, struct hw_module_t* module) : EmulatedBaseCamera(cameraId, HARDWARE_DEVICE_API_VERSION(1, 0), &common, module), mPreviewWindow(), mCallbackNotifier() { /* camera_device v1 fields. */ common.close = EmulatedCamera::close; ops = &mDeviceOps; priv = this; } EmulatedCamera::~EmulatedCamera() { } /**************************************************************************** * Public API ***************************************************************************/ status_t EmulatedCamera::Initialize() { /* Preview formats supported by this HAL. */ char preview_formats[1024]; snprintf(preview_formats, sizeof(preview_formats), "%s,%s,%s", CameraParameters::PIXEL_FORMAT_YUV420SP, CameraParameters::PIXEL_FORMAT_YUV420P, CameraParameters::PIXEL_FORMAT_RGBA8888); /* * Fake required parameters. */ mParameters.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, "320x240,0x0"); mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, "512"); mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, "384"); mParameters.set(CameraParameters::KEY_JPEG_QUALITY, "90"); mParameters.set(CameraParameters::KEY_FOCAL_LENGTH, "4.31"); mParameters.set(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, "54.8"); mParameters.set(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, "42.5"); mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, "90"); /* Preview format settings used here are related to panoramic view only. It's * not related to the preview window that works only with RGB frames, which * is explicitly stated when set_buffers_geometry is called on the preview * window object. */ mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, preview_formats); mParameters.setPreviewFormat(CameraParameters::PIXEL_FORMAT_YUV420SP); /* We don't relay on the actual frame rates supported by the camera device, * since we will emulate them through timeouts in the emulated camera device * worker thread. */ mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, "30,24,20,15,10,5"); mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(5,30)"); mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, "5,30"); mParameters.setPreviewFrameRate(24); /* Only PIXEL_FORMAT_YUV420P is accepted by video framework in emulator! */ mParameters.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, CameraParameters::PIXEL_FORMAT_YUV420P); mParameters.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, CameraParameters::PIXEL_FORMAT_JPEG); mParameters.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG); /* Set exposure compensation. */ mParameters.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, "6"); mParameters.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, "-6"); mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, "0.5"); mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, "0"); /* Sets the white balance modes and the device-dependent scale factors. */ char supported_white_balance[1024]; snprintf(supported_white_balance, sizeof(supported_white_balance), "%s,%s,%s,%s", CameraParameters::WHITE_BALANCE_AUTO, CameraParameters::WHITE_BALANCE_INCANDESCENT, CameraParameters::WHITE_BALANCE_DAYLIGHT, CameraParameters::WHITE_BALANCE_TWILIGHT); mParameters.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, supported_white_balance); mParameters.set(CameraParameters::KEY_WHITE_BALANCE, CameraParameters::WHITE_BALANCE_AUTO); getCameraDevice()->initializeWhiteBalanceModes( CameraParameters::WHITE_BALANCE_AUTO, 1.0f, 1.0f); getCameraDevice()->initializeWhiteBalanceModes( CameraParameters::WHITE_BALANCE_INCANDESCENT, 1.38f, 0.60f); getCameraDevice()->initializeWhiteBalanceModes( CameraParameters::WHITE_BALANCE_DAYLIGHT, 1.09f, 0.92f); getCameraDevice()->initializeWhiteBalanceModes( CameraParameters::WHITE_BALANCE_TWILIGHT, 0.92f, 1.22f); getCameraDevice()->setWhiteBalanceMode(CameraParameters::WHITE_BALANCE_AUTO); /* Not supported features */ mParameters.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, CameraParameters::FOCUS_MODE_FIXED); mParameters.set(CameraParameters::KEY_FOCUS_MODE, CameraParameters::FOCUS_MODE_FIXED); return NO_ERROR; } void EmulatedCamera::onNextFrameAvailable(const void* frame, nsecs_t timestamp, EmulatedCameraDevice* camera_dev) { /* Notify the preview window first. */ mPreviewWindow.onNextFrameAvailable(frame, timestamp, camera_dev); /* Notify callback notifier next. */ mCallbackNotifier.onNextFrameAvailable(frame, timestamp, camera_dev); } void EmulatedCamera::onCameraDeviceError(int err) { /* Errors are reported through the callback notifier */ mCallbackNotifier.onCameraDeviceError(err); } /**************************************************************************** * Camera API implementation. ***************************************************************************/ status_t EmulatedCamera::connectCamera(hw_device_t** device) { ALOGV("%s", __FUNCTION__); status_t res = EINVAL; EmulatedCameraDevice* const camera_dev = getCameraDevice(); ALOGE_IF(camera_dev == NULL, "%s: No camera device instance.", __FUNCTION__); if (camera_dev != NULL) { /* Connect to the camera device. */ res = getCameraDevice()->connectDevice(); if (res == NO_ERROR) { *device = &common; } } return -res; } status_t EmulatedCamera::closeCamera() { ALOGV("%s", __FUNCTION__); return cleanupCamera(); } status_t EmulatedCamera::getCameraInfo(struct camera_info* info) { ALOGV("%s", __FUNCTION__); const char* valstr = NULL; valstr = mParameters.get(EmulatedCamera::FACING_KEY); if (valstr != NULL) { if (strcmp(valstr, EmulatedCamera::FACING_FRONT) == 0) { info->facing = CAMERA_FACING_FRONT; } else if (strcmp(valstr, EmulatedCamera::FACING_BACK) == 0) { info->facing = CAMERA_FACING_BACK; } } else { info->facing = CAMERA_FACING_BACK; } valstr = mParameters.get(EmulatedCamera::ORIENTATION_KEY); if (valstr != NULL) { info->orientation = atoi(valstr); } else { info->orientation = 0; } return EmulatedBaseCamera::getCameraInfo(info); } status_t EmulatedCamera::setPreviewWindow(struct preview_stream_ops* window) { /* Callback should return a negative errno. */ return -mPreviewWindow.setPreviewWindow(window, mParameters.getPreviewFrameRate()); } void EmulatedCamera::setCallbacks(camera_notify_callback notify_cb, camera_data_callback data_cb, camera_data_timestamp_callback data_cb_timestamp, camera_request_memory get_memory, void* user) { mCallbackNotifier.setCallbacks(notify_cb, data_cb, data_cb_timestamp, get_memory, user); } void EmulatedCamera::enableMsgType(int32_t msg_type) { mCallbackNotifier.enableMessage(msg_type); } void EmulatedCamera::disableMsgType(int32_t msg_type) { mCallbackNotifier.disableMessage(msg_type); } int EmulatedCamera::isMsgTypeEnabled(int32_t msg_type) { return mCallbackNotifier.isMessageEnabled(msg_type); } status_t EmulatedCamera::startPreview() { /* Callback should return a negative errno. */ return -doStartPreview(); } void EmulatedCamera::stopPreview() { doStopPreview(); } int EmulatedCamera::isPreviewEnabled() { return mPreviewWindow.isPreviewEnabled(); } status_t EmulatedCamera::storeMetaDataInBuffers(int enable) { /* Callback should return a negative errno. */ return -mCallbackNotifier.storeMetaDataInBuffers(enable); } status_t EmulatedCamera::startRecording() { /* Callback should return a negative errno. */ return -mCallbackNotifier.enableVideoRecording(mParameters.getPreviewFrameRate()); } void EmulatedCamera::stopRecording() { mCallbackNotifier.disableVideoRecording(); } int EmulatedCamera::isRecordingEnabled() { return mCallbackNotifier.isVideoRecordingEnabled(); } void EmulatedCamera::releaseRecordingFrame(const void* opaque) { mCallbackNotifier.releaseRecordingFrame(opaque); } status_t EmulatedCamera::setAutoFocus() { ALOGV("%s", __FUNCTION__); /* TODO: Future enhancements. */ return NO_ERROR; } status_t EmulatedCamera::cancelAutoFocus() { ALOGV("%s", __FUNCTION__); /* TODO: Future enhancements. */ return NO_ERROR; } status_t EmulatedCamera::takePicture() { ALOGV("%s", __FUNCTION__); status_t res; int width, height; uint32_t org_fmt; /* Collect frame info for the picture. */ mParameters.getPictureSize(&width, &height); const char* pix_fmt = mParameters.getPictureFormat(); if (strcmp(pix_fmt, CameraParameters::PIXEL_FORMAT_YUV420P) == 0) { org_fmt = V4L2_PIX_FMT_YUV420; } else if (strcmp(pix_fmt, CameraParameters::PIXEL_FORMAT_RGBA8888) == 0) { org_fmt = V4L2_PIX_FMT_RGB32; } else if (strcmp(pix_fmt, CameraParameters::PIXEL_FORMAT_YUV420SP) == 0) { org_fmt = V4L2_PIX_FMT_NV21; } else if (strcmp(pix_fmt, CameraParameters::PIXEL_FORMAT_JPEG) == 0) { /* We only have JPEG converted for NV21 format. */ org_fmt = V4L2_PIX_FMT_NV21; } else { ALOGE("%s: Unsupported pixel format %s", __FUNCTION__, pix_fmt); return EINVAL; } /* Get JPEG quality. */ int jpeg_quality = mParameters.getInt(CameraParameters::KEY_JPEG_QUALITY); if (jpeg_quality <= 0) { jpeg_quality = 90; /* Fall back to default. */ } /* * Make sure preview is not running, and device is stopped before taking * picture. */ const bool preview_on = mPreviewWindow.isPreviewEnabled(); if (preview_on) { doStopPreview(); } /* Camera device should have been stopped when the shutter message has been * enabled. */ EmulatedCameraDevice* const camera_dev = getCameraDevice(); if (camera_dev->isStarted()) { ALOGW("%s: Camera device is started", __FUNCTION__); camera_dev->stopDeliveringFrames(); camera_dev->stopDevice(); } /* * Take the picture now. */ /* Start camera device for the picture frame. */ ALOGD("Starting camera for picture: %.4s(%s)[%dx%d]", reinterpret_cast(&org_fmt), pix_fmt, width, height); res = camera_dev->startDevice(width, height, org_fmt); if (res != NO_ERROR) { if (preview_on) { doStartPreview(); } return res; } /* Deliver one frame only. */ mCallbackNotifier.setJpegQuality(jpeg_quality); mCallbackNotifier.setTakingPicture(true); res = camera_dev->startDeliveringFrames(true); if (res != NO_ERROR) { mCallbackNotifier.setTakingPicture(false); if (preview_on) { doStartPreview(); } } return res; } status_t EmulatedCamera::cancelPicture() { ALOGV("%s", __FUNCTION__); return NO_ERROR; } status_t EmulatedCamera::setParameters(const char* parms) { ALOGV("%s", __FUNCTION__); PrintParamDiff(mParameters, parms); CameraParameters new_param; String8 str8_param(parms); new_param.unflatten(str8_param); /* * Check for new exposure compensation parameter. */ int new_exposure_compensation = new_param.getInt( CameraParameters::KEY_EXPOSURE_COMPENSATION); const int min_exposure_compensation = new_param.getInt( CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION); const int max_exposure_compensation = new_param.getInt( CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION); // Checks if the exposure compensation change is supported. if ((min_exposure_compensation != 0) || (max_exposure_compensation != 0)) { if (new_exposure_compensation > max_exposure_compensation) { new_exposure_compensation = max_exposure_compensation; } if (new_exposure_compensation < min_exposure_compensation) { new_exposure_compensation = min_exposure_compensation; } const int current_exposure_compensation = mParameters.getInt( CameraParameters::KEY_EXPOSURE_COMPENSATION); if (current_exposure_compensation != new_exposure_compensation) { const float exposure_value = new_exposure_compensation * new_param.getFloat( CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP); getCameraDevice()->setExposureCompensation( exposure_value); } } const char* new_white_balance = new_param.get( CameraParameters::KEY_WHITE_BALANCE); const char* supported_white_balance = new_param.get( CameraParameters::KEY_SUPPORTED_WHITE_BALANCE); if ((supported_white_balance != NULL) && (new_white_balance != NULL) && (strstr(supported_white_balance, new_white_balance) != NULL)) { const char* current_white_balance = mParameters.get( CameraParameters::KEY_WHITE_BALANCE); if ((current_white_balance == NULL) || (strcmp(current_white_balance, new_white_balance) != 0)) { ALOGV("Setting white balance to %s", new_white_balance); getCameraDevice()->setWhiteBalanceMode(new_white_balance); } } mParameters = new_param; return NO_ERROR; } /* A dumb variable indicating "no params" / error on the exit from * EmulatedCamera::getParameters(). */ static char lNoParam = '\0'; char* EmulatedCamera::getParameters() { String8 params(mParameters.flatten()); char* ret_str = reinterpret_cast(malloc(sizeof(char) * (params.length()+1))); memset(ret_str, 0, params.length()+1); if (ret_str != NULL) { strncpy(ret_str, params.string(), params.length()+1); return ret_str; } else { ALOGE("%s: Unable to allocate string for %s", __FUNCTION__, params.string()); /* Apparently, we can't return NULL fron this routine. */ return &lNoParam; } } void EmulatedCamera::putParameters(char* params) { /* This method simply frees parameters allocated in getParameters(). */ if (params != NULL && params != &lNoParam) { free(params); } } status_t EmulatedCamera::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) { ALOGV("%s: cmd = %d, arg1 = %d, arg2 = %d", __FUNCTION__, cmd, arg1, arg2); /* TODO: Future enhancements. */ return 0; } void EmulatedCamera::releaseCamera() { ALOGV("%s", __FUNCTION__); cleanupCamera(); } status_t EmulatedCamera::dumpCamera(int fd) { ALOGV("%s", __FUNCTION__); /* TODO: Future enhancements. */ return -EINVAL; } /**************************************************************************** * Preview management. ***************************************************************************/ status_t EmulatedCamera::doStartPreview() { ALOGV("%s", __FUNCTION__); EmulatedCameraDevice* camera_dev = getCameraDevice(); if (camera_dev->isStarted()) { camera_dev->stopDeliveringFrames(); camera_dev->stopDevice(); } status_t res = mPreviewWindow.startPreview(); if (res != NO_ERROR) { return res; } /* Make sure camera device is connected. */ if (!camera_dev->isConnected()) { res = camera_dev->connectDevice(); if (res != NO_ERROR) { mPreviewWindow.stopPreview(); return res; } } int width, height; /* Lets see what should we use for frame width, and height. */ if (mParameters.get(CameraParameters::KEY_VIDEO_SIZE) != NULL) { mParameters.getVideoSize(&width, &height); } else { mParameters.getPreviewSize(&width, &height); } /* Lets see what should we use for the frame pixel format. Note that there * are two parameters that define pixel formats for frames sent to the * application via notification callbacks: * - KEY_VIDEO_FRAME_FORMAT, that is used when recording video, and * - KEY_PREVIEW_FORMAT, that is used for preview frame notification. * We choose one or the other, depending on "recording-hint" property set by * the framework that indicating intention: video, or preview. */ const char* pix_fmt = NULL; const char* is_video = mParameters.get(EmulatedCamera::RECORDING_HINT_KEY); if (is_video == NULL) { is_video = CameraParameters::FALSE; } if (strcmp(is_video, CameraParameters::TRUE) == 0) { /* Video recording is requested. Lets see if video frame format is set. */ pix_fmt = mParameters.get(CameraParameters::KEY_VIDEO_FRAME_FORMAT); } /* If this was not video recording, or video frame format is not set, lets * use preview pixel format for the main framebuffer. */ if (pix_fmt == NULL) { pix_fmt = mParameters.getPreviewFormat(); } if (pix_fmt == NULL) { ALOGE("%s: Unable to obtain video format", __FUNCTION__); mPreviewWindow.stopPreview(); return EINVAL; } /* Convert framework's pixel format to the FOURCC one. */ uint32_t org_fmt; if (strcmp(pix_fmt, CameraParameters::PIXEL_FORMAT_YUV420P) == 0) { org_fmt = V4L2_PIX_FMT_YUV420; } else if (strcmp(pix_fmt, CameraParameters::PIXEL_FORMAT_RGBA8888) == 0) { org_fmt = V4L2_PIX_FMT_RGB32; } else if (strcmp(pix_fmt, CameraParameters::PIXEL_FORMAT_YUV420SP) == 0) { org_fmt = V4L2_PIX_FMT_NV21; } else { ALOGE("%s: Unsupported pixel format %s", __FUNCTION__, pix_fmt); mPreviewWindow.stopPreview(); return EINVAL; } ALOGD("Starting camera: %dx%d -> %.4s(%s)", width, height, reinterpret_cast(&org_fmt), pix_fmt); res = camera_dev->startDevice(width, height, org_fmt); if (res != NO_ERROR) { mPreviewWindow.stopPreview(); return res; } res = camera_dev->startDeliveringFrames(false); if (res != NO_ERROR) { camera_dev->stopDevice(); mPreviewWindow.stopPreview(); } return res; } status_t EmulatedCamera::doStopPreview() { ALOGV("%s", __FUNCTION__); status_t res = NO_ERROR; if (mPreviewWindow.isPreviewEnabled()) { /* Stop the camera. */ if (getCameraDevice()->isStarted()) { getCameraDevice()->stopDeliveringFrames(); res = getCameraDevice()->stopDevice(); } if (res == NO_ERROR) { /* Disable preview as well. */ mPreviewWindow.stopPreview(); } } return NO_ERROR; } /**************************************************************************** * Private API. ***************************************************************************/ status_t EmulatedCamera::cleanupCamera() { status_t res = NO_ERROR; /* If preview is running - stop it. */ res = doStopPreview(); if (res != NO_ERROR) { return -res; } /* Stop and disconnect the camera device. */ EmulatedCameraDevice* const camera_dev = getCameraDevice(); if (camera_dev != NULL) { if (camera_dev->isStarted()) { camera_dev->stopDeliveringFrames(); res = camera_dev->stopDevice(); if (res != NO_ERROR) { return -res; } } if (camera_dev->isConnected()) { res = camera_dev->disconnectDevice(); if (res != NO_ERROR) { return -res; } } } mCallbackNotifier.cleanupCBNotifier(); return NO_ERROR; } /**************************************************************************** * Camera API callbacks as defined by camera_device_ops structure. * * Callbacks here simply dispatch the calls to an appropriate method inside * EmulatedCamera instance, defined by the 'dev' parameter. ***************************************************************************/ int EmulatedCamera::set_preview_window(struct camera_device* dev, struct preview_stream_ops* window) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return -EINVAL; } return ec->setPreviewWindow(window); } void EmulatedCamera::set_callbacks( struct camera_device* dev, camera_notify_callback notify_cb, camera_data_callback data_cb, camera_data_timestamp_callback data_cb_timestamp, camera_request_memory get_memory, void* user) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return; } ec->setCallbacks(notify_cb, data_cb, data_cb_timestamp, get_memory, user); } void EmulatedCamera::enable_msg_type(struct camera_device* dev, int32_t msg_type) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return; } ec->enableMsgType(msg_type); } void EmulatedCamera::disable_msg_type(struct camera_device* dev, int32_t msg_type) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return; } ec->disableMsgType(msg_type); } int EmulatedCamera::msg_type_enabled(struct camera_device* dev, int32_t msg_type) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return -EINVAL; } return ec->isMsgTypeEnabled(msg_type); } int EmulatedCamera::start_preview(struct camera_device* dev) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return -EINVAL; } return ec->startPreview(); } void EmulatedCamera::stop_preview(struct camera_device* dev) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return; } ec->stopPreview(); } int EmulatedCamera::preview_enabled(struct camera_device* dev) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return -EINVAL; } return ec->isPreviewEnabled(); } int EmulatedCamera::store_meta_data_in_buffers(struct camera_device* dev, int enable) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return -EINVAL; } return ec->storeMetaDataInBuffers(enable); } int EmulatedCamera::start_recording(struct camera_device* dev) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return -EINVAL; } return ec->startRecording(); } void EmulatedCamera::stop_recording(struct camera_device* dev) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return; } ec->stopRecording(); } int EmulatedCamera::recording_enabled(struct camera_device* dev) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return -EINVAL; } return ec->isRecordingEnabled(); } void EmulatedCamera::release_recording_frame(struct camera_device* dev, const void* opaque) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return; } ec->releaseRecordingFrame(opaque); } int EmulatedCamera::auto_focus(struct camera_device* dev) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return -EINVAL; } return ec->setAutoFocus(); } int EmulatedCamera::cancel_auto_focus(struct camera_device* dev) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return -EINVAL; } return ec->cancelAutoFocus(); } int EmulatedCamera::take_picture(struct camera_device* dev) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return -EINVAL; } return ec->takePicture(); } int EmulatedCamera::cancel_picture(struct camera_device* dev) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return -EINVAL; } return ec->cancelPicture(); } int EmulatedCamera::set_parameters(struct camera_device* dev, const char* parms) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return -EINVAL; } return ec->setParameters(parms); } char* EmulatedCamera::get_parameters(struct camera_device* dev) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return NULL; } return ec->getParameters(); } void EmulatedCamera::put_parameters(struct camera_device* dev, char* params) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return; } ec->putParameters(params); } int EmulatedCamera::send_command(struct camera_device* dev, int32_t cmd, int32_t arg1, int32_t arg2) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return -EINVAL; } return ec->sendCommand(cmd, arg1, arg2); } void EmulatedCamera::release(struct camera_device* dev) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return; } ec->releaseCamera(); } int EmulatedCamera::dump(struct camera_device* dev, int fd) { EmulatedCamera* ec = reinterpret_cast(dev->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return -EINVAL; } return ec->dumpCamera(fd); } int EmulatedCamera::close(struct hw_device_t* device) { EmulatedCamera* ec = reinterpret_cast(reinterpret_cast(device)->priv); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera device", __FUNCTION__); return -EINVAL; } return ec->closeCamera(); } /**************************************************************************** * Static initializer for the camera callback API ****************************************************************************/ camera_device_ops_t EmulatedCamera::mDeviceOps = { EmulatedCamera::set_preview_window, EmulatedCamera::set_callbacks, EmulatedCamera::enable_msg_type, EmulatedCamera::disable_msg_type, EmulatedCamera::msg_type_enabled, EmulatedCamera::start_preview, EmulatedCamera::stop_preview, EmulatedCamera::preview_enabled, EmulatedCamera::store_meta_data_in_buffers, EmulatedCamera::start_recording, EmulatedCamera::stop_recording, EmulatedCamera::recording_enabled, EmulatedCamera::release_recording_frame, EmulatedCamera::auto_focus, EmulatedCamera::cancel_auto_focus, EmulatedCamera::take_picture, EmulatedCamera::cancel_picture, EmulatedCamera::set_parameters, EmulatedCamera::get_parameters, EmulatedCamera::put_parameters, EmulatedCamera::send_command, EmulatedCamera::release, EmulatedCamera::dump }; /**************************************************************************** * Common keys ***************************************************************************/ const char EmulatedCamera::FACING_KEY[] = "prop-facing"; const char EmulatedCamera::ORIENTATION_KEY[] = "prop-orientation"; const char EmulatedCamera::RECORDING_HINT_KEY[] = "recording-hint"; /**************************************************************************** * Common string values ***************************************************************************/ const char EmulatedCamera::FACING_BACK[] = "back"; const char EmulatedCamera::FACING_FRONT[] = "front"; /**************************************************************************** * Helper routines ***************************************************************************/ static char* AddValue(const char* param, const char* val) { const size_t len1 = strlen(param); const size_t len2 = strlen(val); char* ret = reinterpret_cast(malloc(len1 + len2 + 2)); ALOGE_IF(ret == NULL, "%s: Memory failure", __FUNCTION__); if (ret != NULL) { memcpy(ret, param, len1); ret[len1] = ','; memcpy(ret + len1 + 1, val, len2); ret[len1 + len2 + 1] = '\0'; } return ret; } /**************************************************************************** * Parameter debugging helpers ***************************************************************************/ #if DEBUG_PARAM static void PrintParamDiff(const CameraParameters& current, const char* new_par) { char tmp[2048]; const char* wrk = new_par; /* Divided with ';' */ const char* next = strchr(wrk, ';'); while (next != NULL) { snprintf(tmp, sizeof(tmp), "%.*s", (int)(intptr_t)(next-wrk), wrk); /* in the form key=value */ char* val = strchr(tmp, '='); if (val != NULL) { *val = '\0'; val++; const char* in_current = current.get(tmp); if (in_current != NULL) { if (strcmp(in_current, val)) { ALOGD("=== Value changed: %s: %s -> %s", tmp, in_current, val); } } else { ALOGD("+++ New parameter: %s=%s", tmp, val); } } else { ALOGW("No value separator in %s", tmp); } wrk = next + 1; next = strchr(wrk, ';'); } } #endif /* DEBUG_PARAM */ }; /* namespace android */ anbox-0.0~git20191115/android/camera/EmulatedCamera.h000077500000000000000000000372641356361734700221360ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef HW_EMULATOR_CAMERA_EMULATED_CAMERA_H #define HW_EMULATOR_CAMERA_EMULATED_CAMERA_H /* * Contains declaration of a class EmulatedCamera that encapsulates * functionality common to all version 1.0 emulated camera devices ("fake", * "webcam", "video file", etc.). Instances of this class (for each emulated * camera) are created during the construction of the EmulatedCameraFactory * instance. This class serves as an entry point for all camera API calls that * defined by camera_device_ops_t API. */ #include #include "EmulatedBaseCamera.h" #include "EmulatedCameraDevice.h" #include "PreviewWindow.h" #include "CallbackNotifier.h" namespace android { /* Encapsulates functionality common to all version 1.0 emulated camera devices * ("fake", "webcam", "file stream", etc.). * * Note that EmulatedCameraFactory instantiates object of this class just once, * when EmulatedCameraFactory instance gets constructed. Connection to / * disconnection from the actual camera device is handled by calls to * connectDevice(), and closeCamera() methods of this class that are ivoked in * response to hw_module_methods_t::open, and camera_device::close callbacks. */ class EmulatedCamera : public camera_device, public EmulatedBaseCamera { public: /* Constructs EmulatedCamera instance. * Param: * cameraId - Zero based camera identifier, which is an index of the camera * instance in camera factory's array. * module - Emulated camera HAL module descriptor. */ EmulatedCamera(int cameraId, struct hw_module_t* module); /* Destructs EmulatedCamera instance. */ virtual ~EmulatedCamera(); /**************************************************************************** * Abstract API ***************************************************************************/ public: /* Gets emulated camera device used by this instance of the emulated camera. */ virtual EmulatedCameraDevice* getCameraDevice() = 0; /**************************************************************************** * Public API ***************************************************************************/ public: /** Override of base class method */ virtual status_t Initialize(); /* Next frame is available in the camera device. * This is a notification callback that is invoked by the camera device when * a new frame is available. * Note that most likely this method is called in context of a worker thread * that camera device has created for frame capturing. * Param: * frame - Captured frame, or NULL if camera device didn't pull the frame * yet. If NULL is passed in this parameter use GetCurrentFrame method * of the camera device class to obtain the next frame. Also note that * the size of the frame that is passed here (as well as the frame * returned from the GetCurrentFrame method) is defined by the current * frame settings (width + height + pixel format) for the camera device. * timestamp - Frame's timestamp. * camera_dev - Camera device instance that delivered the frame. */ virtual void onNextFrameAvailable(const void* frame, nsecs_t timestamp, EmulatedCameraDevice* camera_dev); /* Entry point for notifications that occur in camera device. * Param: * err - CAMERA_ERROR_XXX error code. */ virtual void onCameraDeviceError(int err); /**************************************************************************** * Camera API implementation ***************************************************************************/ public: /** Override of base class method */ virtual status_t connectCamera(hw_device_t** device); /** Override of base class method */ virtual status_t closeCamera(); /** Override of base class method */ virtual status_t getCameraInfo(struct camera_info* info); /**************************************************************************** * Camera API implementation. * These methods are called from the camera API callback routines. ***************************************************************************/ protected: /* Actual handler for camera_device_ops_t::set_preview_window callback. * NOTE: When this method is called the object is locked. * Note that failures in this method are reported as negave EXXX statuses. */ virtual status_t setPreviewWindow(struct preview_stream_ops *window); /* Actual handler for camera_device_ops_t::set_callbacks callback. * NOTE: When this method is called the object is locked. */ virtual void setCallbacks(camera_notify_callback notify_cb, camera_data_callback data_cb, camera_data_timestamp_callback data_cb_timestamp, camera_request_memory get_memory, void* user); /* Actual handler for camera_device_ops_t::enable_msg_type callback. * NOTE: When this method is called the object is locked. */ virtual void enableMsgType(int32_t msg_type); /* Actual handler for camera_device_ops_t::disable_msg_type callback. * NOTE: When this method is called the object is locked. */ virtual void disableMsgType(int32_t msg_type); /* Actual handler for camera_device_ops_t::msg_type_enabled callback. * NOTE: When this method is called the object is locked. * Return: * 0 if message(s) is (are) disabled, != 0 if enabled. */ virtual int isMsgTypeEnabled(int32_t msg_type); /* Actual handler for camera_device_ops_t::start_preview callback. * NOTE: When this method is called the object is locked. * Note that failures in this method are reported as negave EXXX statuses. */ virtual status_t startPreview(); /* Actual handler for camera_device_ops_t::stop_preview callback. * NOTE: When this method is called the object is locked. */ virtual void stopPreview(); /* Actual handler for camera_device_ops_t::preview_enabled callback. * NOTE: When this method is called the object is locked. * Return: * 0 if preview is disabled, != 0 if enabled. */ virtual int isPreviewEnabled(); /* Actual handler for camera_device_ops_t::store_meta_data_in_buffers callback. * NOTE: When this method is called the object is locked. * Note that failures in this method are reported as negave EXXX statuses. */ virtual status_t storeMetaDataInBuffers(int enable); /* Actual handler for camera_device_ops_t::start_recording callback. * NOTE: When this method is called the object is locked. * Note that failures in this method are reported as negave EXXX statuses. */ virtual status_t startRecording(); /* Actual handler for camera_device_ops_t::stop_recording callback. * NOTE: When this method is called the object is locked. */ virtual void stopRecording(); /* Actual handler for camera_device_ops_t::recording_enabled callback. * NOTE: When this method is called the object is locked. * Return: * 0 if recording is disabled, != 0 if enabled. */ virtual int isRecordingEnabled(); /* Actual handler for camera_device_ops_t::release_recording_frame callback. * NOTE: When this method is called the object is locked. */ virtual void releaseRecordingFrame(const void* opaque); /* Actual handler for camera_device_ops_t::auto_focus callback. * NOTE: When this method is called the object is locked. * Note that failures in this method are reported as negave EXXX statuses. */ virtual status_t setAutoFocus(); /* Actual handler for camera_device_ops_t::cancel_auto_focus callback. * NOTE: When this method is called the object is locked. * Note that failures in this method are reported as negave EXXX statuses. */ virtual status_t cancelAutoFocus(); /* Actual handler for camera_device_ops_t::take_picture callback. * NOTE: When this method is called the object is locked. * Note that failures in this method are reported as negave EXXX statuses. */ virtual status_t takePicture(); /* Actual handler for camera_device_ops_t::cancel_picture callback. * NOTE: When this method is called the object is locked. * Note that failures in this method are reported as negave EXXX statuses. */ virtual status_t cancelPicture(); /* Actual handler for camera_device_ops_t::set_parameters callback. * NOTE: When this method is called the object is locked. * Note that failures in this method are reported as negave EXXX statuses. */ virtual status_t setParameters(const char* parms); /* Actual handler for camera_device_ops_t::get_parameters callback. * NOTE: When this method is called the object is locked. * Return: * Flattened parameters string. The caller will free the buffer allocated * for the string by calling camera_device_ops_t::put_parameters callback. */ virtual char* getParameters(); /* Actual handler for camera_device_ops_t::put_parameters callback. * Called to free the string returned from camera_device_ops_t::get_parameters * callback. There is nothing more to it: the name of the callback is just * misleading. * NOTE: When this method is called the object is locked. */ virtual void putParameters(char* params); /* Actual handler for camera_device_ops_t::send_command callback. * NOTE: When this method is called the object is locked. * Note that failures in this method are reported as negave EXXX statuses. */ virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2); /* Actual handler for camera_device_ops_t::release callback. * NOTE: When this method is called the object is locked. */ virtual void releaseCamera(); /* Actual handler for camera_device_ops_t::dump callback. * NOTE: When this method is called the object is locked. * Note that failures in this method are reported as negave EXXX statuses. */ virtual status_t dumpCamera(int fd); /**************************************************************************** * Preview management. ***************************************************************************/ protected: /* Starts preview. * Note that when this method is called mPreviewWindow may be NULL, * indicating that framework has an intention to start displaying video * frames, but didn't create the preview window yet. * Return: * NO_ERROR on success, or an appropriate error status on failure. */ virtual status_t doStartPreview(); /* Stops preview. * This method reverts DoStartPreview. * Return: * NO_ERROR on success, or an appropriate error status on failure. */ virtual status_t doStopPreview(); /**************************************************************************** * Private API. ***************************************************************************/ protected: /* Cleans up camera when released. */ virtual status_t cleanupCamera(); /**************************************************************************** * Camera API callbacks as defined by camera_device_ops structure. * See hardware/libhardware/include/hardware/camera.h for information on * each of these callbacks. Implemented in this class, these callbacks simply * dispatch the call into an instance of EmulatedCamera class defined by the * 'camera_device' parameter. ***************************************************************************/ private: static int set_preview_window(struct camera_device* dev, struct preview_stream_ops* window); static void set_callbacks(struct camera_device* dev, camera_notify_callback notify_cb, camera_data_callback data_cb, camera_data_timestamp_callback data_cb_timestamp, camera_request_memory get_memory, void* user); static void enable_msg_type(struct camera_device* dev, int32_t msg_type); static void disable_msg_type(struct camera_device* dev, int32_t msg_type); static int msg_type_enabled(struct camera_device* dev, int32_t msg_type); static int start_preview(struct camera_device* dev); static void stop_preview(struct camera_device* dev); static int preview_enabled(struct camera_device* dev); static int store_meta_data_in_buffers(struct camera_device* dev, int enable); static int start_recording(struct camera_device* dev); static void stop_recording(struct camera_device* dev); static int recording_enabled(struct camera_device* dev); static void release_recording_frame(struct camera_device* dev, const void* opaque); static int auto_focus(struct camera_device* dev); static int cancel_auto_focus(struct camera_device* dev); static int take_picture(struct camera_device* dev); static int cancel_picture(struct camera_device* dev); static int set_parameters(struct camera_device* dev, const char* parms); static char* get_parameters(struct camera_device* dev); static void put_parameters(struct camera_device* dev, char* params); static int send_command(struct camera_device* dev, int32_t cmd, int32_t arg1, int32_t arg2); static void release(struct camera_device* dev); static int dump(struct camera_device* dev, int fd); static int close(struct hw_device_t* device); /**************************************************************************** * Data members ***************************************************************************/ protected: /* Locks this instance for parameters, state, etc. change. */ Mutex mObjectLock; /* Camera parameters. */ CameraParameters mParameters; /* Preview window. */ PreviewWindow mPreviewWindow; /* Callback notifier. */ CallbackNotifier mCallbackNotifier; private: /* Registered callbacks implementing camera API. */ static camera_device_ops_t mDeviceOps; /**************************************************************************** * Common keys ***************************************************************************/ public: static const char FACING_KEY[]; static const char ORIENTATION_KEY[]; static const char RECORDING_HINT_KEY[]; /**************************************************************************** * Common string values ***************************************************************************/ /* Possible values for FACING_KEY */ static const char FACING_BACK[]; static const char FACING_FRONT[]; }; }; /* namespace android */ #endif /* HW_EMULATOR_CAMERA_EMULATED_CAMERA_H */ anbox-0.0~git20191115/android/camera/EmulatedCamera2.cpp000066400000000000000000000312351356361734700225400ustar00rootroot00000000000000/* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * Contains implementation of a class EmulatedCamera that encapsulates * functionality common to all version 2.0 emulated camera devices. Instances * of this class (for each emulated camera) are created during the construction * of the EmulatedCameraFactory instance. This class serves as an entry point * for all camera API calls that defined by camera2_device_ops_t API. */ //#define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera2_Camera" #include #include "EmulatedCamera2.h" #include "system/camera_metadata.h" namespace android { /* Constructs EmulatedCamera2 instance. * Param: * cameraId - Zero based camera identifier, which is an index of the camera * instance in camera factory's array. * module - Emulated camera HAL module descriptor. */ EmulatedCamera2::EmulatedCamera2(int cameraId, struct hw_module_t* module): EmulatedBaseCamera(cameraId, CAMERA_DEVICE_API_VERSION_2_0, &common, module) { common.close = EmulatedCamera2::close; ops = &sDeviceOps; priv = this; mNotifyCb = NULL; mRequestQueueSrc = NULL; mFrameQueueDst = NULL; mVendorTagOps.get_camera_vendor_section_name = EmulatedCamera2::get_camera_vendor_section_name; mVendorTagOps.get_camera_vendor_tag_name = EmulatedCamera2::get_camera_vendor_tag_name; mVendorTagOps.get_camera_vendor_tag_type = EmulatedCamera2::get_camera_vendor_tag_type; mVendorTagOps.parent = this; mStatusPresent = true; } /* Destructs EmulatedCamera2 instance. */ EmulatedCamera2::~EmulatedCamera2() { } /**************************************************************************** * Abstract API ***************************************************************************/ /**************************************************************************** * Public API ***************************************************************************/ status_t EmulatedCamera2::Initialize() { return NO_ERROR; } /**************************************************************************** * Camera API implementation ***************************************************************************/ status_t EmulatedCamera2::connectCamera(hw_device_t** device) { *device = &common; return NO_ERROR; } status_t EmulatedCamera2::closeCamera() { return NO_ERROR; } status_t EmulatedCamera2::getCameraInfo(struct camera_info* info) { return EmulatedBaseCamera::getCameraInfo(info); } /**************************************************************************** * Camera Device API implementation. * These methods are called from the camera API callback routines. ***************************************************************************/ /** Request input queue */ int EmulatedCamera2::requestQueueNotify() { return INVALID_OPERATION; } /** Count of requests in flight */ int EmulatedCamera2::getInProgressCount() { return INVALID_OPERATION; } /** Cancel all captures in flight */ int EmulatedCamera2::flushCapturesInProgress() { return INVALID_OPERATION; } /** Construct a default request for a given use case */ int EmulatedCamera2::constructDefaultRequest( int request_template, camera_metadata_t **request) { return INVALID_OPERATION; } /** Output stream creation and management */ int EmulatedCamera2::allocateStream( uint32_t width, uint32_t height, int format, const camera2_stream_ops_t *stream_ops, uint32_t *stream_id, uint32_t *format_actual, uint32_t *usage, uint32_t *max_buffers) { return INVALID_OPERATION; } int EmulatedCamera2::registerStreamBuffers( uint32_t stream_id, int num_buffers, buffer_handle_t *buffers) { return INVALID_OPERATION; } int EmulatedCamera2::releaseStream(uint32_t stream_id) { return INVALID_OPERATION; } /** Reprocessing input stream management */ int EmulatedCamera2::allocateReprocessStream( uint32_t width, uint32_t height, uint32_t format, const camera2_stream_in_ops_t *reprocess_stream_ops, uint32_t *stream_id, uint32_t *consumer_usage, uint32_t *max_buffers) { return INVALID_OPERATION; } int EmulatedCamera2::allocateReprocessStreamFromStream( uint32_t output_stream_id, const camera2_stream_in_ops_t *reprocess_stream_ops, uint32_t *stream_id) { return INVALID_OPERATION; } int EmulatedCamera2::releaseReprocessStream(uint32_t stream_id) { return INVALID_OPERATION; } /** 3A triggering */ int EmulatedCamera2::triggerAction(uint32_t trigger_id, int ext1, int ext2) { return INVALID_OPERATION; } /** Custom tag query methods */ const char* EmulatedCamera2::getVendorSectionName(uint32_t tag) { return NULL; } const char* EmulatedCamera2::getVendorTagName(uint32_t tag) { return NULL; } int EmulatedCamera2::getVendorTagType(uint32_t tag) { return -1; } /** Debug methods */ int EmulatedCamera2::dump(int fd) { return INVALID_OPERATION; } /**************************************************************************** * Private API. ***************************************************************************/ /**************************************************************************** * Camera API callbacks as defined by camera2_device_ops structure. See * hardware/libhardware/include/hardware/camera2.h for information on each * of these callbacks. Implemented in this class, these callbacks simply * dispatch the call into an instance of EmulatedCamera2 class defined by the * 'camera_device2' parameter, or set a member value in the same. ***************************************************************************/ EmulatedCamera2* getInstance(const camera2_device_t *d) { const EmulatedCamera2* cec = static_cast(d); return const_cast(cec); } int EmulatedCamera2::set_request_queue_src_ops(const camera2_device_t *d, const camera2_request_queue_src_ops *queue_src_ops) { EmulatedCamera2* ec = getInstance(d); ec->mRequestQueueSrc = queue_src_ops; return NO_ERROR; } int EmulatedCamera2::notify_request_queue_not_empty(const camera2_device_t *d) { EmulatedCamera2* ec = getInstance(d); return ec->requestQueueNotify(); } int EmulatedCamera2::set_frame_queue_dst_ops(const camera2_device_t *d, const camera2_frame_queue_dst_ops *queue_dst_ops) { EmulatedCamera2* ec = getInstance(d); ec->mFrameQueueDst = queue_dst_ops; return NO_ERROR; } int EmulatedCamera2::get_in_progress_count(const camera2_device_t *d) { EmulatedCamera2* ec = getInstance(d); return ec->getInProgressCount(); } int EmulatedCamera2::flush_captures_in_progress(const camera2_device_t *d) { EmulatedCamera2* ec = getInstance(d); return ec->flushCapturesInProgress(); } int EmulatedCamera2::construct_default_request(const camera2_device_t *d, int request_template, camera_metadata_t **request) { EmulatedCamera2* ec = getInstance(d); return ec->constructDefaultRequest(request_template, request); } int EmulatedCamera2::allocate_stream(const camera2_device_t *d, uint32_t width, uint32_t height, int format, const camera2_stream_ops_t *stream_ops, uint32_t *stream_id, uint32_t *format_actual, uint32_t *usage, uint32_t *max_buffers) { EmulatedCamera2* ec = getInstance(d); return ec->allocateStream(width, height, format, stream_ops, stream_id, format_actual, usage, max_buffers); } int EmulatedCamera2::register_stream_buffers(const camera2_device_t *d, uint32_t stream_id, int num_buffers, buffer_handle_t *buffers) { EmulatedCamera2* ec = getInstance(d); return ec->registerStreamBuffers(stream_id, num_buffers, buffers); } int EmulatedCamera2::release_stream(const camera2_device_t *d, uint32_t stream_id) { EmulatedCamera2* ec = getInstance(d); return ec->releaseStream(stream_id); } int EmulatedCamera2::allocate_reprocess_stream(const camera2_device_t *d, uint32_t width, uint32_t height, uint32_t format, const camera2_stream_in_ops_t *reprocess_stream_ops, uint32_t *stream_id, uint32_t *consumer_usage, uint32_t *max_buffers) { EmulatedCamera2* ec = getInstance(d); return ec->allocateReprocessStream(width, height, format, reprocess_stream_ops, stream_id, consumer_usage, max_buffers); } int EmulatedCamera2::allocate_reprocess_stream_from_stream( const camera2_device_t *d, uint32_t output_stream_id, const camera2_stream_in_ops_t *reprocess_stream_ops, uint32_t *stream_id) { EmulatedCamera2* ec = getInstance(d); return ec->allocateReprocessStreamFromStream(output_stream_id, reprocess_stream_ops, stream_id); } int EmulatedCamera2::release_reprocess_stream(const camera2_device_t *d, uint32_t stream_id) { EmulatedCamera2* ec = getInstance(d); return ec->releaseReprocessStream(stream_id); } int EmulatedCamera2::trigger_action(const camera2_device_t *d, uint32_t trigger_id, int ext1, int ext2) { EmulatedCamera2* ec = getInstance(d); return ec->triggerAction(trigger_id, ext1, ext2); } int EmulatedCamera2::set_notify_callback(const camera2_device_t *d, camera2_notify_callback notify_cb, void* user) { EmulatedCamera2* ec = getInstance(d); Mutex::Autolock l(ec->mMutex); ec->mNotifyCb = notify_cb; ec->mNotifyUserPtr = user; return NO_ERROR; } int EmulatedCamera2::get_metadata_vendor_tag_ops(const camera2_device_t *d, vendor_tag_query_ops_t **ops) { EmulatedCamera2* ec = getInstance(d); *ops = static_cast( &ec->mVendorTagOps); return NO_ERROR; } const char* EmulatedCamera2::get_camera_vendor_section_name( const vendor_tag_query_ops_t *v, uint32_t tag) { EmulatedCamera2* ec = static_cast(v)->parent; return ec->getVendorSectionName(tag); } const char* EmulatedCamera2::get_camera_vendor_tag_name( const vendor_tag_query_ops_t *v, uint32_t tag) { EmulatedCamera2* ec = static_cast(v)->parent; return ec->getVendorTagName(tag); } int EmulatedCamera2::get_camera_vendor_tag_type( const vendor_tag_query_ops_t *v, uint32_t tag) { EmulatedCamera2* ec = static_cast(v)->parent; return ec->getVendorTagType(tag); } int EmulatedCamera2::dump(const camera2_device_t *d, int fd) { EmulatedCamera2* ec = getInstance(d); return ec->dump(fd); } int EmulatedCamera2::close(struct hw_device_t* device) { EmulatedCamera2* ec = static_cast( reinterpret_cast(device) ); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera2 device", __FUNCTION__); return -EINVAL; } return ec->closeCamera(); } void EmulatedCamera2::sendNotification(int32_t msgType, int32_t ext1, int32_t ext2, int32_t ext3) { camera2_notify_callback notifyCb; { Mutex::Autolock l(mMutex); notifyCb = mNotifyCb; } if (notifyCb != NULL) { notifyCb(msgType, ext1, ext2, ext3, mNotifyUserPtr); } } camera2_device_ops_t EmulatedCamera2::sDeviceOps = { EmulatedCamera2::set_request_queue_src_ops, EmulatedCamera2::notify_request_queue_not_empty, EmulatedCamera2::set_frame_queue_dst_ops, EmulatedCamera2::get_in_progress_count, EmulatedCamera2::flush_captures_in_progress, EmulatedCamera2::construct_default_request, EmulatedCamera2::allocate_stream, EmulatedCamera2::register_stream_buffers, EmulatedCamera2::release_stream, EmulatedCamera2::allocate_reprocess_stream, EmulatedCamera2::allocate_reprocess_stream_from_stream, EmulatedCamera2::release_reprocess_stream, EmulatedCamera2::trigger_action, EmulatedCamera2::set_notify_callback, EmulatedCamera2::get_metadata_vendor_tag_ops, EmulatedCamera2::dump }; }; /* namespace android */ anbox-0.0~git20191115/android/camera/EmulatedCamera2.h000066400000000000000000000231501356361734700222020ustar00rootroot00000000000000/* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef HW_EMULATOR_CAMERA_EMULATED_CAMERA2_H #define HW_EMULATOR_CAMERA_EMULATED_CAMERA2_H /* * Contains declaration of a class EmulatedCamera that encapsulates * functionality common to all version 2.0 emulated camera devices. Instances * of this class (for each emulated camera) are created during the construction * of the EmulatedCameraFactory instance. This class serves as an entry point * for all camera API calls that defined by camera2_device_ops_t API. */ #include "hardware/camera2.h" #include "system/camera_metadata.h" #include "EmulatedBaseCamera.h" #include #include namespace android { /* Encapsulates functionality common to all version 2.0 emulated camera devices * * Note that EmulatedCameraFactory instantiates object of this class just once, * when EmulatedCameraFactory instance gets constructed. Connection to / * disconnection from the actual camera device is handled by calls to * connectDevice(), and closeCamera() methods of this class that are invoked in * response to hw_module_methods_t::open, and camera_device::close callbacks. */ class EmulatedCamera2 : public camera2_device, public EmulatedBaseCamera { public: /* Constructs EmulatedCamera2 instance. * Param: * cameraId - Zero based camera identifier, which is an index of the camera * instance in camera factory's array. * module - Emulated camera HAL module descriptor. */ EmulatedCamera2(int cameraId, struct hw_module_t* module); /* Destructs EmulatedCamera2 instance. */ virtual ~EmulatedCamera2(); /**************************************************************************** * Abstract API ***************************************************************************/ public: /**************************************************************************** * Public API ***************************************************************************/ public: virtual status_t Initialize(); /**************************************************************************** * Camera module API and generic hardware device API implementation ***************************************************************************/ public: virtual status_t connectCamera(hw_device_t** device); virtual status_t closeCamera(); virtual status_t getCameraInfo(struct camera_info* info) = 0; /**************************************************************************** * Camera API implementation. * These methods are called from the camera API callback routines. ***************************************************************************/ protected: /** Request input queue notification */ virtual int requestQueueNotify(); /** Count of requests in flight */ virtual int getInProgressCount(); /** Cancel all captures in flight */ virtual int flushCapturesInProgress(); virtual int constructDefaultRequest( int request_template, camera_metadata_t **request); /** Output stream creation and management */ virtual int allocateStream( uint32_t width, uint32_t height, int format, const camera2_stream_ops_t *stream_ops, uint32_t *stream_id, uint32_t *format_actual, uint32_t *usage, uint32_t *max_buffers); virtual int registerStreamBuffers( uint32_t stream_id, int num_buffers, buffer_handle_t *buffers); virtual int releaseStream(uint32_t stream_id); /** Input stream creation and management */ virtual int allocateReprocessStream( uint32_t width, uint32_t height, uint32_t format, const camera2_stream_in_ops_t *reprocess_stream_ops, uint32_t *stream_id, uint32_t *consumer_usage, uint32_t *max_buffers); virtual int allocateReprocessStreamFromStream( uint32_t output_stream_id, const camera2_stream_in_ops_t *reprocess_stream_ops, uint32_t *stream_id); virtual int releaseReprocessStream(uint32_t stream_id); /** 3A action triggering */ virtual int triggerAction(uint32_t trigger_id, int32_t ext1, int32_t ext2); /** Custom tag definitions */ virtual const char* getVendorSectionName(uint32_t tag); virtual const char* getVendorTagName(uint32_t tag); virtual int getVendorTagType(uint32_t tag); /** Debug methods */ virtual int dump(int fd); /**************************************************************************** * Camera API callbacks as defined by camera2_device_ops structure. See * hardware/libhardware/include/hardware/camera2.h for information on each * of these callbacks. Implemented in this class, these callbacks simply * dispatch the call into an instance of EmulatedCamera2 class defined in * the 'camera_device2' parameter. ***************************************************************************/ private: /** Input request queue */ static int set_request_queue_src_ops(const camera2_device_t *, const camera2_request_queue_src_ops *queue_src_ops); static int notify_request_queue_not_empty(const camera2_device_t *); /** Output frame queue */ static int set_frame_queue_dst_ops(const camera2_device_t *, const camera2_frame_queue_dst_ops *queue_dst_ops); /** In-progress request management */ static int get_in_progress_count(const camera2_device_t *); static int flush_captures_in_progress(const camera2_device_t *); /** Request template creation */ static int construct_default_request(const camera2_device_t *, int request_template, camera_metadata_t **request); /** Stream management */ static int allocate_stream(const camera2_device_t *, uint32_t width, uint32_t height, int format, const camera2_stream_ops_t *stream_ops, uint32_t *stream_id, uint32_t *format_actual, uint32_t *usage, uint32_t *max_buffers); static int register_stream_buffers(const camera2_device_t *, uint32_t stream_id, int num_buffers, buffer_handle_t *buffers); static int release_stream(const camera2_device_t *, uint32_t stream_id); static int allocate_reprocess_stream(const camera2_device_t *, uint32_t width, uint32_t height, uint32_t format, const camera2_stream_in_ops_t *reprocess_stream_ops, uint32_t *stream_id, uint32_t *consumer_usage, uint32_t *max_buffers); static int allocate_reprocess_stream_from_stream(const camera2_device_t *, uint32_t output_stream_id, const camera2_stream_in_ops_t *reprocess_stream_ops, uint32_t *stream_id); static int release_reprocess_stream(const camera2_device_t *, uint32_t stream_id); /** 3A triggers*/ static int trigger_action(const camera2_device_t *, uint32_t trigger_id, int ext1, int ext2); /** Notifications to application */ static int set_notify_callback(const camera2_device_t *, camera2_notify_callback notify_cb, void *user); /** Vendor metadata registration */ static int get_metadata_vendor_tag_ops(const camera2_device_t *, vendor_tag_query_ops_t **ops); // for get_metadata_vendor_tag_ops static const char* get_camera_vendor_section_name( const vendor_tag_query_ops_t *, uint32_t tag); static const char* get_camera_vendor_tag_name( const vendor_tag_query_ops_t *, uint32_t tag); static int get_camera_vendor_tag_type( const vendor_tag_query_ops_t *, uint32_t tag); static int dump(const camera2_device_t *, int fd); /** For hw_device_t ops */ static int close(struct hw_device_t* device); /**************************************************************************** * Data members shared with implementations ***************************************************************************/ protected: /** Mutex for calls through camera2 device interface */ Mutex mMutex; bool mStatusPresent; const camera2_request_queue_src_ops *mRequestQueueSrc; const camera2_frame_queue_dst_ops *mFrameQueueDst; struct TagOps : public vendor_tag_query_ops { EmulatedCamera2 *parent; }; TagOps mVendorTagOps; void sendNotification(int32_t msgType, int32_t ext1, int32_t ext2, int32_t ext3); /**************************************************************************** * Data members ***************************************************************************/ private: static camera2_device_ops_t sDeviceOps; camera2_notify_callback mNotifyCb; void* mNotifyUserPtr; }; }; /* namespace android */ #endif /* HW_EMULATOR_CAMERA_EMULATED_CAMERA2_H */ anbox-0.0~git20191115/android/camera/EmulatedCamera3.cpp000066400000000000000000000206651356361734700225460ustar00rootroot00000000000000/* * Copyright (C) 2013 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * Contains implementation of a class EmulatedCamera that encapsulates * functionality common to all version 3.0 emulated camera devices. Instances * of this class (for each emulated camera) are created during the construction * of the EmulatedCameraFactory instance. This class serves as an entry point * for all camera API calls that defined by camera3_device_ops_t API. */ //#define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera3_Camera" #include #include "EmulatedCamera3.h" #include "system/camera_metadata.h" namespace android { /** * Constructs EmulatedCamera3 instance. * Param: * cameraId - Zero based camera identifier, which is an index of the camera * instance in camera factory's array. * module - Emulated camera HAL module descriptor. */ EmulatedCamera3::EmulatedCamera3(int cameraId, struct hw_module_t* module): EmulatedBaseCamera(cameraId, CAMERA_DEVICE_API_VERSION_3_3, &common, module), mStatus(STATUS_ERROR) { common.close = EmulatedCamera3::close; ops = &sDeviceOps; mCallbackOps = NULL; } /* Destructs EmulatedCamera3 instance. */ EmulatedCamera3::~EmulatedCamera3() { } /**************************************************************************** * Abstract API ***************************************************************************/ /**************************************************************************** * Public API ***************************************************************************/ status_t EmulatedCamera3::Initialize() { ALOGV("%s", __FUNCTION__); mStatus = STATUS_CLOSED; return NO_ERROR; } /**************************************************************************** * Camera API implementation ***************************************************************************/ status_t EmulatedCamera3::connectCamera(hw_device_t** device) { ALOGV("%s", __FUNCTION__); if (device == NULL) return BAD_VALUE; if (mStatus != STATUS_CLOSED) { ALOGE("%s: Trying to open a camera in state %d!", __FUNCTION__, mStatus); return INVALID_OPERATION; } *device = &common; mStatus = STATUS_OPEN; return NO_ERROR; } status_t EmulatedCamera3::closeCamera() { mStatus = STATUS_CLOSED; return NO_ERROR; } status_t EmulatedCamera3::getCameraInfo(struct camera_info* info) { return EmulatedBaseCamera::getCameraInfo(info); } /**************************************************************************** * Camera Device API implementation. * These methods are called from the camera API callback routines. ***************************************************************************/ status_t EmulatedCamera3::initializeDevice( const camera3_callback_ops *callbackOps) { if (callbackOps == NULL) { ALOGE("%s: NULL callback ops provided to HAL!", __FUNCTION__); return BAD_VALUE; } if (mStatus != STATUS_OPEN) { ALOGE("%s: Trying to initialize a camera in state %d!", __FUNCTION__, mStatus); return INVALID_OPERATION; } mCallbackOps = callbackOps; mStatus = STATUS_READY; return NO_ERROR; } status_t EmulatedCamera3::configureStreams( camera3_stream_configuration *streamList) { ALOGE("%s: Not implemented", __FUNCTION__); return INVALID_OPERATION; } status_t EmulatedCamera3::registerStreamBuffers( const camera3_stream_buffer_set *bufferSet) { ALOGE("%s: Not implemented", __FUNCTION__); return INVALID_OPERATION; } const camera_metadata_t* EmulatedCamera3::constructDefaultRequestSettings( int type) { ALOGE("%s: Not implemented", __FUNCTION__); return NULL; } status_t EmulatedCamera3::processCaptureRequest( camera3_capture_request *request) { ALOGE("%s: Not implemented", __FUNCTION__); return INVALID_OPERATION; } status_t EmulatedCamera3::flush() { ALOGE("%s: Not implemented", __FUNCTION__); return INVALID_OPERATION; } /** Debug methods */ void EmulatedCamera3::dump(int fd) { ALOGE("%s: Not implemented", __FUNCTION__); return; } /**************************************************************************** * Protected API. Callbacks to the framework. ***************************************************************************/ void EmulatedCamera3::sendCaptureResult(camera3_capture_result_t *result) { mCallbackOps->process_capture_result(mCallbackOps, result); } void EmulatedCamera3::sendNotify(camera3_notify_msg_t *msg) { mCallbackOps->notify(mCallbackOps, msg); } /**************************************************************************** * Private API. ***************************************************************************/ /**************************************************************************** * Camera API callbacks as defined by camera3_device_ops structure. See * hardware/libhardware/include/hardware/camera3.h for information on each * of these callbacks. Implemented in this class, these callbacks simply * dispatch the call into an instance of EmulatedCamera3 class defined by the * 'camera_device3' parameter, or set a member value in the same. ***************************************************************************/ EmulatedCamera3* getInstance(const camera3_device_t *d) { const EmulatedCamera3* cec = static_cast(d); return const_cast(cec); } int EmulatedCamera3::initialize(const struct camera3_device *d, const camera3_callback_ops_t *callback_ops) { EmulatedCamera3* ec = getInstance(d); return ec->initializeDevice(callback_ops); } int EmulatedCamera3::configure_streams(const struct camera3_device *d, camera3_stream_configuration_t *stream_list) { EmulatedCamera3* ec = getInstance(d); return ec->configureStreams(stream_list); } int EmulatedCamera3::register_stream_buffers( const struct camera3_device *d, const camera3_stream_buffer_set_t *buffer_set) { EmulatedCamera3* ec = getInstance(d); return ec->registerStreamBuffers(buffer_set); } int EmulatedCamera3::process_capture_request( const struct camera3_device *d, camera3_capture_request_t *request) { EmulatedCamera3* ec = getInstance(d); return ec->processCaptureRequest(request); } const camera_metadata_t* EmulatedCamera3::construct_default_request_settings( const camera3_device_t *d, int type) { EmulatedCamera3* ec = getInstance(d); return ec->constructDefaultRequestSettings(type); } void EmulatedCamera3::dump(const camera3_device_t *d, int fd) { EmulatedCamera3* ec = getInstance(d); ec->dump(fd); } int EmulatedCamera3::flush(const camera3_device_t *d) { EmulatedCamera3* ec = getInstance(d); return ec->flush(); } int EmulatedCamera3::close(struct hw_device_t* device) { EmulatedCamera3* ec = static_cast( reinterpret_cast(device) ); if (ec == NULL) { ALOGE("%s: Unexpected NULL camera3 device", __FUNCTION__); return BAD_VALUE; } return ec->closeCamera(); } camera3_device_ops_t EmulatedCamera3::sDeviceOps = { EmulatedCamera3::initialize, EmulatedCamera3::configure_streams, /* DEPRECATED: register_stream_buffers */ nullptr, EmulatedCamera3::construct_default_request_settings, EmulatedCamera3::process_capture_request, /* DEPRECATED: get_metadata_vendor_tag_ops */ nullptr, EmulatedCamera3::dump, EmulatedCamera3::flush }; const char* EmulatedCamera3::sAvailableCapabilitiesStrings[NUM_CAPABILITIES] = { "BACKWARD_COMPATIBLE", "MANUAL_SENSOR", "MANUAL_POST_PROCESSING", "RAW", "PRIVATE_REPROCESSING", "READ_SENSOR_SETTINGS", "BURST_CAPTURE", "YUV_REPROCESSING", "DEPTH_OUTPUT", "CONSTRAINED_HIGH_SPEED_VIDEO", "FULL_LEVEL" }; }; /* namespace android */ anbox-0.0~git20191115/android/camera/EmulatedCamera3.h000066400000000000000000000157031356361734700222100ustar00rootroot00000000000000/* * Copyright (C) 2013 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef HW_EMULATOR_CAMERA_EMULATED_CAMERA3_H #define HW_EMULATOR_CAMERA_EMULATED_CAMERA3_H /** * Contains declaration of a class EmulatedCamera that encapsulates * functionality common to all version 3.0 emulated camera devices. Instances * of this class (for each emulated camera) are created during the construction * of the EmulatedCameraFactory instance. This class serves as an entry point * for all camera API calls that defined by camera3_device_ops_t API. */ #include "hardware/camera3.h" #include "system/camera_metadata.h" #include "EmulatedBaseCamera.h" namespace android { /** * Encapsulates functionality common to all version 3.0 emulated camera devices * * Note that EmulatedCameraFactory instantiates an object of this class just * once, when EmulatedCameraFactory instance gets constructed. Connection to / * disconnection from the actual camera device is handled by calls to * connectDevice(), and closeCamera() methods of this class that are invoked in * response to hw_module_methods_t::open, and camera_device::close callbacks. */ class EmulatedCamera3 : public camera3_device, public EmulatedBaseCamera { public: /* Constructs EmulatedCamera3 instance. * Param: * cameraId - Zero based camera identifier, which is an index of the camera * instance in camera factory's array. * module - Emulated camera HAL module descriptor. */ EmulatedCamera3(int cameraId, struct hw_module_t* module); /* Destructs EmulatedCamera2 instance. */ virtual ~EmulatedCamera3(); /* List of all defined capabilities plus useful HW levels */ enum AvailableCapabilities { BACKWARD_COMPATIBLE, MANUAL_SENSOR, MANUAL_POST_PROCESSING, RAW, PRIVATE_REPROCESSING, READ_SENSOR_SETTINGS, BURST_CAPTURE, YUV_REPROCESSING, DEPTH_OUTPUT, CONSTRAINED_HIGH_SPEED_VIDEO, // Levels FULL_LEVEL, NUM_CAPABILITIES }; // Char strings for above enum, with size NUM_CAPABILITIES static const char *sAvailableCapabilitiesStrings[]; /**************************************************************************** * Abstract API ***************************************************************************/ public: /**************************************************************************** * Public API ***************************************************************************/ public: virtual status_t Initialize(); /**************************************************************************** * Camera module API and generic hardware device API implementation ***************************************************************************/ public: virtual status_t connectCamera(hw_device_t** device); virtual status_t closeCamera(); virtual status_t getCameraInfo(struct camera_info* info); /**************************************************************************** * Camera API implementation. * These methods are called from the camera API callback routines. ***************************************************************************/ protected: virtual status_t initializeDevice( const camera3_callback_ops *callbackOps); virtual status_t configureStreams( camera3_stream_configuration *streamList); virtual status_t registerStreamBuffers( const camera3_stream_buffer_set *bufferSet) ; virtual const camera_metadata_t* constructDefaultRequestSettings( int type); virtual status_t processCaptureRequest(camera3_capture_request *request); virtual status_t flush(); /** Debug methods */ virtual void dump(int fd); /**************************************************************************** * Camera API callbacks as defined by camera3_device_ops structure. See * hardware/libhardware/include/hardware/camera3.h for information on each * of these callbacks. Implemented in this class, these callbacks simply * dispatch the call into an instance of EmulatedCamera3 class defined in * the 'camera_device3' parameter. ***************************************************************************/ private: /** Startup */ static int initialize(const struct camera3_device *, const camera3_callback_ops_t *callback_ops); /** Stream configuration and buffer registration */ static int configure_streams(const struct camera3_device *, camera3_stream_configuration_t *stream_list); static int register_stream_buffers(const struct camera3_device *, const camera3_stream_buffer_set_t *buffer_set); /** Template request settings provision */ static const camera_metadata_t* construct_default_request_settings( const struct camera3_device *, int type); /** Submission of capture requests to HAL */ static int process_capture_request(const struct camera3_device *, camera3_capture_request_t *request); static void dump(const camera3_device_t *, int fd); static int flush(const camera3_device_t *); /** For hw_device_t ops */ static int close(struct hw_device_t* device); /**************************************************************************** * Data members shared with implementations ***************************************************************************/ protected: enum { // State at construction time, and after a device operation error STATUS_ERROR = 0, // State after startup-time init and after device instance close STATUS_CLOSED, // State after being opened, before device instance init STATUS_OPEN, // State after device instance initialization STATUS_READY, // State while actively capturing data STATUS_ACTIVE } mStatus; /** * Callbacks back to the framework */ void sendCaptureResult(camera3_capture_result_t *result); void sendNotify(camera3_notify_msg_t *msg); /**************************************************************************** * Data members ***************************************************************************/ private: static camera3_device_ops_t sDeviceOps; const camera3_callback_ops_t *mCallbackOps; }; }; /* namespace android */ #endif /* HW_EMULATOR_CAMERA_EMULATED_CAMERA3_H */ anbox-0.0~git20191115/android/camera/EmulatedCameraCommon.h000077500000000000000000000035051356361734700232760ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef HW_EMULATOR_CAMERA_EMULATED_CAMERA_COMMON_H #define HW_EMULATOR_CAMERA_EMULATED_CAMERA_COMMON_H /* * Contains common declarations that are used across the camera emulation. */ #include #include /* A helper class that tracks a routine execution. * Basically, it dumps an enry message in its constructor, and an exit message * in its destructor. Use LOGRE() macro (declared bellow) to create instances * of this class at the beginning of the tracked routines / methods. */ class HWERoutineTracker { public: /* Constructor that prints an "entry" trace message. */ explicit HWERoutineTracker(const char* name) : mName(name) { ALOGV("Entering %s", mName); } /* Destructor that prints a "leave" trace message. */ ~HWERoutineTracker() { ALOGV("Leaving %s", mName); } private: /* Stores the routine name. */ const char* mName; }; /* Logs an execution of a routine / method. */ #define LOGRE() HWERoutineTracker hwertracker_##__LINE__(__FUNCTION__) /* * min / max macros */ #define min(a,b) (((a) < (b)) ? (a) : (b)) #define max(a,b) (((a) > (b)) ? (a) : (b)) #endif /* HW_EMULATOR_CAMERA_EMULATED_CAMERA_COMMON_H */ anbox-0.0~git20191115/android/camera/EmulatedCameraDevice.cpp000077500000000000000000000322631356361734700236030ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * Contains implementation of an abstract class EmulatedCameraDevice that defines * functionality expected from an emulated physical camera device: * - Obtaining and setting camera parameters * - Capturing frames * - Streaming video * - etc. */ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_Device" #include #include #include #include "EmulatedCameraDevice.h" namespace android { const float GAMMA_CORRECTION = 2.2f; EmulatedCameraDevice::EmulatedCameraDevice(EmulatedCamera* camera_hal) : mObjectLock(), mCurFrameTimestamp(0), mCameraHAL(camera_hal), mCurrentFrame(NULL), mExposureCompensation(1.0f), mWhiteBalanceScale(NULL), mSupportedWhiteBalanceScale(), mState(ECDS_CONSTRUCTED) { } EmulatedCameraDevice::~EmulatedCameraDevice() { ALOGV("EmulatedCameraDevice destructor"); if (mCurrentFrame != NULL) { delete[] mCurrentFrame; } for (size_t i = 0; i < mSupportedWhiteBalanceScale.size(); ++i) { if (mSupportedWhiteBalanceScale.valueAt(i) != NULL) { delete[] mSupportedWhiteBalanceScale.valueAt(i); } } } /**************************************************************************** * Emulated camera device public API ***************************************************************************/ status_t EmulatedCameraDevice::Initialize() { if (isInitialized()) { ALOGW("%s: Emulated camera device is already initialized: mState = %d", __FUNCTION__, mState); return NO_ERROR; } /* Instantiate worker thread object. */ mWorkerThread = new WorkerThread(this); if (getWorkerThread() == NULL) { ALOGE("%s: Unable to instantiate worker thread object", __FUNCTION__); return ENOMEM; } mState = ECDS_INITIALIZED; return NO_ERROR; } status_t EmulatedCameraDevice::startDeliveringFrames(bool one_burst) { ALOGV("%s", __FUNCTION__); if (!isStarted()) { ALOGE("%s: Device is not started", __FUNCTION__); return EINVAL; } /* Frames will be delivered from the thread routine. */ const status_t res = startWorkerThread(one_burst); ALOGE_IF(res != NO_ERROR, "%s: startWorkerThread failed", __FUNCTION__); return res; } status_t EmulatedCameraDevice::stopDeliveringFrames() { ALOGV("%s", __FUNCTION__); if (!isStarted()) { ALOGW("%s: Device is not started", __FUNCTION__); return NO_ERROR; } const status_t res = stopWorkerThread(); ALOGE_IF(res != NO_ERROR, "%s: startWorkerThread failed", __FUNCTION__); return res; } void EmulatedCameraDevice::setExposureCompensation(const float ev) { ALOGV("%s", __FUNCTION__); if (!isStarted()) { ALOGW("%s: Fake camera device is not started.", __FUNCTION__); } mExposureCompensation = std::pow(2.0f, ev / GAMMA_CORRECTION); ALOGV("New exposure compensation is %f", mExposureCompensation); } void EmulatedCameraDevice::initializeWhiteBalanceModes(const char* mode, const float r_scale, const float b_scale) { ALOGV("%s with %s, %f, %f", __FUNCTION__, mode, r_scale, b_scale); float* value = new float[3]; value[0] = r_scale; value[1] = 1.0f; value[2] = b_scale; mSupportedWhiteBalanceScale.add(String8(mode), value); } void EmulatedCameraDevice::setWhiteBalanceMode(const char* mode) { ALOGV("%s with white balance %s", __FUNCTION__, mode); mWhiteBalanceScale = mSupportedWhiteBalanceScale.valueFor(String8(mode)); } /* Computes the pixel value after adjusting the white balance to the current * one. The input the y, u, v channel of the pixel and the adjusted value will * be stored in place. The adjustment is done in RGB space. */ void EmulatedCameraDevice::changeWhiteBalance(uint8_t& y, uint8_t& u, uint8_t& v) const { float r_scale = mWhiteBalanceScale[0]; float b_scale = mWhiteBalanceScale[2]; int r = static_cast(YUV2R(y, u, v)) / r_scale; int g = YUV2G(y, u, v); int b = static_cast(YUV2B(y, u, v)) / b_scale; y = RGB2Y(r, g, b); u = RGB2U(r, g, b); v = RGB2V(r, g, b); } status_t EmulatedCameraDevice::getCurrentPreviewFrame(void* buffer) { if (!isStarted()) { ALOGE("%s: Device is not started", __FUNCTION__); return EINVAL; } if (mCurrentFrame == NULL || buffer == NULL) { ALOGE("%s: No framebuffer", __FUNCTION__); return EINVAL; } /* In emulation the framebuffer is never RGB. */ switch (mPixelFormat) { case V4L2_PIX_FMT_YVU420: YV12ToRGB32(mCurrentFrame, buffer, mFrameWidth, mFrameHeight); return NO_ERROR; case V4L2_PIX_FMT_YUV420: YU12ToRGB32(mCurrentFrame, buffer, mFrameWidth, mFrameHeight); return NO_ERROR; case V4L2_PIX_FMT_NV21: NV21ToRGB32(mCurrentFrame, buffer, mFrameWidth, mFrameHeight); return NO_ERROR; case V4L2_PIX_FMT_NV12: NV12ToRGB32(mCurrentFrame, buffer, mFrameWidth, mFrameHeight); return NO_ERROR; default: ALOGE("%s: Unknown pixel format %.4s", __FUNCTION__, reinterpret_cast(&mPixelFormat)); return EINVAL; } } /**************************************************************************** * Emulated camera device private API ***************************************************************************/ status_t EmulatedCameraDevice::commonStartDevice(int width, int height, uint32_t pix_fmt) { /* Validate pixel format, and calculate framebuffer size at the same time. */ switch (pix_fmt) { case V4L2_PIX_FMT_YVU420: case V4L2_PIX_FMT_YUV420: case V4L2_PIX_FMT_NV21: case V4L2_PIX_FMT_NV12: mFrameBufferSize = (width * height * 12) / 8; break; default: ALOGE("%s: Unknown pixel format %.4s", __FUNCTION__, reinterpret_cast(&pix_fmt)); return EINVAL; } /* Cache framebuffer info. */ mFrameWidth = width; mFrameHeight = height; mPixelFormat = pix_fmt; mTotalPixels = width * height; /* Allocate framebuffer. */ mCurrentFrame = new uint8_t[mFrameBufferSize]; if (mCurrentFrame == NULL) { ALOGE("%s: Unable to allocate framebuffer", __FUNCTION__); return ENOMEM; } ALOGV("%s: Allocated %p %zu bytes for %d pixels in %.4s[%dx%d] frame", __FUNCTION__, mCurrentFrame, mFrameBufferSize, mTotalPixels, reinterpret_cast(&mPixelFormat), mFrameWidth, mFrameHeight); return NO_ERROR; } void EmulatedCameraDevice::commonStopDevice() { mFrameWidth = mFrameHeight = mTotalPixels = 0; mPixelFormat = 0; if (mCurrentFrame != NULL) { delete[] mCurrentFrame; mCurrentFrame = NULL; } } /**************************************************************************** * Worker thread management. ***************************************************************************/ status_t EmulatedCameraDevice::startWorkerThread(bool one_burst) { ALOGV("%s", __FUNCTION__); if (!isInitialized()) { ALOGE("%s: Emulated camera device is not initialized", __FUNCTION__); return EINVAL; } const status_t res = getWorkerThread()->startThread(one_burst); ALOGE_IF(res != NO_ERROR, "%s: Unable to start worker thread", __FUNCTION__); return res; } status_t EmulatedCameraDevice::stopWorkerThread() { ALOGV("%s", __FUNCTION__); if (!isInitialized()) { ALOGE("%s: Emulated camera device is not initialized", __FUNCTION__); return EINVAL; } const status_t res = getWorkerThread()->stopThread(); ALOGE_IF(res != NO_ERROR, "%s: Unable to stop worker thread", __FUNCTION__); return res; } bool EmulatedCameraDevice::inWorkerThread() { /* This will end the thread loop, and will terminate the thread. Derived * classes must override this method. */ return false; } /**************************************************************************** * Worker thread implementation. ***************************************************************************/ status_t EmulatedCameraDevice::WorkerThread::readyToRun() { ALOGV("Starting emulated camera device worker thread..."); ALOGW_IF(mThreadControl >= 0 || mControlFD >= 0, "%s: Thread control FDs are opened", __FUNCTION__); /* Create a pair of FDs that would be used to control the thread. */ int thread_fds[2]; status_t ret; Mutex::Autolock lock(mCameraDevice->mObjectLock); if (pipe(thread_fds) == 0) { mThreadControl = thread_fds[1]; mControlFD = thread_fds[0]; ALOGV("Emulated device's worker thread has been started."); ret = NO_ERROR; } else { ALOGE("%s: Unable to create thread control FDs: %d -> %s", __FUNCTION__, errno, strerror(errno)); ret = errno; } mSetup.signal(); return ret; } status_t EmulatedCameraDevice::WorkerThread::stopThread() { ALOGV("Stopping emulated camera device's worker thread..."); status_t res = EINVAL; // Limit the scope of the Autolock { // If thread is running and readyToRun() has not finished running, // then wait until it is done. Mutex::Autolock lock(mCameraDevice->mObjectLock); if (isRunning() && (mThreadControl < 0 || mControlFD < 0)) { mSetup.wait(mCameraDevice->mObjectLock); } } if (mThreadControl >= 0) { /* Send "stop" message to the thread loop. */ const ControlMessage msg = THREAD_STOP; const int wres = TEMP_FAILURE_RETRY(write(mThreadControl, &msg, sizeof(msg))); if (wres == sizeof(msg)) { /* Stop the thread, and wait till it's terminated. */ res = requestExitAndWait(); if (res == NO_ERROR) { /* Close control FDs. */ if (mThreadControl >= 0) { close(mThreadControl); mThreadControl = -1; } if (mControlFD >= 0) { close(mControlFD); mControlFD = -1; } ALOGV("Emulated camera device's worker thread has been stopped."); } else { ALOGE("%s: requestExitAndWait failed: %d -> %s", __FUNCTION__, res, strerror(-res)); } } else { ALOGE("%s: Unable to send THREAD_STOP message: %d -> %s", __FUNCTION__, errno, strerror(errno)); res = errno ? errno : EINVAL; } } else { ALOGE("%s: Thread control FDs are not opened", __FUNCTION__); } return res; } EmulatedCameraDevice::WorkerThread::SelectRes EmulatedCameraDevice::WorkerThread::Select(int fd, int timeout) { fd_set fds[1]; struct timeval tv, *tvp = NULL; const int fd_num = (fd >= 0) ? max(fd, mControlFD) + 1 : mControlFD + 1; FD_ZERO(fds); FD_SET(mControlFD, fds); if (fd >= 0) { FD_SET(fd, fds); } if (timeout) { tv.tv_sec = timeout / 1000000; tv.tv_usec = timeout % 1000000; tvp = &tv; } int res = TEMP_FAILURE_RETRY(select(fd_num, fds, NULL, NULL, tvp)); if (res < 0) { ALOGE("%s: select returned %d and failed: %d -> %s", __FUNCTION__, res, errno, strerror(errno)); return ERROR; } else if (res == 0) { /* Timeout. */ return TIMEOUT; } else if (FD_ISSET(mControlFD, fds)) { /* A control event. Lets read the message. */ ControlMessage msg; res = TEMP_FAILURE_RETRY(read(mControlFD, &msg, sizeof(msg))); if (res != sizeof(msg)) { ALOGE("%s: Unexpected message size %d, or an error %d -> %s", __FUNCTION__, res, errno, strerror(errno)); return ERROR; } /* THREAD_STOP is the only message expected here. */ if (msg == THREAD_STOP) { ALOGV("%s: THREAD_STOP message is received", __FUNCTION__); return EXIT_THREAD; } else { ALOGE("Unknown worker thread message %d", msg); return ERROR; } } else { /* Must be an FD. */ ALOGW_IF(fd < 0 || !FD_ISSET(fd, fds), "%s: Undefined 'select' result", __FUNCTION__); return READY; } } }; /* namespace android */ anbox-0.0~git20191115/android/camera/EmulatedCameraDevice.h000077500000000000000000000523541356361734700232530ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef HW_EMULATOR_CAMERA_EMULATED_CAMERA_DEVICE_H #define HW_EMULATOR_CAMERA_EMULATED_CAMERA_DEVICE_H /* * Contains declaration of an abstract class EmulatedCameraDevice that defines * functionality expected from an emulated physical camera device: * - Obtaining and setting camera device parameters * - Capturing frames * - Streaming video * - etc. */ #include #include #include #include "EmulatedCameraCommon.h" #include "Converters.h" namespace android { class EmulatedCamera; /* Encapsulates an abstract class EmulatedCameraDevice that defines * functionality expected from an emulated physical camera device: * - Obtaining and setting camera device parameters * - Capturing frames * - Streaming video * - etc. */ class EmulatedCameraDevice { public: /* Constructs EmulatedCameraDevice instance. * Param: * camera_hal - Emulated camera that implements the camera HAL API, and * manages (contains) this object. */ explicit EmulatedCameraDevice(EmulatedCamera* camera_hal); /* Destructs EmulatedCameraDevice instance. */ virtual ~EmulatedCameraDevice(); /*************************************************************************** * Emulated camera device abstract interface **************************************************************************/ public: /* Connects to the camera device. * This method must be called on an initialized instance of this class. * Return: * NO_ERROR on success, or an appropriate error status. */ virtual status_t connectDevice() = 0; /* Disconnects from the camera device. * Return: * NO_ERROR on success, or an appropriate error status. If this method is * called for already disconnected, or uninitialized instance of this class, * a successful status must be returned from this method. If this method is * called for an instance that is in the "started" state, this method must * return a failure. */ virtual status_t disconnectDevice() = 0; /* Starts the camera device. * This method tells the camera device to start capturing frames of the given * dimensions for the given pixel format. Note that this method doesn't start * the delivery of the captured frames to the emulated camera. Call * startDeliveringFrames method to start delivering frames. This method must * be called on a connected instance of this class. If it is called on a * disconnected instance, this method must return a failure. * Param: * width, height - Frame dimensions to use when capturing video frames. * pix_fmt - Pixel format to use when capturing video frames. * Return: * NO_ERROR on success, or an appropriate error status. */ virtual status_t startDevice(int width, int height, uint32_t pix_fmt) = 0; /* Stops the camera device. * This method tells the camera device to stop capturing frames. Note that * this method doesn't stop delivering frames to the emulated camera. Always * call stopDeliveringFrames prior to calling this method. * Return: * NO_ERROR on success, or an appropriate error status. If this method is * called for an object that is not capturing frames, or is disconnected, * or is uninitialized, a successful status must be returned from this * method. */ virtual status_t stopDevice() = 0; /*************************************************************************** * Emulated camera device public API **************************************************************************/ public: /* Initializes EmulatedCameraDevice instance. * Derived classes should override this method in order to cache static * properties of the physical device (list of supported pixel formats, frame * sizes, etc.) If this method is called on an already initialized instance, * it must return a successful status. * Return: * NO_ERROR on success, or an appropriate error status. */ virtual status_t Initialize(); /* Initializes the white balance modes parameters. * The parameters are passed by each individual derived camera API to * represent that different camera manufacturers may have different * preferences on the white balance parameters. Green channel in the RGB * color space is fixed to keep the luminance to be reasonably constant. * * Param: * mode the text describing the current white balance mode * r_scale the scale factor for the R channel in RGB space * b_scale the scale factor for the B channel in RGB space. */ void initializeWhiteBalanceModes(const char* mode, const float r_scale, const float b_scale); /* Starts delivering frames captured from the camera device. * This method will start the worker thread that would be pulling frames from * the camera device, and will deliver the pulled frames back to the emulated * camera via onNextFrameAvailable callback. This method must be called on a * connected instance of this class with a started camera device. If it is * called on a disconnected instance, or camera device has not been started, * this method must return a failure. * Param: * one_burst - Controls how many frames should be delivered. If this * parameter is 'true', only one captured frame will be delivered to the * emulated camera. If this parameter is 'false', frames will keep * coming until stopDeliveringFrames method is called. Typically, this * parameter is set to 'true' only in order to obtain a single frame * that will be used as a "picture" in takePicture method of the * emulated camera. * Return: * NO_ERROR on success, or an appropriate error status. */ virtual status_t startDeliveringFrames(bool one_burst); /* Stops delivering frames captured from the camera device. * This method will stop the worker thread started by startDeliveringFrames. * Return: * NO_ERROR on success, or an appropriate error status. */ virtual status_t stopDeliveringFrames(); /* Sets the exposure compensation for the camera device. */ void setExposureCompensation(const float ev); /* Sets the white balance mode for the device. */ void setWhiteBalanceMode(const char* mode); /* Gets current framebuffer, converted into preview frame format. * This method must be called on a connected instance of this class with a * started camera device. If it is called on a disconnected instance, or * camera device has not been started, this method must return a failure. * Note that this method should be called only after at least one frame has * been captured and delivered. Otherwise it will return garbage in the * preview frame buffer. Typically, this method shuld be called from * onNextFrameAvailable callback. * Param: * buffer - Buffer, large enough to contain the entire preview frame. * Return: * NO_ERROR on success, or an appropriate error status. */ virtual status_t getCurrentPreviewFrame(void* buffer); /* Gets width of the frame obtained from the physical device. * Return: * Width of the frame obtained from the physical device. Note that value * returned from this method is valid only in case if camera device has been * started. */ inline int getFrameWidth() const { ALOGE_IF(!isStarted(), "%s: Device is not started", __FUNCTION__); return mFrameWidth; } /* Gets height of the frame obtained from the physical device. * Return: * Height of the frame obtained from the physical device. Note that value * returned from this method is valid only in case if camera device has been * started. */ inline int getFrameHeight() const { ALOGE_IF(!isStarted(), "%s: Device is not started", __FUNCTION__); return mFrameHeight; } /* Gets byte size of the current frame buffer. * Return: * Byte size of the frame buffer. Note that value returned from this method * is valid only in case if camera device has been started. */ inline size_t getFrameBufferSize() const { ALOGE_IF(!isStarted(), "%s: Device is not started", __FUNCTION__); return mFrameBufferSize; } /* Gets number of pixels in the current frame buffer. * Return: * Number of pixels in the frame buffer. Note that value returned from this * method is valid only in case if camera device has been started. */ inline int getPixelNum() const { ALOGE_IF(!isStarted(), "%s: Device is not started", __FUNCTION__); return mTotalPixels; } /* Gets pixel format of the frame that camera device streams to this class. * Throughout camera framework, there are three different forms of pixel * format representation: * - Original format, as reported by the actual camera device. Values for * this format are declared in bionic/libc/kernel/common/linux/videodev2.h * - String representation as defined in CameraParameters::PIXEL_FORMAT_XXX * strings in frameworks/base/include/camera/CameraParameters.h * - HAL_PIXEL_FORMAT_XXX format, as defined in system/core/include/system/graphics.h * Since emulated camera device gets its data from the actual device, it gets * pixel format in the original form. And that's the pixel format * representation that will be returned from this method. HAL components will * need to translate value returned from this method to the appropriate form. * This method must be called only on started instance of this class, since * it's applicable only when camera device is ready to stream frames. * Param: * pix_fmt - Upon success contains the original pixel format. * Return: * Current framebuffer's pixel format. Note that value returned from this * method is valid only in case if camera device has been started. */ inline uint32_t getOriginalPixelFormat() const { ALOGE_IF(!isStarted(), "%s: Device is not started", __FUNCTION__); return mPixelFormat; } /* * State checkers. */ inline bool isInitialized() const { /* Instance is initialized when the worker thread has been successfuly * created (but not necessarily started). */ return mWorkerThread.get() != NULL && mState != ECDS_CONSTRUCTED; } inline bool isConnected() const { /* Instance is connected when its status is either"connected", or * "started". */ return mState == ECDS_CONNECTED || mState == ECDS_STARTED; } inline bool isStarted() const { return mState == ECDS_STARTED; } /**************************************************************************** * Emulated camera device private API ***************************************************************************/ protected: /* Performs common validation and calculation of startDevice parameters. * Param: * width, height, pix_fmt - Parameters passed to the startDevice method. * Return: * NO_ERROR on success, or an appropriate error status. */ virtual status_t commonStartDevice(int width, int height, uint32_t pix_fmt); /* Performs common cleanup on stopDevice. * This method will undo what commonStartDevice had done. */ virtual void commonStopDevice(); /** Computes a luminance value after taking the exposure compensation. * value into account. * * Param: * inputY - The input luminance value. * Return: * The luminance value after adjusting the exposure compensation. */ inline uint8_t changeExposure(const uint8_t& inputY) const { return static_cast(clamp(static_cast(inputY) * mExposureCompensation)); } /** Computes the pixel value in YUV space after adjusting to the current * white balance mode. */ void changeWhiteBalance(uint8_t& y, uint8_t& u, uint8_t& v) const; /**************************************************************************** * Worker thread management. * Typicaly when emulated camera device starts capturing frames from the * actual device, it does that in a worker thread created in StartCapturing, * and terminated in StopCapturing. Since this is such a typical scenario, * it makes sence to encapsulate worker thread management in the base class * for all emulated camera devices. ***************************************************************************/ protected: /* Starts the worker thread. * Typically, worker thread is started from startDeliveringFrames method of * this class. * Param: * one_burst - Controls how many times thread loop should run. If this * parameter is 'true', thread routine will run only once If this * parameter is 'false', thread routine will run until stopWorkerThread * method is called. See startDeliveringFrames for more info. * Return: * NO_ERROR on success, or an appropriate error status. */ virtual status_t startWorkerThread(bool one_burst); /* Stops the worker thread. * Note that this method will always wait for the worker thread to terminate. * Typically, worker thread is started from stopDeliveringFrames method of * this class. * Return: * NO_ERROR on success, or an appropriate error status. */ virtual status_t stopWorkerThread(); /* Implementation of the worker thread routine. * In the default implementation of the worker thread routine we simply * return 'false' forcing the thread loop to exit, and the thread to * terminate. Derived class should override that method to provide there the * actual frame delivery. * Return: * true To continue thread loop (this method will be called again), or false * to exit the thread loop and to terminate the thread. */ virtual bool inWorkerThread(); /* Encapsulates a worker thread used by the emulated camera device. */ friend class WorkerThread; class WorkerThread : public Thread { /**************************************************************************** * Public API ***************************************************************************/ public: inline explicit WorkerThread(EmulatedCameraDevice* camera_dev) : Thread(true), // Callbacks may involve Java calls. mCameraDevice(camera_dev), mThreadControl(-1), mControlFD(-1) { } inline ~WorkerThread() { ALOGW_IF(mThreadControl >= 0 || mControlFD >= 0, "%s: Control FDs are opened in the destructor", __FUNCTION__); if (mThreadControl >= 0) { close(mThreadControl); } if (mControlFD >= 0) { close(mControlFD); } } /* Starts the thread * Param: * one_burst - Controls how many times thread loop should run. If * this parameter is 'true', thread routine will run only once * If this parameter is 'false', thread routine will run until * stopThread method is called. See startWorkerThread for more * info. * Return: * NO_ERROR on success, or an appropriate error status. */ inline status_t startThread(bool one_burst) { mOneBurst = one_burst; return run("Camera_startThread", ANDROID_PRIORITY_URGENT_DISPLAY, 0); } /* Overriden base class method. * It is overriden in order to provide one-time initialization just * prior to starting the thread routine. */ status_t readyToRun(); /* Stops the thread. */ status_t stopThread(); /* Values returned from the Select method of this class. */ enum SelectRes { /* A timeout has occurred. */ TIMEOUT, /* Data are available for read on the provided FD. */ READY, /* Thread exit request has been received. */ EXIT_THREAD, /* An error has occurred. */ ERROR }; /* Select on an FD event, keeping in mind thread exit message. * Param: * fd - File descriptor on which to wait for an event. This * parameter may be negative. If it is negative this method will * only wait on a control message to the thread. * timeout - Timeout in microseconds. 0 indicates no timeout (wait * forever). * Return: * See SelectRes enum comments. */ SelectRes Select(int fd, int timeout); /**************************************************************************** * Private API ***************************************************************************/ private: /* Implements abstract method of the base Thread class. */ bool threadLoop() { /* Simply dispatch the call to the containing camera device. */ if (mCameraDevice->inWorkerThread()) { /* Respect "one burst" parameter (see startThread). */ return !mOneBurst; } else { return false; } } /* Containing camera device object. */ EmulatedCameraDevice* mCameraDevice; /* FD that is used to send control messages into the thread. */ int mThreadControl; /* FD that thread uses to receive control messages. */ int mControlFD; /* Controls number of times the thread loop runs. * See startThread for more information. */ bool mOneBurst; /* Enumerates control messages that can be sent into the thread. */ enum ControlMessage { /* Stop the thread. */ THREAD_STOP }; Condition mSetup; }; /* Worker thread accessor. */ inline WorkerThread* getWorkerThread() const { return mWorkerThread.get(); } /**************************************************************************** * Data members ***************************************************************************/ protected: /* Locks this instance for parameters, state, etc. change. */ Mutex mObjectLock; /* Worker thread that is used in frame capturing. */ sp mWorkerThread; /* Timestamp of the current frame. */ nsecs_t mCurFrameTimestamp; /* Emulated camera object containing this instance. */ EmulatedCamera* mCameraHAL; /* Framebuffer containing the current frame. */ uint8_t* mCurrentFrame; /* * Framebuffer properties. */ /* Byte size of the framebuffer. */ size_t mFrameBufferSize; /* Original pixel format (one of the V4L2_PIX_FMT_XXX values, as defined in * bionic/libc/kernel/common/linux/videodev2.h */ uint32_t mPixelFormat; /* Frame width */ int mFrameWidth; /* Frame height */ int mFrameHeight; /* Total number of pixels */ int mTotalPixels; /* Exposure compensation value */ float mExposureCompensation; float* mWhiteBalanceScale; DefaultKeyedVector mSupportedWhiteBalanceScale; /* Defines possible states of the emulated camera device object. */ enum EmulatedCameraDeviceState { /* Object has been constructed. */ ECDS_CONSTRUCTED, /* Object has been initialized. */ ECDS_INITIALIZED, /* Object has been connected to the physical device. */ ECDS_CONNECTED, /* Camera device has been started. */ ECDS_STARTED, }; /* Object state. */ EmulatedCameraDeviceState mState; }; }; /* namespace android */ #endif /* HW_EMULATOR_CAMERA_EMULATED_CAMERA_DEVICE_H */ anbox-0.0~git20191115/android/camera/EmulatedCameraFactory.cpp000077500000000000000000000443761356361734700240230ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * Contains implementation of a class EmulatedCameraFactory that manages cameras * available for emulation. */ //#define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_Factory" #include #include #include "EmulatedQemuCamera.h" #include "EmulatedFakeCamera.h" #include "EmulatedFakeCamera2.h" #include "EmulatedFakeCamera3.h" #include "EmulatedCameraHotplugThread.h" #include "EmulatedCameraFactory.h" extern camera_module_t HAL_MODULE_INFO_SYM; /* A global instance of EmulatedCameraFactory is statically instantiated and * initialized when camera emulation HAL is loaded. */ android::EmulatedCameraFactory gEmulatedCameraFactory; namespace android { EmulatedCameraFactory::EmulatedCameraFactory() : mQemuClient(), mEmulatedCameras(NULL), mEmulatedCameraNum(0), mFakeCameraNum(0), mConstructedOK(false), mCallbacks(NULL) { status_t res; /* Connect to the factory service in the emulator, and create Qemu cameras. */ if (mQemuClient.connectClient(NULL) == NO_ERROR) { /* Connection has succeeded. Create emulated cameras for each camera * device, reported by the service. */ createQemuCameras(); } if (isBackFakeCameraEmulationOn()) { /* Camera ID. */ const int camera_id = mEmulatedCameraNum; /* Use fake camera to emulate back-facing camera. */ mEmulatedCameraNum++; /* Make sure that array is allocated (in case there were no 'qemu' * cameras created. Note that we preallocate the array so it may contain * two fake cameras: one facing back, and another facing front. */ if (mEmulatedCameras == NULL) { mEmulatedCameras = new EmulatedBaseCamera*[mEmulatedCameraNum + 1]; if (mEmulatedCameras == NULL) { ALOGE("%s: Unable to allocate emulated camera array for %d entries", __FUNCTION__, mEmulatedCameraNum); return; } memset(mEmulatedCameras, 0, (mEmulatedCameraNum + 1) * sizeof(EmulatedBaseCamera*)); } /* Create, and initialize the fake camera */ switch (getBackCameraHalVersion()) { case 1: mEmulatedCameras[camera_id] = new EmulatedFakeCamera(camera_id, true, &HAL_MODULE_INFO_SYM.common); break; case 2: mEmulatedCameras[camera_id] = new EmulatedFakeCamera2(camera_id, true, &HAL_MODULE_INFO_SYM.common); break; case 3: mEmulatedCameras[camera_id] = new EmulatedFakeCamera3(camera_id, true, &HAL_MODULE_INFO_SYM.common); break; default: ALOGE("%s: Unknown back camera hal version requested: %d", __FUNCTION__, getBackCameraHalVersion()); } if (mEmulatedCameras[camera_id] != NULL) { ALOGV("%s: Back camera device version is %d", __FUNCTION__, getBackCameraHalVersion()); res = mEmulatedCameras[camera_id]->Initialize(); if (res != NO_ERROR) { ALOGE("%s: Unable to intialize back camera %d: %s (%d)", __FUNCTION__, camera_id, strerror(-res), res); delete mEmulatedCameras[camera_id]; mEmulatedCameraNum--; } } else { mEmulatedCameraNum--; ALOGE("%s: Unable to instantiate fake camera class", __FUNCTION__); } } if (isFrontFakeCameraEmulationOn()) { /* Camera ID. */ const int camera_id = mEmulatedCameraNum; /* Use fake camera to emulate front-facing camera. */ mEmulatedCameraNum++; /* Make sure that array is allocated (in case there were no 'qemu' * cameras created. */ if (mEmulatedCameras == NULL) { mEmulatedCameras = new EmulatedBaseCamera*[mEmulatedCameraNum]; if (mEmulatedCameras == NULL) { ALOGE("%s: Unable to allocate emulated camera array for %d entries", __FUNCTION__, mEmulatedCameraNum); return; } memset(mEmulatedCameras, 0, mEmulatedCameraNum * sizeof(EmulatedBaseCamera*)); } /* Create, and initialize the fake camera */ switch (getFrontCameraHalVersion()) { case 1: mEmulatedCameras[camera_id] = new EmulatedFakeCamera(camera_id, false, &HAL_MODULE_INFO_SYM.common); break; case 2: mEmulatedCameras[camera_id] = new EmulatedFakeCamera2(camera_id, false, &HAL_MODULE_INFO_SYM.common); break; case 3: mEmulatedCameras[camera_id] = new EmulatedFakeCamera3(camera_id, false, &HAL_MODULE_INFO_SYM.common); break; default: ALOGE("%s: Unknown front camera hal version requested: %d", __FUNCTION__, getFrontCameraHalVersion()); } if (mEmulatedCameras[camera_id] != NULL) { ALOGV("%s: Front camera device version is %d", __FUNCTION__, getFrontCameraHalVersion()); res = mEmulatedCameras[camera_id]->Initialize(); if (res != NO_ERROR) { ALOGE("%s: Unable to intialize front camera %d: %s (%d)", __FUNCTION__, camera_id, strerror(-res), res); delete mEmulatedCameras[camera_id]; mEmulatedCameraNum--; } } else { mEmulatedCameraNum--; ALOGE("%s: Unable to instantiate fake camera class", __FUNCTION__); } } ALOGV("%d cameras are being emulated. %d of them are fake cameras.", mEmulatedCameraNum, mFakeCameraNum); /* Create hotplug thread */ { Vector cameraIdVector; for (int i = 0; i < mEmulatedCameraNum; ++i) { cameraIdVector.push_back(i); } mHotplugThread = new EmulatedCameraHotplugThread(&cameraIdVector[0], mEmulatedCameraNum); mHotplugThread->run("EmulatedCameraHotplugThread"); } mConstructedOK = true; } EmulatedCameraFactory::~EmulatedCameraFactory() { if (mEmulatedCameras != NULL) { for (int n = 0; n < mEmulatedCameraNum; n++) { if (mEmulatedCameras[n] != NULL) { delete mEmulatedCameras[n]; } } delete[] mEmulatedCameras; } if (mHotplugThread != NULL) { mHotplugThread->requestExit(); mHotplugThread->join(); } } /**************************************************************************** * Camera HAL API handlers. * * Each handler simply verifies existence of an appropriate EmulatedBaseCamera * instance, and dispatches the call to that instance. * ***************************************************************************/ int EmulatedCameraFactory::cameraDeviceOpen(int camera_id, hw_device_t** device) { ALOGV("%s: id = %d", __FUNCTION__, camera_id); *device = NULL; if (!isConstructedOK()) { ALOGE("%s: EmulatedCameraFactory has failed to initialize", __FUNCTION__); return -EINVAL; } if (camera_id < 0 || camera_id >= getEmulatedCameraNum()) { ALOGE("%s: Camera id %d is out of bounds (%d)", __FUNCTION__, camera_id, getEmulatedCameraNum()); return -ENODEV; } return mEmulatedCameras[camera_id]->connectCamera(device); } int EmulatedCameraFactory::getCameraInfo(int camera_id, struct camera_info* info) { ALOGV("%s: id = %d", __FUNCTION__, camera_id); if (!isConstructedOK()) { ALOGE("%s: EmulatedCameraFactory has failed to initialize", __FUNCTION__); return -EINVAL; } if (camera_id < 0 || camera_id >= getEmulatedCameraNum()) { ALOGE("%s: Camera id %d is out of bounds (%d)", __FUNCTION__, camera_id, getEmulatedCameraNum()); return -ENODEV; } return mEmulatedCameras[camera_id]->getCameraInfo(info); } int EmulatedCameraFactory::setCallbacks( const camera_module_callbacks_t *callbacks) { ALOGV("%s: callbacks = %p", __FUNCTION__, callbacks); mCallbacks = callbacks; return OK; } void EmulatedCameraFactory::getVendorTagOps(vendor_tag_ops_t* ops) { ALOGV("%s: ops = %p", __FUNCTION__, ops); // No vendor tags defined for emulator yet, so not touching ops } /**************************************************************************** * Camera HAL API callbacks. ***************************************************************************/ int EmulatedCameraFactory::device_open(const hw_module_t* module, const char* name, hw_device_t** device) { /* * Simply verify the parameters, and dispatch the call inside the * EmulatedCameraFactory instance. */ if (module != &HAL_MODULE_INFO_SYM.common) { ALOGE("%s: Invalid module %p expected %p", __FUNCTION__, module, &HAL_MODULE_INFO_SYM.common); return -EINVAL; } if (name == NULL) { ALOGE("%s: NULL name is not expected here", __FUNCTION__); return -EINVAL; } return gEmulatedCameraFactory.cameraDeviceOpen(atoi(name), device); } int EmulatedCameraFactory::get_number_of_cameras(void) { return gEmulatedCameraFactory.getEmulatedCameraNum(); } int EmulatedCameraFactory::get_camera_info(int camera_id, struct camera_info* info) { return gEmulatedCameraFactory.getCameraInfo(camera_id, info); } int EmulatedCameraFactory::set_callbacks( const camera_module_callbacks_t *callbacks) { return gEmulatedCameraFactory.setCallbacks(callbacks); } void EmulatedCameraFactory::get_vendor_tag_ops(vendor_tag_ops_t* ops) { gEmulatedCameraFactory.getVendorTagOps(ops); } int EmulatedCameraFactory::open_legacy(const struct hw_module_t* module, const char* id, uint32_t halVersion, struct hw_device_t** device) { // Not supporting legacy open return -ENOSYS; } /******************************************************************************** * Internal API *******************************************************************************/ /* * Camera information tokens passed in response to the "list" factory query. */ /* Device name token. */ static const char lListNameToken[] = "name="; /* Frame dimensions token. */ static const char lListDimsToken[] = "framedims="; /* Facing direction token. */ static const char lListDirToken[] = "dir="; void EmulatedCameraFactory::createQemuCameras() { /* Obtain camera list. */ char* camera_list = NULL; status_t res = mQemuClient.listCameras(&camera_list); /* Empty list, or list containing just an EOL means that there were no * connected cameras found. */ if (res != NO_ERROR || camera_list == NULL || *camera_list == '\0' || *camera_list == '\n') { if (camera_list != NULL) { free(camera_list); } return; } /* * Calculate number of connected cameras. Number of EOLs in the camera list * is the number of the connected cameras. */ int num = 0; const char* eol = strchr(camera_list, '\n'); while (eol != NULL) { num++; eol = strchr(eol + 1, '\n'); } /* Allocate the array for emulated camera instances. Note that we allocate * two more entries for back and front fake camera emulation. */ mEmulatedCameras = new EmulatedBaseCamera*[num + 2]; if (mEmulatedCameras == NULL) { ALOGE("%s: Unable to allocate emulated camera array for %d entries", __FUNCTION__, num + 1); free(camera_list); return; } memset(mEmulatedCameras, 0, sizeof(EmulatedBaseCamera*) * (num + 1)); /* * Iterate the list, creating, and initializin emulated qemu cameras for each * entry (line) in the list. */ int index = 0; char* cur_entry = camera_list; while (cur_entry != NULL && *cur_entry != '\0' && index < num) { /* Find the end of the current camera entry, and terminate it with zero * for simpler string manipulation. */ char* next_entry = strchr(cur_entry, '\n'); if (next_entry != NULL) { *next_entry = '\0'; next_entry++; // Start of the next entry. } /* Find 'name', 'framedims', and 'dir' tokens that are required here. */ char* name_start = strstr(cur_entry, lListNameToken); char* dim_start = strstr(cur_entry, lListDimsToken); char* dir_start = strstr(cur_entry, lListDirToken); if (name_start != NULL && dim_start != NULL && dir_start != NULL) { /* Advance to the token values. */ name_start += strlen(lListNameToken); dim_start += strlen(lListDimsToken); dir_start += strlen(lListDirToken); /* Terminate token values with zero. */ char* s = strchr(name_start, ' '); if (s != NULL) { *s = '\0'; } s = strchr(dim_start, ' '); if (s != NULL) { *s = '\0'; } s = strchr(dir_start, ' '); if (s != NULL) { *s = '\0'; } /* Create and initialize qemu camera. */ EmulatedQemuCamera* qemu_cam = new EmulatedQemuCamera(index, &HAL_MODULE_INFO_SYM.common); if (NULL != qemu_cam) { res = qemu_cam->Initialize(name_start, dim_start, dir_start); if (res == NO_ERROR) { mEmulatedCameras[index] = qemu_cam; index++; } else { delete qemu_cam; } } else { ALOGE("%s: Unable to instantiate EmulatedQemuCamera", __FUNCTION__); } } else { ALOGW("%s: Bad camera information: %s", __FUNCTION__, cur_entry); } cur_entry = next_entry; } mEmulatedCameraNum = index; } bool EmulatedCameraFactory::isBackFakeCameraEmulationOn() { /* Defined by 'qemu.sf.fake_camera' boot property: if property exist, and * is set to 'both', or 'back', then fake camera is used to emulate back * camera. */ char prop[PROPERTY_VALUE_MAX]; if ((property_get("qemu.sf.fake_camera", prop, NULL) > 0) && (!strcmp(prop, "both") || !strcmp(prop, "back"))) { return true; } else { return false; } } int EmulatedCameraFactory::getBackCameraHalVersion() { /* Defined by 'qemu.sf.back_camera_hal_version' boot property: if the * property doesn't exist, it is assumed to be 1. */ char prop[PROPERTY_VALUE_MAX]; if (property_get("qemu.sf.back_camera_hal", prop, NULL) > 0) { char *prop_end = prop; int val = strtol(prop, &prop_end, 10); if (*prop_end == '\0') { return val; } // Badly formatted property, should just be a number ALOGE("qemu.sf.back_camera_hal is not a number: %s", prop); } return 1; } bool EmulatedCameraFactory::isFrontFakeCameraEmulationOn() { /* Defined by 'qemu.sf.fake_camera' boot property: if property exist, and * is set to 'both', or 'front', then fake camera is used to emulate front * camera. */ char prop[PROPERTY_VALUE_MAX]; if ((property_get("qemu.sf.fake_camera", prop, NULL) > 0) && (!strcmp(prop, "both") || !strcmp(prop, "front"))) { return true; } else { return false; } } int EmulatedCameraFactory::getFrontCameraHalVersion() { /* Defined by 'qemu.sf.front_camera_hal_version' boot property: if the * property doesn't exist, it is assumed to be 1. */ char prop[PROPERTY_VALUE_MAX]; if (property_get("qemu.sf.front_camera_hal", prop, NULL) > 0) { char *prop_end = prop; int val = strtol(prop, &prop_end, 10); if (*prop_end == '\0') { return val; } // Badly formatted property, should just be a number ALOGE("qemu.sf.front_camera_hal is not a number: %s", prop); } return 1; } void EmulatedCameraFactory::onStatusChanged(int cameraId, int newStatus) { EmulatedBaseCamera *cam = mEmulatedCameras[cameraId]; if (!cam) { ALOGE("%s: Invalid camera ID %d", __FUNCTION__, cameraId); return; } /** * (Order is important) * Send the callback first to framework, THEN close the camera. */ if (newStatus == cam->getHotplugStatus()) { ALOGW("%s: Ignoring transition to the same status", __FUNCTION__); return; } const camera_module_callbacks_t* cb = mCallbacks; if (cb != NULL && cb->camera_device_status_change != NULL) { cb->camera_device_status_change(cb, cameraId, newStatus); } if (newStatus == CAMERA_DEVICE_STATUS_NOT_PRESENT) { cam->unplugCamera(); } else if (newStatus == CAMERA_DEVICE_STATUS_PRESENT) { cam->plugCamera(); } } /******************************************************************************** * Initializer for the static member structure. *******************************************************************************/ /* Entry point for camera HAL API. */ struct hw_module_methods_t EmulatedCameraFactory::mCameraModuleMethods = { open: EmulatedCameraFactory::device_open }; }; /* namespace android */ anbox-0.0~git20191115/android/camera/EmulatedCameraFactory.h000077500000000000000000000165251356361734700234630ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef HW_EMULATOR_CAMERA_EMULATED_CAMERA_FACTORY_H #define HW_EMULATOR_CAMERA_EMULATED_CAMERA_FACTORY_H #include #include "EmulatedBaseCamera.h" #include "QemuClient.h" namespace android { struct EmulatedCameraHotplugThread; /* * Contains declaration of a class EmulatedCameraFactory that manages cameras * available for the emulation. A global instance of this class is statically * instantiated and initialized when camera emulation HAL is loaded. */ /* Class EmulatedCameraFactoryManages cameras available for the emulation. * * When the global static instance of this class is created on the module load, * it enumerates cameras available for the emulation by connecting to the * emulator's 'camera' service. For every camera found out there it creates an * instance of an appropriate class, and stores it an in array of emulated * cameras. In addition to the cameras reported by the emulator, a fake camera * emulator is always created, so there is always at least one camera that is * available. * * Instance of this class is also used as the entry point for the camera HAL API, * including: * - hw_module_methods_t::open entry point * - camera_module_t::get_number_of_cameras entry point * - camera_module_t::get_camera_info entry point * */ class EmulatedCameraFactory { public: /* Constructs EmulatedCameraFactory instance. * In this constructor the factory will create and initialize a list of * emulated cameras. All errors that occur on this constructor are reported * via mConstructedOK data member of this class. */ EmulatedCameraFactory(); /* Destructs EmulatedCameraFactory instance. */ ~EmulatedCameraFactory(); /**************************************************************************** * Camera HAL API handlers. ***************************************************************************/ public: /* Opens (connects to) a camera device. * This method is called in response to hw_module_methods_t::open callback. */ int cameraDeviceOpen(int camera_id, hw_device_t** device); /* Gets emulated camera information. * This method is called in response to camera_module_t::get_camera_info callback. */ int getCameraInfo(int camera_id, struct camera_info *info); /* Sets emulated camera callbacks. * This method is called in response to camera_module_t::set_callbacks callback. */ int setCallbacks(const camera_module_callbacks_t *callbacks); /* Fill in vendor tags for the module * This method is called in response to camera_module_t::get_vendor_tag_ops callback. */ void getVendorTagOps(vendor_tag_ops_t* ops); /**************************************************************************** * Camera HAL API callbacks. ***************************************************************************/ public: /* camera_module_t::get_number_of_cameras callback entry point. */ static int get_number_of_cameras(void); /* camera_module_t::get_camera_info callback entry point. */ static int get_camera_info(int camera_id, struct camera_info *info); /* camera_module_t::set_callbacks callback entry point. */ static int set_callbacks(const camera_module_callbacks_t *callbacks); /* camera_module_t::get_vendor_tag_ops callback entry point */ static void get_vendor_tag_ops(vendor_tag_ops_t* ops); /* camera_module_t::open_legacy callback entry point */ static int open_legacy(const struct hw_module_t* module, const char* id, uint32_t halVersion, struct hw_device_t** device); private: /* hw_module_methods_t::open callback entry point. */ static int device_open(const hw_module_t* module, const char* name, hw_device_t** device); /**************************************************************************** * Public API. ***************************************************************************/ public: /* Gets fake camera orientation. */ int getFakeCameraOrientation() { /* TODO: Have a boot property that controls that. */ return 90; } /* Gets qemu camera orientation. */ int getQemuCameraOrientation() { /* TODO: Have a boot property that controls that. */ return 270; } /* Gets number of emulated cameras. */ int getEmulatedCameraNum() const { return mEmulatedCameraNum; } /* Checks whether or not the constructor has succeeded. */ bool isConstructedOK() const { return mConstructedOK; } void onStatusChanged(int cameraId, int newStatus); /**************************************************************************** * Private API ***************************************************************************/ private: /* Populates emulated cameras array with cameras that are available via * 'camera' service in the emulator. For each such camera and instance of * the EmulatedCameraQemud will be created and added to the mEmulatedCameras * array. */ void createQemuCameras(); /* Checks if fake camera emulation is on for the camera facing back. */ bool isBackFakeCameraEmulationOn(); /* Gets camera device version number to use for back camera emulation */ int getBackCameraHalVersion(); /* Checks if fake camera emulation is on for the camera facing front. */ bool isFrontFakeCameraEmulationOn(); /* Gets camera device version number to use for front camera emulation */ int getFrontCameraHalVersion(); /**************************************************************************** * Data members. ***************************************************************************/ private: /* Connection to the camera service in the emulator. */ FactoryQemuClient mQemuClient; /* Array of cameras available for the emulation. */ EmulatedBaseCamera** mEmulatedCameras; /* Number of emulated cameras (including the fake ones). */ int mEmulatedCameraNum; /* Number of emulated fake cameras. */ int mFakeCameraNum; /* Flags whether or not constructor has succeeded. */ bool mConstructedOK; /* Camera callbacks (for status changing) */ const camera_module_callbacks_t* mCallbacks; /* Hotplug thread (to call onStatusChanged) */ sp mHotplugThread; public: /* Contains device open entry point, as required by HAL API. */ static struct hw_module_methods_t mCameraModuleMethods; }; }; /* namespace android */ /* References the global EmulatedCameraFactory instance. */ extern android::EmulatedCameraFactory gEmulatedCameraFactory; #endif /* HW_EMULATOR_CAMERA_EMULATED_CAMERA_FACTORY_H */ anbox-0.0~git20191115/android/camera/EmulatedCameraHal.cpp000077500000000000000000000036071356361734700231100ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * Contains implementation of the camera HAL layer in the system running * under the emulator. * * This file contains only required HAL header, which directs all the API calls * to the EmulatedCameraFactory class implementation, wich is responsible for * managing emulated cameras. */ #include "EmulatedCameraFactory.h" /* * Required HAL header. */ camera_module_t HAL_MODULE_INFO_SYM = { common: { tag: HARDWARE_MODULE_TAG, module_api_version: CAMERA_MODULE_API_VERSION_2_3, hal_api_version: HARDWARE_HAL_API_VERSION, id: CAMERA_HARDWARE_MODULE_ID, name: "Emulated Camera Module", author: "The Android Open Source Project", methods: &android::EmulatedCameraFactory::mCameraModuleMethods, dso: NULL, reserved: {0}, }, get_number_of_cameras: android::EmulatedCameraFactory::get_number_of_cameras, get_camera_info: android::EmulatedCameraFactory::get_camera_info, set_callbacks: android::EmulatedCameraFactory::set_callbacks, get_vendor_tag_ops: android::EmulatedCameraFactory::get_vendor_tag_ops, open_legacy: android::EmulatedCameraFactory::open_legacy }; anbox-0.0~git20191115/android/camera/EmulatedCameraHotplugThread.cpp000066400000000000000000000246251356361734700251560ustar00rootroot00000000000000/* * Copyright (C) 2013 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ //#define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_HotplugThread" #include #include #include #include #include #include "EmulatedCameraHotplugThread.h" #include "EmulatedCameraFactory.h" #define FAKE_HOTPLUG_FILE "/data/misc/media/emulator.camera.hotplug" #define EVENT_SIZE (sizeof(struct inotify_event)) #define EVENT_BUF_LEN (1024*(EVENT_SIZE+16)) #define SubscriberInfo EmulatedCameraHotplugThread::SubscriberInfo namespace android { EmulatedCameraHotplugThread::EmulatedCameraHotplugThread( const int* cameraIdArray, size_t size) : Thread(/*canCallJava*/false) { mRunning = true; mInotifyFd = 0; for (size_t i = 0; i < size; ++i) { int id = cameraIdArray[i]; if (createFileIfNotExists(id)) { mSubscribedCameraIds.push_back(id); } } } EmulatedCameraHotplugThread::~EmulatedCameraHotplugThread() { } status_t EmulatedCameraHotplugThread::requestExitAndWait() { ALOGE("%s: Not implemented. Use requestExit + join instead", __FUNCTION__); return INVALID_OPERATION; } void EmulatedCameraHotplugThread::requestExit() { Mutex::Autolock al(mMutex); ALOGV("%s: Requesting thread exit", __FUNCTION__); mRunning = false; bool rmWatchFailed = false; Vector::iterator it; for (it = mSubscribers.begin(); it != mSubscribers.end(); ++it) { if (inotify_rm_watch(mInotifyFd, it->WatchID) == -1) { ALOGE("%s: Could not remove watch for camID '%d'," " error: '%s' (%d)", __FUNCTION__, it->CameraID, strerror(errno), errno); rmWatchFailed = true ; } else { ALOGV("%s: Removed watch for camID '%d'", __FUNCTION__, it->CameraID); } } if (rmWatchFailed) { // unlikely // Give the thread a fighting chance to error out on the next // read if (close(mInotifyFd) == -1) { ALOGE("%s: close failure error: '%s' (%d)", __FUNCTION__, strerror(errno), errno); } } ALOGV("%s: Request exit complete.", __FUNCTION__); } status_t EmulatedCameraHotplugThread::readyToRun() { Mutex::Autolock al(mMutex); mInotifyFd = -1; do { ALOGV("%s: Initializing inotify", __FUNCTION__); mInotifyFd = inotify_init(); if (mInotifyFd == -1) { ALOGE("%s: inotify_init failure error: '%s' (%d)", __FUNCTION__, strerror(errno), errno); mRunning = false; break; } /** * For each fake camera file, add a watch for when * the file is closed (if it was written to) */ Vector::const_iterator it, end; it = mSubscribedCameraIds.begin(); end = mSubscribedCameraIds.end(); for (; it != end; ++it) { int cameraId = *it; if (!addWatch(cameraId)) { mRunning = false; break; } } } while(false); if (!mRunning) { status_t err = -errno; if (mInotifyFd != -1) { close(mInotifyFd); } return err; } return OK; } bool EmulatedCameraHotplugThread::threadLoop() { // If requestExit was already called, mRunning will be false while (mRunning) { char buffer[EVENT_BUF_LEN]; int length = TEMP_FAILURE_RETRY( read(mInotifyFd, buffer, EVENT_BUF_LEN)); if (length < 0) { ALOGE("%s: Error reading from inotify FD, error: '%s' (%d)", __FUNCTION__, strerror(errno), errno); mRunning = false; break; } ALOGV("%s: Read %d bytes from inotify FD", __FUNCTION__, length); int i = 0; while (i < length) { inotify_event* event = (inotify_event*) &buffer[i]; if (event->mask & IN_IGNORED) { Mutex::Autolock al(mMutex); if (!mRunning) { ALOGV("%s: Shutting down thread", __FUNCTION__); break; } else { ALOGE("%s: File was deleted, aborting", __FUNCTION__); mRunning = false; break; } } else if (event->mask & IN_CLOSE_WRITE) { int cameraId = getCameraId(event->wd); if (cameraId < 0) { ALOGE("%s: Got bad camera ID from WD '%d", __FUNCTION__, event->wd); } else { // Check the file for the new hotplug event String8 filePath = getFilePath(cameraId); /** * NOTE: we carefully avoid getting an inotify * for the same exact file because it's opened for * read-only, but our inotify is for write-only */ int newStatus = readFile(filePath); if (newStatus < 0) { mRunning = false; break; } int halStatus = newStatus ? CAMERA_DEVICE_STATUS_PRESENT : CAMERA_DEVICE_STATUS_NOT_PRESENT; gEmulatedCameraFactory.onStatusChanged(cameraId, halStatus); } } else { ALOGW("%s: Unknown mask 0x%x", __FUNCTION__, event->mask); } i += EVENT_SIZE + event->len; } } if (!mRunning) { close(mInotifyFd); return false; } return true; } String8 EmulatedCameraHotplugThread::getFilePath(int cameraId) const { return String8::format(FAKE_HOTPLUG_FILE ".%d", cameraId); } bool EmulatedCameraHotplugThread::createFileIfNotExists(int cameraId) const { String8 filePath = getFilePath(cameraId); // make sure this file exists and we have access to it int fd = TEMP_FAILURE_RETRY( open(filePath.string(), O_WRONLY | O_CREAT | O_TRUNC, /* mode = ug+rwx */ S_IRWXU | S_IRWXG )); if (fd == -1) { ALOGE("%s: Could not create file '%s', error: '%s' (%d)", __FUNCTION__, filePath.string(), strerror(errno), errno); return false; } // File has '1' by default since we are plugged in by default if (TEMP_FAILURE_RETRY(write(fd, "1\n", /*count*/2)) == -1) { ALOGE("%s: Could not write '1' to file '%s', error: '%s' (%d)", __FUNCTION__, filePath.string(), strerror(errno), errno); return false; } close(fd); return true; } int EmulatedCameraHotplugThread::getCameraId(String8 filePath) const { Vector::const_iterator it, end; it = mSubscribedCameraIds.begin(); end = mSubscribedCameraIds.end(); for (; it != end; ++it) { String8 camPath = getFilePath(*it); if (camPath == filePath) { return *it; } } return NAME_NOT_FOUND; } int EmulatedCameraHotplugThread::getCameraId(int wd) const { for (size_t i = 0; i < mSubscribers.size(); ++i) { if (mSubscribers[i].WatchID == wd) { return mSubscribers[i].CameraID; } } return NAME_NOT_FOUND; } SubscriberInfo* EmulatedCameraHotplugThread::getSubscriberInfo(int cameraId) { for (size_t i = 0; i < mSubscribers.size(); ++i) { if (mSubscribers[i].CameraID == cameraId) { return (SubscriberInfo*)&mSubscribers[i]; } } return NULL; } bool EmulatedCameraHotplugThread::addWatch(int cameraId) { String8 camPath = getFilePath(cameraId); int wd = inotify_add_watch(mInotifyFd, camPath.string(), IN_CLOSE_WRITE); if (wd == -1) { ALOGE("%s: Could not add watch for '%s', error: '%s' (%d)", __FUNCTION__, camPath.string(), strerror(errno), errno); mRunning = false; return false; } ALOGV("%s: Watch added for camID='%d', wd='%d'", __FUNCTION__, cameraId, wd); SubscriberInfo si = { cameraId, wd }; mSubscribers.push_back(si); return true; } bool EmulatedCameraHotplugThread::removeWatch(int cameraId) { SubscriberInfo* si = getSubscriberInfo(cameraId); if (!si) return false; if (inotify_rm_watch(mInotifyFd, si->WatchID) == -1) { ALOGE("%s: Could not remove watch for camID '%d', error: '%s' (%d)", __FUNCTION__, cameraId, strerror(errno), errno); return false; } Vector::iterator it; for (it = mSubscribers.begin(); it != mSubscribers.end(); ++it) { if (it->CameraID == cameraId) { break; } } if (it != mSubscribers.end()) { mSubscribers.erase(it); } return true; } int EmulatedCameraHotplugThread::readFile(String8 filePath) const { int fd = TEMP_FAILURE_RETRY( open(filePath.string(), O_RDONLY, /*mode*/0)); if (fd == -1) { ALOGE("%s: Could not open file '%s', error: '%s' (%d)", __FUNCTION__, filePath.string(), strerror(errno), errno); return -1; } char buffer[1]; int length; length = TEMP_FAILURE_RETRY( read(fd, buffer, sizeof(buffer))); int retval; ALOGV("%s: Read file '%s', length='%d', buffer='%c'", __FUNCTION__, filePath.string(), length, buffer[0]); if (length == 0) { // EOF retval = 0; // empty file is the same thing as 0 } else if (buffer[0] == '0') { retval = 0; } else { // anything non-empty that's not beginning with '0' retval = 1; } close(fd); return retval; } } //namespace android anbox-0.0~git20191115/android/camera/EmulatedCameraHotplugThread.h000066400000000000000000000041561356361734700246200ustar00rootroot00000000000000/* * Copyright (C) 2013 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef HW_EMULATOR_CAMERA_EMULATED_CAMERA_HOTPLUG_H #define HW_EMULATOR_CAMERA_EMULATED_CAMERA_HOTPLUG_H /** * This class emulates hotplug events by inotifying on a file, specific * to a camera ID. When the file changes between 1/0 the hotplug * status goes between PRESENT and NOT_PRESENT. * * Refer to FAKE_HOTPLUG_FILE in EmulatedCameraHotplugThread.cpp */ #include "EmulatedCamera2.h" #include #include namespace android { class EmulatedCameraHotplugThread : public Thread { public: EmulatedCameraHotplugThread(const int* cameraIdArray, size_t size); ~EmulatedCameraHotplugThread(); virtual void requestExit(); virtual status_t requestExitAndWait(); private: virtual status_t readyToRun(); virtual bool threadLoop(); struct SubscriberInfo { int CameraID; int WatchID; }; bool addWatch(int cameraId); bool removeWatch(int cameraId); SubscriberInfo* getSubscriberInfo(int cameraId); int getCameraId(String8 filePath) const; int getCameraId(int wd) const; String8 getFilePath(int cameraId) const; int readFile(String8 filePath) const; bool createFileIfNotExists(int cameraId) const; int mInotifyFd; Vector mSubscribedCameraIds; Vector mSubscribers; // variables above are unguarded: // -- accessed in thread loop or in constructor only Mutex mMutex; bool mRunning; // guarding only when it's important }; } // namespace android #endif anbox-0.0~git20191115/android/camera/EmulatedFakeCamera.cpp000077500000000000000000000053051356361734700232470ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * Contains implementation of a class EmulatedFakeCamera that encapsulates * functionality of a fake camera. */ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_FakeCamera" #include #include #include "EmulatedFakeCamera.h" #include "EmulatedCameraFactory.h" namespace android { EmulatedFakeCamera::EmulatedFakeCamera(int cameraId, bool facingBack, struct hw_module_t* module) : EmulatedCamera(cameraId, module), mFacingBack(facingBack), mFakeCameraDevice(this) { } EmulatedFakeCamera::~EmulatedFakeCamera() { } /**************************************************************************** * Public API overrides ***************************************************************************/ status_t EmulatedFakeCamera::Initialize() { status_t res = mFakeCameraDevice.Initialize(); if (res != NO_ERROR) { return res; } const char* facing = mFacingBack ? EmulatedCamera::FACING_BACK : EmulatedCamera::FACING_FRONT; mParameters.set(EmulatedCamera::FACING_KEY, facing); ALOGD("%s: Fake camera is facing %s", __FUNCTION__, facing); mParameters.set(EmulatedCamera::ORIENTATION_KEY, gEmulatedCameraFactory.getFakeCameraOrientation()); res = EmulatedCamera::Initialize(); if (res != NO_ERROR) { return res; } /* * Parameters provided by the camera device. */ /* 352x288 and 320x240 frame dimensions are required by the framework for * video mode preview and video recording. */ mParameters.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, "640x480,352x288,320x240"); mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, "640x480,352x288,320x240"); mParameters.setPreviewSize(640, 480); mParameters.setPictureSize(640, 480); return NO_ERROR; } EmulatedCameraDevice* EmulatedFakeCamera::getCameraDevice() { return &mFakeCameraDevice; } }; /* namespace android */ anbox-0.0~git20191115/android/camera/EmulatedFakeCamera.h000077500000000000000000000050511356361734700227120ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA_H #define HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA_H /* * Contains declaration of a class EmulatedFakeCamera that encapsulates * functionality of a fake camera. This class is nothing more than a placeholder * for EmulatedFakeCameraDevice instance. */ #include "EmulatedCamera.h" #include "EmulatedFakeCameraDevice.h" namespace android { /* Encapsulates functionality of a fake camera. * This class is nothing more than a placeholder for EmulatedFakeCameraDevice * instance that emulates a fake camera device. */ class EmulatedFakeCamera : public EmulatedCamera { public: /* Constructs EmulatedFakeCamera instance. */ EmulatedFakeCamera(int cameraId, bool facingBack, struct hw_module_t* module); /* Destructs EmulatedFakeCamera instance. */ ~EmulatedFakeCamera(); /**************************************************************************** * EmulatedCamera virtual overrides. ***************************************************************************/ public: /* Initializes EmulatedFakeCamera instance. */ status_t Initialize(); /**************************************************************************** * EmulatedCamera abstract API implementation. ***************************************************************************/ protected: /* Gets emulated camera device ised by this instance of the emulated camera. */ EmulatedCameraDevice* getCameraDevice(); /**************************************************************************** * Data memebers. ***************************************************************************/ protected: /* Facing back (true) or front (false) switch. */ bool mFacingBack; /* Contained fake camera device object. */ EmulatedFakeCameraDevice mFakeCameraDevice; }; }; /* namespace android */ #endif /* HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA_H */ anbox-0.0~git20191115/android/camera/EmulatedFakeCamera2.cpp000066400000000000000000002631011356361734700233260ustar00rootroot00000000000000/* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * Contains implementation of a class EmulatedFakeCamera2 that encapsulates * functionality of an advanced fake camera. */ #include //#define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_FakeCamera2" #include #include "EmulatedFakeCamera2.h" #include "EmulatedCameraFactory.h" #include #include #include "gralloc_cb.h" #define ERROR_CAMERA_NOT_PRESENT -EPIPE #define CAMERA2_EXT_TRIGGER_TESTING_DISCONNECT 0xFFFFFFFF namespace android { const int64_t USEC = 1000LL; const int64_t MSEC = USEC * 1000LL; const int64_t SEC = MSEC * 1000LL; const uint32_t EmulatedFakeCamera2::kAvailableFormats[4] = { HAL_PIXEL_FORMAT_RAW16, HAL_PIXEL_FORMAT_BLOB, HAL_PIXEL_FORMAT_RGBA_8888, // HAL_PIXEL_FORMAT_YV12, HAL_PIXEL_FORMAT_YCrCb_420_SP }; const uint32_t EmulatedFakeCamera2::kAvailableRawSizes[2] = { 640, 480 // Sensor::kResolution[0], Sensor::kResolution[1] }; const uint64_t EmulatedFakeCamera2::kAvailableRawMinDurations[1] = { static_cast(Sensor::kFrameDurationRange[0]) }; const uint32_t EmulatedFakeCamera2::kAvailableProcessedSizesBack[4] = { 640, 480, 320, 240 // Sensor::kResolution[0], Sensor::kResolution[1] }; const uint32_t EmulatedFakeCamera2::kAvailableProcessedSizesFront[4] = { 320, 240, 160, 120 // Sensor::kResolution[0], Sensor::kResolution[1] }; const uint64_t EmulatedFakeCamera2::kAvailableProcessedMinDurations[1] = { static_cast(Sensor::kFrameDurationRange[0]) }; const uint32_t EmulatedFakeCamera2::kAvailableJpegSizesBack[2] = { 640, 480 // Sensor::kResolution[0], Sensor::kResolution[1] }; const uint32_t EmulatedFakeCamera2::kAvailableJpegSizesFront[2] = { 320, 240 // Sensor::kResolution[0], Sensor::kResolution[1] }; const uint64_t EmulatedFakeCamera2::kAvailableJpegMinDurations[1] = { static_cast(Sensor::kFrameDurationRange[0]) }; EmulatedFakeCamera2::EmulatedFakeCamera2(int cameraId, bool facingBack, struct hw_module_t* module) : EmulatedCamera2(cameraId,module), mFacingBack(facingBack), mIsConnected(false) { ALOGD("Constructing emulated fake camera 2 facing %s", facingBack ? "back" : "front"); } EmulatedFakeCamera2::~EmulatedFakeCamera2() { if (mCameraInfo != NULL) { free_camera_metadata(mCameraInfo); } } /**************************************************************************** * Public API overrides ***************************************************************************/ status_t EmulatedFakeCamera2::Initialize() { status_t res; res = constructStaticInfo(&mCameraInfo, true); if (res != OK) { ALOGE("%s: Unable to allocate static info: %s (%d)", __FUNCTION__, strerror(-res), res); return res; } res = constructStaticInfo(&mCameraInfo, false); if (res != OK) { ALOGE("%s: Unable to fill in static info: %s (%d)", __FUNCTION__, strerror(-res), res); return res; } if (res != OK) return res; mNextStreamId = 1; mNextReprocessStreamId = 1; mRawStreamCount = 0; mProcessedStreamCount = 0; mJpegStreamCount = 0; mReprocessStreamCount = 0; return NO_ERROR; } /**************************************************************************** * Camera module API overrides ***************************************************************************/ status_t EmulatedFakeCamera2::connectCamera(hw_device_t** device) { status_t res; ALOGV("%s", __FUNCTION__); { Mutex::Autolock l(mMutex); if (!mStatusPresent) { ALOGE("%s: Camera ID %d is unplugged", __FUNCTION__, mCameraID); return -ENODEV; } } mConfigureThread = new ConfigureThread(this); mReadoutThread = new ReadoutThread(this); mControlThread = new ControlThread(this); mSensor = new Sensor(); mJpegCompressor = new JpegCompressor(); mNextStreamId = 1; mNextReprocessStreamId = 1; res = mSensor->startUp(); if (res != NO_ERROR) return res; res = mConfigureThread->run("EmulatedFakeCamera2::configureThread"); if (res != NO_ERROR) return res; res = mReadoutThread->run("EmulatedFakeCamera2::readoutThread"); if (res != NO_ERROR) return res; res = mControlThread->run("EmulatedFakeCamera2::controlThread"); if (res != NO_ERROR) return res; status_t ret = EmulatedCamera2::connectCamera(device); if (ret >= 0) { mIsConnected = true; } return ret; } status_t EmulatedFakeCamera2::plugCamera() { { Mutex::Autolock l(mMutex); if (!mStatusPresent) { ALOGI("%s: Plugged back in", __FUNCTION__); mStatusPresent = true; } } return NO_ERROR; } status_t EmulatedFakeCamera2::unplugCamera() { { Mutex::Autolock l(mMutex); if (mStatusPresent) { ALOGI("%s: Unplugged camera", __FUNCTION__); mStatusPresent = false; } } return closeCamera(); } camera_device_status_t EmulatedFakeCamera2::getHotplugStatus() { Mutex::Autolock l(mMutex); return mStatusPresent ? CAMERA_DEVICE_STATUS_PRESENT : CAMERA_DEVICE_STATUS_NOT_PRESENT; } status_t EmulatedFakeCamera2::closeCamera() { { Mutex::Autolock l(mMutex); status_t res; ALOGV("%s", __FUNCTION__); if (!mIsConnected) { return NO_ERROR; } res = mSensor->shutDown(); if (res != NO_ERROR) { ALOGE("%s: Unable to shut down sensor: %d", __FUNCTION__, res); return res; } mConfigureThread->requestExit(); mReadoutThread->requestExit(); mControlThread->requestExit(); mJpegCompressor->cancel(); } // give up the lock since we will now block and the threads // can call back into this object mConfigureThread->join(); mReadoutThread->join(); mControlThread->join(); ALOGV("%s exit", __FUNCTION__); { Mutex::Autolock l(mMutex); mIsConnected = false; } return NO_ERROR; } status_t EmulatedFakeCamera2::getCameraInfo(struct camera_info *info) { info->facing = mFacingBack ? CAMERA_FACING_BACK : CAMERA_FACING_FRONT; info->orientation = gEmulatedCameraFactory.getFakeCameraOrientation(); return EmulatedCamera2::getCameraInfo(info); } /**************************************************************************** * Camera device API overrides ***************************************************************************/ /** Request input queue */ int EmulatedFakeCamera2::requestQueueNotify() { ALOGV("Request queue notification received"); ALOG_ASSERT(mRequestQueueSrc != NULL, "%s: Request queue src not set, but received queue notification!", __FUNCTION__); ALOG_ASSERT(mFrameQueueDst != NULL, "%s: Request queue src not set, but received queue notification!", __FUNCTION__); ALOG_ASSERT(mStreams.size() != 0, "%s: No streams allocated, but received queue notification!", __FUNCTION__); return mConfigureThread->newRequestAvailable(); } int EmulatedFakeCamera2::getInProgressCount() { Mutex::Autolock l(mMutex); if (!mStatusPresent) { ALOGW("%s: Camera was physically disconnected", __FUNCTION__); return ERROR_CAMERA_NOT_PRESENT; } int requestCount = 0; requestCount += mConfigureThread->getInProgressCount(); requestCount += mReadoutThread->getInProgressCount(); requestCount += mJpegCompressor->isBusy() ? 1 : 0; return requestCount; } int EmulatedFakeCamera2::constructDefaultRequest( int request_template, camera_metadata_t **request) { if (request == NULL) return BAD_VALUE; if (request_template < 0 || request_template >= CAMERA2_TEMPLATE_COUNT) { return BAD_VALUE; } { Mutex::Autolock l(mMutex); if (!mStatusPresent) { ALOGW("%s: Camera was physically disconnected", __FUNCTION__); return ERROR_CAMERA_NOT_PRESENT; } } status_t res; // Pass 1, calculate size and allocate res = constructDefaultRequest(request_template, request, true); if (res != OK) { return res; } // Pass 2, build request res = constructDefaultRequest(request_template, request, false); if (res != OK) { ALOGE("Unable to populate new request for template %d", request_template); } return res; } int EmulatedFakeCamera2::allocateStream( uint32_t width, uint32_t height, int format, const camera2_stream_ops_t *stream_ops, uint32_t *stream_id, uint32_t *format_actual, uint32_t *usage, uint32_t *max_buffers) { Mutex::Autolock l(mMutex); if (!mStatusPresent) { ALOGW("%s: Camera was physically disconnected", __FUNCTION__); return ERROR_CAMERA_NOT_PRESENT; } // Temporary shim until FORMAT_ZSL is removed if (format == CAMERA2_HAL_PIXEL_FORMAT_ZSL) { format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED; } if (format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) { unsigned int numFormats = sizeof(kAvailableFormats) / sizeof(uint32_t); unsigned int formatIdx = 0; unsigned int sizeOffsetIdx = 0; for (; formatIdx < numFormats; formatIdx++) { if (format == (int)kAvailableFormats[formatIdx]) break; } if (formatIdx == numFormats) { ALOGE("%s: Format 0x%x is not supported", __FUNCTION__, format); return BAD_VALUE; } } const uint32_t *availableSizes; size_t availableSizeCount; switch (format) { case HAL_PIXEL_FORMAT_RAW16: availableSizes = kAvailableRawSizes; availableSizeCount = sizeof(kAvailableRawSizes)/sizeof(uint32_t); break; case HAL_PIXEL_FORMAT_BLOB: availableSizes = mFacingBack ? kAvailableJpegSizesBack : kAvailableJpegSizesFront; availableSizeCount = mFacingBack ? sizeof(kAvailableJpegSizesBack)/sizeof(uint32_t) : sizeof(kAvailableJpegSizesFront)/sizeof(uint32_t); break; case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED: case HAL_PIXEL_FORMAT_RGBA_8888: case HAL_PIXEL_FORMAT_YV12: case HAL_PIXEL_FORMAT_YCrCb_420_SP: availableSizes = mFacingBack ? kAvailableProcessedSizesBack : kAvailableProcessedSizesFront; availableSizeCount = mFacingBack ? sizeof(kAvailableProcessedSizesBack)/sizeof(uint32_t) : sizeof(kAvailableProcessedSizesFront)/sizeof(uint32_t); break; default: ALOGE("%s: Unknown format 0x%x", __FUNCTION__, format); return BAD_VALUE; } unsigned int resIdx = 0; for (; resIdx < availableSizeCount; resIdx++) { if (availableSizes[resIdx * 2] == width && availableSizes[resIdx * 2 + 1] == height) break; } if (resIdx == availableSizeCount) { ALOGE("%s: Format 0x%x does not support resolution %d, %d", __FUNCTION__, format, width, height); return BAD_VALUE; } switch (format) { case HAL_PIXEL_FORMAT_RAW16: if (mRawStreamCount >= kMaxRawStreamCount) { ALOGE("%s: Cannot allocate another raw stream (%d already allocated)", __FUNCTION__, mRawStreamCount); return INVALID_OPERATION; } mRawStreamCount++; break; case HAL_PIXEL_FORMAT_BLOB: if (mJpegStreamCount >= kMaxJpegStreamCount) { ALOGE("%s: Cannot allocate another JPEG stream (%d already allocated)", __FUNCTION__, mJpegStreamCount); return INVALID_OPERATION; } mJpegStreamCount++; break; default: if (mProcessedStreamCount >= kMaxProcessedStreamCount) { ALOGE("%s: Cannot allocate another processed stream (%d already allocated)", __FUNCTION__, mProcessedStreamCount); return INVALID_OPERATION; } mProcessedStreamCount++; } Stream newStream; newStream.ops = stream_ops; newStream.width = width; newStream.height = height; newStream.format = format; // TODO: Query stride from gralloc newStream.stride = width; mStreams.add(mNextStreamId, newStream); *stream_id = mNextStreamId; if (format_actual) *format_actual = format; *usage = GRALLOC_USAGE_HW_CAMERA_WRITE; *max_buffers = kMaxBufferCount; ALOGV("Stream allocated: %d, %d x %d, 0x%x. U: %x, B: %d", *stream_id, width, height, format, *usage, *max_buffers); mNextStreamId++; return NO_ERROR; } int EmulatedFakeCamera2::registerStreamBuffers( uint32_t stream_id, int num_buffers, buffer_handle_t *buffers) { Mutex::Autolock l(mMutex); if (!mStatusPresent) { ALOGW("%s: Camera was physically disconnected", __FUNCTION__); return ERROR_CAMERA_NOT_PRESENT; } ALOGV("%s: Stream %d registering %d buffers", __FUNCTION__, stream_id, num_buffers); // Need to find out what the final concrete pixel format for our stream is // Assumes that all buffers have the same format. if (num_buffers < 1) { ALOGE("%s: Stream %d only has %d buffers!", __FUNCTION__, stream_id, num_buffers); return BAD_VALUE; } const cb_handle_t *streamBuffer = reinterpret_cast(buffers[0]); int finalFormat = streamBuffer->format; if (finalFormat == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) { ALOGE("%s: Stream %d: Bad final pixel format " "HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED; " "concrete pixel format required!", __FUNCTION__, stream_id); return BAD_VALUE; } ssize_t streamIndex = mStreams.indexOfKey(stream_id); if (streamIndex < 0) { ALOGE("%s: Unknown stream id %d!", __FUNCTION__, stream_id); return BAD_VALUE; } Stream &stream = mStreams.editValueAt(streamIndex); ALOGV("%s: Stream %d format set to %x, previously %x", __FUNCTION__, stream_id, finalFormat, stream.format); stream.format = finalFormat; return NO_ERROR; } int EmulatedFakeCamera2::releaseStream(uint32_t stream_id) { Mutex::Autolock l(mMutex); ssize_t streamIndex = mStreams.indexOfKey(stream_id); if (streamIndex < 0) { ALOGE("%s: Unknown stream id %d!", __FUNCTION__, stream_id); return BAD_VALUE; } if (isStreamInUse(stream_id)) { ALOGE("%s: Cannot release stream %d; in use!", __FUNCTION__, stream_id); return BAD_VALUE; } switch(mStreams.valueAt(streamIndex).format) { case HAL_PIXEL_FORMAT_RAW16: mRawStreamCount--; break; case HAL_PIXEL_FORMAT_BLOB: mJpegStreamCount--; break; default: mProcessedStreamCount--; break; } mStreams.removeItemsAt(streamIndex); return NO_ERROR; } int EmulatedFakeCamera2::allocateReprocessStreamFromStream( uint32_t output_stream_id, const camera2_stream_in_ops_t *stream_ops, uint32_t *stream_id) { Mutex::Autolock l(mMutex); if (!mStatusPresent) { ALOGW("%s: Camera was physically disconnected", __FUNCTION__); return ERROR_CAMERA_NOT_PRESENT; } ssize_t baseStreamIndex = mStreams.indexOfKey(output_stream_id); if (baseStreamIndex < 0) { ALOGE("%s: Unknown output stream id %d!", __FUNCTION__, output_stream_id); return BAD_VALUE; } const Stream &baseStream = mStreams[baseStreamIndex]; // We'll reprocess anything we produced if (mReprocessStreamCount >= kMaxReprocessStreamCount) { ALOGE("%s: Cannot allocate another reprocess stream (%d already allocated)", __FUNCTION__, mReprocessStreamCount); return INVALID_OPERATION; } mReprocessStreamCount++; ReprocessStream newStream; newStream.ops = stream_ops; newStream.width = baseStream.width; newStream.height = baseStream.height; newStream.format = baseStream.format; newStream.stride = baseStream.stride; newStream.sourceStreamId = output_stream_id; *stream_id = mNextReprocessStreamId; mReprocessStreams.add(mNextReprocessStreamId, newStream); ALOGV("Reprocess stream allocated: %d: %d, %d, 0x%x. Parent stream: %d", *stream_id, newStream.width, newStream.height, newStream.format, output_stream_id); mNextReprocessStreamId++; return NO_ERROR; } int EmulatedFakeCamera2::releaseReprocessStream(uint32_t stream_id) { Mutex::Autolock l(mMutex); ssize_t streamIndex = mReprocessStreams.indexOfKey(stream_id); if (streamIndex < 0) { ALOGE("%s: Unknown reprocess stream id %d!", __FUNCTION__, stream_id); return BAD_VALUE; } if (isReprocessStreamInUse(stream_id)) { ALOGE("%s: Cannot release reprocessing stream %d; in use!", __FUNCTION__, stream_id); return BAD_VALUE; } mReprocessStreamCount--; mReprocessStreams.removeItemsAt(streamIndex); return NO_ERROR; } int EmulatedFakeCamera2::triggerAction(uint32_t trigger_id, int32_t ext1, int32_t ext2) { Mutex::Autolock l(mMutex); if (trigger_id == CAMERA2_EXT_TRIGGER_TESTING_DISCONNECT) { ALOGI("%s: Disconnect trigger - camera must be closed", __FUNCTION__); mStatusPresent = false; gEmulatedCameraFactory.onStatusChanged( mCameraID, CAMERA_DEVICE_STATUS_NOT_PRESENT); } if (!mStatusPresent) { ALOGW("%s: Camera was physically disconnected", __FUNCTION__); return ERROR_CAMERA_NOT_PRESENT; } return mControlThread->triggerAction(trigger_id, ext1, ext2); } /** Shutdown and debug methods */ int EmulatedFakeCamera2::dump(int fd) { String8 result; result.appendFormat(" Camera HAL device: EmulatedFakeCamera2\n"); result.appendFormat(" Streams:\n"); for (size_t i = 0; i < mStreams.size(); i++) { int id = mStreams.keyAt(i); const Stream& s = mStreams.valueAt(i); result.appendFormat( " Stream %d: %d x %d, format 0x%x, stride %d\n", id, s.width, s.height, s.format, s.stride); } write(fd, result.string(), result.size()); return NO_ERROR; } void EmulatedFakeCamera2::signalError() { // TODO: Let parent know so we can shut down cleanly ALOGE("Worker thread is signaling a serious error"); } /** Pipeline control worker thread methods */ EmulatedFakeCamera2::ConfigureThread::ConfigureThread(EmulatedFakeCamera2 *parent): Thread(false), mParent(parent), mRequestCount(0), mNextBuffers(NULL) { mRunning = false; } EmulatedFakeCamera2::ConfigureThread::~ConfigureThread() { } status_t EmulatedFakeCamera2::ConfigureThread::readyToRun() { Mutex::Autolock lock(mInputMutex); ALOGV("Starting up ConfigureThread"); mRequest = NULL; mActive = false; mRunning = true; mInputSignal.signal(); return NO_ERROR; } status_t EmulatedFakeCamera2::ConfigureThread::waitUntilRunning() { Mutex::Autolock lock(mInputMutex); if (!mRunning) { ALOGV("Waiting for configure thread to start"); mInputSignal.wait(mInputMutex); } return OK; } status_t EmulatedFakeCamera2::ConfigureThread::newRequestAvailable() { waitUntilRunning(); Mutex::Autolock lock(mInputMutex); mActive = true; mInputSignal.signal(); return OK; } bool EmulatedFakeCamera2::ConfigureThread::isStreamInUse(uint32_t id) { Mutex::Autolock lock(mInternalsMutex); if (mNextBuffers == NULL) return false; for (size_t i=0; i < mNextBuffers->size(); i++) { if ((*mNextBuffers)[i].streamId == (int)id) return true; } return false; } int EmulatedFakeCamera2::ConfigureThread::getInProgressCount() { Mutex::Autolock lock(mInputMutex); return mRequestCount; } bool EmulatedFakeCamera2::ConfigureThread::threadLoop() { status_t res; // Check if we're currently processing or just waiting { Mutex::Autolock lock(mInputMutex); if (!mActive) { // Inactive, keep waiting until we've been signaled status_t res; res = mInputSignal.waitRelative(mInputMutex, kWaitPerLoop); if (res != NO_ERROR && res != TIMED_OUT) { ALOGE("%s: Error waiting for input requests: %d", __FUNCTION__, res); return false; } if (!mActive) return true; ALOGV("New request available"); } // Active } if (mRequest == NULL) { Mutex::Autolock il(mInternalsMutex); ALOGV("Configure: Getting next request"); res = mParent->mRequestQueueSrc->dequeue_request( mParent->mRequestQueueSrc, &mRequest); if (res != NO_ERROR) { ALOGE("%s: Error dequeuing next request: %d", __FUNCTION__, res); mParent->signalError(); return false; } if (mRequest == NULL) { ALOGV("Configure: Request queue empty, going inactive"); // No requests available, go into inactive mode Mutex::Autolock lock(mInputMutex); mActive = false; return true; } else { Mutex::Autolock lock(mInputMutex); mRequestCount++; } camera_metadata_entry_t type; res = find_camera_metadata_entry(mRequest, ANDROID_REQUEST_TYPE, &type); if (res != NO_ERROR) { ALOGE("%s: error reading request type", __FUNCTION__); mParent->signalError(); return false; } bool success = false;; switch (type.data.u8[0]) { case ANDROID_REQUEST_TYPE_CAPTURE: success = setupCapture(); break; case ANDROID_REQUEST_TYPE_REPROCESS: success = setupReprocess(); break; default: ALOGE("%s: Unexpected request type %d", __FUNCTION__, type.data.u8[0]); mParent->signalError(); break; } if (!success) return false; } if (mWaitingForReadout) { bool readoutDone; readoutDone = mParent->mReadoutThread->waitForReady(kWaitPerLoop); if (!readoutDone) return true; if (mNextNeedsJpeg) { ALOGV("Configure: Waiting for JPEG compressor"); } else { ALOGV("Configure: Waiting for sensor"); } mWaitingForReadout = false; } if (mNextNeedsJpeg) { bool jpegDone; jpegDone = mParent->mJpegCompressor->waitForDone(kWaitPerLoop); if (!jpegDone) return true; ALOGV("Configure: Waiting for sensor"); mNextNeedsJpeg = false; } if (mNextIsCapture) { return configureNextCapture(); } else { return configureNextReprocess(); } } bool EmulatedFakeCamera2::ConfigureThread::setupCapture() { status_t res; mNextIsCapture = true; // Get necessary parameters for sensor config mParent->mControlThread->processRequest(mRequest); camera_metadata_entry_t streams; res = find_camera_metadata_entry(mRequest, ANDROID_REQUEST_OUTPUT_STREAMS, &streams); if (res != NO_ERROR) { ALOGE("%s: error reading output stream tag", __FUNCTION__); mParent->signalError(); return false; } mNextBuffers = new Buffers; mNextNeedsJpeg = false; ALOGV("Configure: Setting up buffers for capture"); for (size_t i = 0; i < streams.count; i++) { int streamId = streams.data.i32[i]; const Stream &s = mParent->getStreamInfo(streamId); if (s.format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) { ALOGE("%s: Stream %d does not have a concrete pixel format, but " "is included in a request!", __FUNCTION__, streamId); mParent->signalError(); return false; } StreamBuffer b; b.streamId = streams.data.u8[i]; b.width = s.width; b.height = s.height; b.format = s.format; b.stride = s.stride; mNextBuffers->push_back(b); ALOGV("Configure: Buffer %zu: Stream %d, %d x %d, format 0x%x, " "stride %d", i, b.streamId, b.width, b.height, b.format, b.stride); if (b.format == HAL_PIXEL_FORMAT_BLOB) { mNextNeedsJpeg = true; } } camera_metadata_entry_t e; res = find_camera_metadata_entry(mRequest, ANDROID_REQUEST_FRAME_COUNT, &e); if (res != NO_ERROR) { ALOGE("%s: error reading frame count tag: %s (%d)", __FUNCTION__, strerror(-res), res); mParent->signalError(); return false; } mNextFrameNumber = *e.data.i32; res = find_camera_metadata_entry(mRequest, ANDROID_SENSOR_EXPOSURE_TIME, &e); if (res != NO_ERROR) { ALOGE("%s: error reading exposure time tag: %s (%d)", __FUNCTION__, strerror(-res), res); mParent->signalError(); return false; } mNextExposureTime = *e.data.i64; res = find_camera_metadata_entry(mRequest, ANDROID_SENSOR_FRAME_DURATION, &e); if (res != NO_ERROR) { ALOGE("%s: error reading frame duration tag", __FUNCTION__); mParent->signalError(); return false; } mNextFrameDuration = *e.data.i64; if (mNextFrameDuration < mNextExposureTime + Sensor::kMinVerticalBlank) { mNextFrameDuration = mNextExposureTime + Sensor::kMinVerticalBlank; } res = find_camera_metadata_entry(mRequest, ANDROID_SENSOR_SENSITIVITY, &e); if (res != NO_ERROR) { ALOGE("%s: error reading sensitivity tag", __FUNCTION__); mParent->signalError(); return false; } mNextSensitivity = *e.data.i32; // Start waiting on readout thread mWaitingForReadout = true; ALOGV("Configure: Waiting for readout thread"); return true; } bool EmulatedFakeCamera2::ConfigureThread::configureNextCapture() { bool vsync = mParent->mSensor->waitForVSync(kWaitPerLoop); if (!vsync) return true; Mutex::Autolock il(mInternalsMutex); ALOGV("Configure: Configuring sensor for capture %d", mNextFrameNumber); mParent->mSensor->setExposureTime(mNextExposureTime); mParent->mSensor->setFrameDuration(mNextFrameDuration); mParent->mSensor->setSensitivity(mNextSensitivity); getBuffers(); ALOGV("Configure: Done configure for capture %d", mNextFrameNumber); mParent->mReadoutThread->setNextOperation(true, mRequest, mNextBuffers); mParent->mSensor->setDestinationBuffers(mNextBuffers); mRequest = NULL; mNextBuffers = NULL; Mutex::Autolock lock(mInputMutex); mRequestCount--; return true; } bool EmulatedFakeCamera2::ConfigureThread::setupReprocess() { status_t res; mNextNeedsJpeg = true; mNextIsCapture = false; camera_metadata_entry_t reprocessStreams; res = find_camera_metadata_entry(mRequest, ANDROID_REQUEST_INPUT_STREAMS, &reprocessStreams); if (res != NO_ERROR) { ALOGE("%s: error reading output stream tag", __FUNCTION__); mParent->signalError(); return false; } mNextBuffers = new Buffers; ALOGV("Configure: Setting up input buffers for reprocess"); for (size_t i = 0; i < reprocessStreams.count; i++) { int streamId = reprocessStreams.data.i32[i]; const ReprocessStream &s = mParent->getReprocessStreamInfo(streamId); if (s.format != HAL_PIXEL_FORMAT_RGB_888) { ALOGE("%s: Only ZSL reprocessing supported!", __FUNCTION__); mParent->signalError(); return false; } StreamBuffer b; b.streamId = -streamId; b.width = s.width; b.height = s.height; b.format = s.format; b.stride = s.stride; mNextBuffers->push_back(b); } camera_metadata_entry_t streams; res = find_camera_metadata_entry(mRequest, ANDROID_REQUEST_OUTPUT_STREAMS, &streams); if (res != NO_ERROR) { ALOGE("%s: error reading output stream tag", __FUNCTION__); mParent->signalError(); return false; } ALOGV("Configure: Setting up output buffers for reprocess"); for (size_t i = 0; i < streams.count; i++) { int streamId = streams.data.i32[i]; const Stream &s = mParent->getStreamInfo(streamId); if (s.format != HAL_PIXEL_FORMAT_BLOB) { // TODO: Support reprocess to YUV ALOGE("%s: Non-JPEG output stream %d for reprocess not supported", __FUNCTION__, streamId); mParent->signalError(); return false; } StreamBuffer b; b.streamId = streams.data.u8[i]; b.width = s.width; b.height = s.height; b.format = s.format; b.stride = s.stride; mNextBuffers->push_back(b); ALOGV("Configure: Buffer %zu: Stream %d, %d x %d, format 0x%x, " "stride %d", i, b.streamId, b.width, b.height, b.format, b.stride); } camera_metadata_entry_t e; res = find_camera_metadata_entry(mRequest, ANDROID_REQUEST_FRAME_COUNT, &e); if (res != NO_ERROR) { ALOGE("%s: error reading frame count tag: %s (%d)", __FUNCTION__, strerror(-res), res); mParent->signalError(); return false; } mNextFrameNumber = *e.data.i32; return true; } bool EmulatedFakeCamera2::ConfigureThread::configureNextReprocess() { Mutex::Autolock il(mInternalsMutex); getBuffers(); ALOGV("Configure: Done configure for reprocess %d", mNextFrameNumber); mParent->mReadoutThread->setNextOperation(false, mRequest, mNextBuffers); mRequest = NULL; mNextBuffers = NULL; Mutex::Autolock lock(mInputMutex); mRequestCount--; return true; } bool EmulatedFakeCamera2::ConfigureThread::getBuffers() { status_t res; /** Get buffers to fill for this frame */ for (size_t i = 0; i < mNextBuffers->size(); i++) { StreamBuffer &b = mNextBuffers->editItemAt(i); if (b.streamId > 0) { Stream s = mParent->getStreamInfo(b.streamId); ALOGV("Configure: Dequeing buffer from stream %d", b.streamId); res = s.ops->dequeue_buffer(s.ops, &(b.buffer) ); if (res != NO_ERROR || b.buffer == NULL) { ALOGE("%s: Unable to dequeue buffer from stream %d: %s (%d)", __FUNCTION__, b.streamId, strerror(-res), res); mParent->signalError(); return false; } /* Lock the buffer from the perspective of the graphics mapper */ const Rect rect(s.width, s.height); res = GraphicBufferMapper::get().lock(*(b.buffer), GRALLOC_USAGE_HW_CAMERA_WRITE, rect, (void**)&(b.img) ); if (res != NO_ERROR) { ALOGE("%s: grbuffer_mapper.lock failure: %s (%d)", __FUNCTION__, strerror(-res), res); s.ops->cancel_buffer(s.ops, b.buffer); mParent->signalError(); return false; } } else { ReprocessStream s = mParent->getReprocessStreamInfo(-b.streamId); ALOGV("Configure: Acquiring buffer from reprocess stream %d", -b.streamId); res = s.ops->acquire_buffer(s.ops, &(b.buffer) ); if (res != NO_ERROR || b.buffer == NULL) { ALOGE("%s: Unable to acquire buffer from reprocess stream %d: " "%s (%d)", __FUNCTION__, -b.streamId, strerror(-res), res); mParent->signalError(); return false; } /* Lock the buffer from the perspective of the graphics mapper */ const Rect rect(s.width, s.height); res = GraphicBufferMapper::get().lock(*(b.buffer), GRALLOC_USAGE_HW_CAMERA_READ, rect, (void**)&(b.img) ); if (res != NO_ERROR) { ALOGE("%s: grbuffer_mapper.lock failure: %s (%d)", __FUNCTION__, strerror(-res), res); s.ops->release_buffer(s.ops, b.buffer); mParent->signalError(); return false; } } } return true; } EmulatedFakeCamera2::ReadoutThread::ReadoutThread(EmulatedFakeCamera2 *parent): Thread(false), mParent(parent), mRunning(false), mActive(false), mRequestCount(0), mRequest(NULL), mBuffers(NULL) { mInFlightQueue = new InFlightQueue[kInFlightQueueSize]; mInFlightHead = 0; mInFlightTail = 0; } EmulatedFakeCamera2::ReadoutThread::~ReadoutThread() { delete mInFlightQueue; } status_t EmulatedFakeCamera2::ReadoutThread::readyToRun() { Mutex::Autolock lock(mInputMutex); ALOGV("Starting up ReadoutThread"); mRunning = true; mInputSignal.signal(); return NO_ERROR; } status_t EmulatedFakeCamera2::ReadoutThread::waitUntilRunning() { Mutex::Autolock lock(mInputMutex); if (!mRunning) { ALOGV("Waiting for readout thread to start"); mInputSignal.wait(mInputMutex); } return OK; } bool EmulatedFakeCamera2::ReadoutThread::waitForReady(nsecs_t timeout) { status_t res; Mutex::Autolock lock(mInputMutex); while (!readyForNextCapture()) { res = mReadySignal.waitRelative(mInputMutex, timeout); if (res == TIMED_OUT) return false; if (res != OK) { ALOGE("%s: Error waiting for ready: %s (%d)", __FUNCTION__, strerror(-res), res); return false; } } return true; } bool EmulatedFakeCamera2::ReadoutThread::readyForNextCapture() { return (mInFlightTail + 1) % kInFlightQueueSize != mInFlightHead; } void EmulatedFakeCamera2::ReadoutThread::setNextOperation( bool isCapture, camera_metadata_t *request, Buffers *buffers) { Mutex::Autolock lock(mInputMutex); if ( !readyForNextCapture() ) { ALOGE("In flight queue full, dropping captures"); mParent->signalError(); return; } mInFlightQueue[mInFlightTail].isCapture = isCapture; mInFlightQueue[mInFlightTail].request = request; mInFlightQueue[mInFlightTail].buffers = buffers; mInFlightTail = (mInFlightTail + 1) % kInFlightQueueSize; mRequestCount++; if (!mActive) { mActive = true; mInputSignal.signal(); } } bool EmulatedFakeCamera2::ReadoutThread::isStreamInUse(uint32_t id) { // acquire in same order as threadLoop Mutex::Autolock iLock(mInternalsMutex); Mutex::Autolock lock(mInputMutex); size_t i = mInFlightHead; while (i != mInFlightTail) { for (size_t j = 0; j < mInFlightQueue[i].buffers->size(); j++) { if ( (*(mInFlightQueue[i].buffers))[j].streamId == (int)id ) return true; } i = (i + 1) % kInFlightQueueSize; } if (mBuffers != NULL) { for (i = 0; i < mBuffers->size(); i++) { if ( (*mBuffers)[i].streamId == (int)id) return true; } } return false; } int EmulatedFakeCamera2::ReadoutThread::getInProgressCount() { Mutex::Autolock lock(mInputMutex); return mRequestCount; } bool EmulatedFakeCamera2::ReadoutThread::threadLoop() { static const nsecs_t kWaitPerLoop = 10000000L; // 10 ms status_t res; int32_t frameNumber; // Check if we're currently processing or just waiting { Mutex::Autolock lock(mInputMutex); if (!mActive) { // Inactive, keep waiting until we've been signaled res = mInputSignal.waitRelative(mInputMutex, kWaitPerLoop); if (res != NO_ERROR && res != TIMED_OUT) { ALOGE("%s: Error waiting for capture requests: %d", __FUNCTION__, res); mParent->signalError(); return false; } if (!mActive) return true; } // Active, see if we need a new request if (mRequest == NULL) { if (mInFlightHead == mInFlightTail) { // Go inactive ALOGV("Waiting for sensor data"); mActive = false; return true; } else { Mutex::Autolock iLock(mInternalsMutex); mReadySignal.signal(); mIsCapture = mInFlightQueue[mInFlightHead].isCapture; mRequest = mInFlightQueue[mInFlightHead].request; mBuffers = mInFlightQueue[mInFlightHead].buffers; mInFlightQueue[mInFlightHead].request = NULL; mInFlightQueue[mInFlightHead].buffers = NULL; mInFlightHead = (mInFlightHead + 1) % kInFlightQueueSize; ALOGV("Ready to read out request %p, %zu buffers", mRequest, mBuffers->size()); } } } // Active with request, wait on sensor to complete nsecs_t captureTime; if (mIsCapture) { bool gotFrame; gotFrame = mParent->mSensor->waitForNewFrame(kWaitPerLoop, &captureTime); if (!gotFrame) return true; } Mutex::Autolock iLock(mInternalsMutex); camera_metadata_entry_t entry; if (!mIsCapture) { res = find_camera_metadata_entry(mRequest, ANDROID_SENSOR_TIMESTAMP, &entry); if (res != NO_ERROR) { ALOGE("%s: error reading reprocessing timestamp: %s (%d)", __FUNCTION__, strerror(-res), res); mParent->signalError(); return false; } captureTime = entry.data.i64[0]; } res = find_camera_metadata_entry(mRequest, ANDROID_REQUEST_FRAME_COUNT, &entry); if (res != NO_ERROR) { ALOGE("%s: error reading frame count tag: %s (%d)", __FUNCTION__, strerror(-res), res); mParent->signalError(); return false; } frameNumber = *entry.data.i32; res = find_camera_metadata_entry(mRequest, ANDROID_REQUEST_METADATA_MODE, &entry); if (res != NO_ERROR) { ALOGE("%s: error reading metadata mode tag: %s (%d)", __FUNCTION__, strerror(-res), res); mParent->signalError(); return false; } // Got sensor data and request, construct frame and send it out ALOGV("Readout: Constructing metadata and frames for request %d", frameNumber); if (*entry.data.u8 == ANDROID_REQUEST_METADATA_MODE_FULL) { ALOGV("Readout: Metadata requested, constructing"); camera_metadata_t *frame = NULL; size_t frame_entries = get_camera_metadata_entry_count(mRequest); size_t frame_data = get_camera_metadata_data_count(mRequest); // TODO: Dynamically calculate based on enabled statistics, etc frame_entries += 10; frame_data += 100; res = mParent->mFrameQueueDst->dequeue_frame(mParent->mFrameQueueDst, frame_entries, frame_data, &frame); if (res != NO_ERROR || frame == NULL) { ALOGE("%s: Unable to dequeue frame metadata buffer", __FUNCTION__); mParent->signalError(); return false; } res = append_camera_metadata(frame, mRequest); if (res != NO_ERROR) { ALOGE("Unable to append request metadata"); } if (mIsCapture) { add_camera_metadata_entry(frame, ANDROID_SENSOR_TIMESTAMP, &captureTime, 1); collectStatisticsMetadata(frame); // TODO: Collect all final values used from sensor in addition to timestamp } ALOGV("Readout: Enqueue frame %d", frameNumber); mParent->mFrameQueueDst->enqueue_frame(mParent->mFrameQueueDst, frame); } ALOGV("Readout: Free request"); res = mParent->mRequestQueueSrc->free_request(mParent->mRequestQueueSrc, mRequest); if (res != NO_ERROR) { ALOGE("%s: Unable to return request buffer to queue: %d", __FUNCTION__, res); mParent->signalError(); return false; } mRequest = NULL; int compressedBufferIndex = -1; ALOGV("Readout: Processing %zu buffers", mBuffers->size()); for (size_t i = 0; i < mBuffers->size(); i++) { const StreamBuffer &b = (*mBuffers)[i]; ALOGV("Readout: Buffer %zu: Stream %d, %d x %d, format 0x%x, stride %d", i, b.streamId, b.width, b.height, b.format, b.stride); if (b.streamId > 0) { if (b.format == HAL_PIXEL_FORMAT_BLOB) { // Assumes only one BLOB buffer type per capture compressedBufferIndex = i; } else { ALOGV("Readout: Sending image buffer %zu (%p) to output stream %d", i, (void*)*(b.buffer), b.streamId); GraphicBufferMapper::get().unlock(*(b.buffer)); const Stream &s = mParent->getStreamInfo(b.streamId); res = s.ops->enqueue_buffer(s.ops, captureTime, b.buffer); if (res != OK) { ALOGE("Error enqueuing image buffer %p: %s (%d)", b.buffer, strerror(-res), res); mParent->signalError(); } } } } if (compressedBufferIndex == -1) { delete mBuffers; } else { ALOGV("Readout: Starting JPEG compression for buffer %d, stream %d", compressedBufferIndex, (*mBuffers)[compressedBufferIndex].streamId); mJpegTimestamp = captureTime; // Takes ownership of mBuffers mParent->mJpegCompressor->start(mBuffers, this); } mBuffers = NULL; Mutex::Autolock l(mInputMutex); mRequestCount--; ALOGV("Readout: Done with request %d", frameNumber); return true; } void EmulatedFakeCamera2::ReadoutThread::onJpegDone( const StreamBuffer &jpegBuffer, bool success) { status_t res; if (!success) { ALOGE("%s: Error queueing compressed image buffer %p", __FUNCTION__, jpegBuffer.buffer); mParent->signalError(); return; } // Write to JPEG output stream ALOGV("%s: Compression complete, pushing to stream %d", __FUNCTION__, jpegBuffer.streamId); GraphicBufferMapper::get().unlock(*(jpegBuffer.buffer)); const Stream &s = mParent->getStreamInfo(jpegBuffer.streamId); res = s.ops->enqueue_buffer(s.ops, mJpegTimestamp, jpegBuffer.buffer); } void EmulatedFakeCamera2::ReadoutThread::onJpegInputDone( const StreamBuffer &inputBuffer) { status_t res; GraphicBufferMapper::get().unlock(*(inputBuffer.buffer)); const ReprocessStream &s = mParent->getReprocessStreamInfo(-inputBuffer.streamId); res = s.ops->release_buffer(s.ops, inputBuffer.buffer); if (res != OK) { ALOGE("Error releasing reprocess buffer %p: %s (%d)", inputBuffer.buffer, strerror(-res), res); mParent->signalError(); } } status_t EmulatedFakeCamera2::ReadoutThread::collectStatisticsMetadata( camera_metadata_t *frame) { // Completely fake face rectangles, don't correspond to real faces in scene ALOGV("Readout: Collecting statistics metadata"); status_t res; camera_metadata_entry_t entry; res = find_camera_metadata_entry(frame, ANDROID_STATISTICS_FACE_DETECT_MODE, &entry); if (res != OK) { ALOGE("%s: Unable to find face detect mode!", __FUNCTION__); return BAD_VALUE; } if (entry.data.u8[0] == ANDROID_STATISTICS_FACE_DETECT_MODE_OFF) return OK; // The coordinate system for the face regions is the raw sensor pixel // coordinates. Here, we map from the scene coordinates (0-19 in both axis) // to raw pixels, for the scene defined in fake-pipeline2/Scene.cpp. We // approximately place two faces on top of the windows of the house. No // actual faces exist there, but might one day. Note that this doesn't // account for the offsets used to account for aspect ratio differences, so // the rectangles don't line up quite right. const size_t numFaces = 2; int32_t rects[numFaces * 4] = { static_cast(Sensor::kResolution[0] * 10 / 20), static_cast(Sensor::kResolution[1] * 15 / 20), static_cast(Sensor::kResolution[0] * 12 / 20), static_cast(Sensor::kResolution[1] * 17 / 20), static_cast(Sensor::kResolution[0] * 16 / 20), static_cast(Sensor::kResolution[1] * 15 / 20), static_cast(Sensor::kResolution[0] * 18 / 20), static_cast(Sensor::kResolution[1] * 17 / 20) }; // To simulate some kind of real detection going on, we jitter the rectangles on // each frame by a few pixels in each dimension. for (size_t i = 0; i < numFaces * 4; i++) { rects[i] += (int32_t)(((float)rand() / RAND_MAX) * 6 - 3); } // The confidence scores (0-100) are similarly jittered. uint8_t scores[numFaces] = { 85, 95 }; for (size_t i = 0; i < numFaces; i++) { scores[i] += (int32_t)(((float)rand() / RAND_MAX) * 10 - 5); } res = add_camera_metadata_entry(frame, ANDROID_STATISTICS_FACE_RECTANGLES, rects, numFaces * 4); if (res != OK) { ALOGE("%s: Unable to add face rectangles!", __FUNCTION__); return BAD_VALUE; } res = add_camera_metadata_entry(frame, ANDROID_STATISTICS_FACE_SCORES, scores, numFaces); if (res != OK) { ALOGE("%s: Unable to add face scores!", __FUNCTION__); return BAD_VALUE; } if (entry.data.u8[0] == ANDROID_STATISTICS_FACE_DETECT_MODE_SIMPLE) return OK; // Advanced face detection options - add eye/mouth coordinates. The // coordinates in order are (leftEyeX, leftEyeY, rightEyeX, rightEyeY, // mouthX, mouthY). The mapping is the same as the face rectangles. int32_t features[numFaces * 6] = { static_cast(Sensor::kResolution[0] * 10.5 / 20), static_cast(Sensor::kResolution[1] * 16 / 20), static_cast(Sensor::kResolution[0] * 11.5 / 20), static_cast(Sensor::kResolution[1] * 16 / 20), static_cast(Sensor::kResolution[0] * 11 / 20), static_cast(Sensor::kResolution[1] * 16.5 / 20), static_cast(Sensor::kResolution[0] * 16.5 / 20), static_cast(Sensor::kResolution[1] * 16 / 20), static_cast(Sensor::kResolution[0] * 17.5 / 20), static_cast(Sensor::kResolution[1] * 16 / 20), static_cast(Sensor::kResolution[0] * 17 / 20), static_cast(Sensor::kResolution[1] * 16.5 / 20), }; // Jitter these a bit less than the rects for (size_t i = 0; i < numFaces * 6; i++) { features[i] += (int32_t)(((float)rand() / RAND_MAX) * 4 - 2); } // These are unique IDs that are used to identify each face while it's // visible to the detector (if a face went away and came back, it'd get a // new ID). int32_t ids[numFaces] = { 100, 200 }; res = add_camera_metadata_entry(frame, ANDROID_STATISTICS_FACE_LANDMARKS, features, numFaces * 6); if (res != OK) { ALOGE("%s: Unable to add face landmarks!", __FUNCTION__); return BAD_VALUE; } res = add_camera_metadata_entry(frame, ANDROID_STATISTICS_FACE_IDS, ids, numFaces); if (res != OK) { ALOGE("%s: Unable to add face scores!", __FUNCTION__); return BAD_VALUE; } return OK; } EmulatedFakeCamera2::ControlThread::ControlThread(EmulatedFakeCamera2 *parent): Thread(false), mParent(parent) { mRunning = false; } EmulatedFakeCamera2::ControlThread::~ControlThread() { } status_t EmulatedFakeCamera2::ControlThread::readyToRun() { Mutex::Autolock lock(mInputMutex); ALOGV("Starting up ControlThread"); mRunning = true; mStartAf = false; mCancelAf = false; mStartPrecapture = false; mControlMode = ANDROID_CONTROL_MODE_AUTO; mEffectMode = ANDROID_CONTROL_EFFECT_MODE_OFF; mSceneMode = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY; mAfMode = ANDROID_CONTROL_AF_MODE_AUTO; mAfModeChange = false; mAeMode = ANDROID_CONTROL_AE_MODE_ON; mAwbMode = ANDROID_CONTROL_AWB_MODE_AUTO; mAfTriggerId = 0; mPrecaptureTriggerId = 0; mAfState = ANDROID_CONTROL_AF_STATE_INACTIVE; mAeState = ANDROID_CONTROL_AE_STATE_INACTIVE; mAwbState = ANDROID_CONTROL_AWB_STATE_INACTIVE; mExposureTime = kNormalExposureTime; mInputSignal.signal(); return NO_ERROR; } status_t EmulatedFakeCamera2::ControlThread::waitUntilRunning() { Mutex::Autolock lock(mInputMutex); if (!mRunning) { ALOGV("Waiting for control thread to start"); mInputSignal.wait(mInputMutex); } return OK; } // Override android.control.* fields with 3A values before sending request to sensor status_t EmulatedFakeCamera2::ControlThread::processRequest(camera_metadata_t *request) { Mutex::Autolock lock(mInputMutex); // TODO: Add handling for all android.control.* fields here camera_metadata_entry_t mode; status_t res; #define READ_IF_OK(res, what, def) \ (((res) == OK) ? (what) : (uint8_t)(def)) res = find_camera_metadata_entry(request, ANDROID_CONTROL_MODE, &mode); mControlMode = READ_IF_OK(res, mode.data.u8[0], ANDROID_CONTROL_MODE_OFF); // disable all 3A if (mControlMode == ANDROID_CONTROL_MODE_OFF) { mEffectMode = ANDROID_CONTROL_EFFECT_MODE_OFF; mSceneMode = ANDROID_CONTROL_SCENE_MODE_DISABLED; mAfMode = ANDROID_CONTROL_AF_MODE_OFF; mAeLock = ANDROID_CONTROL_AE_LOCK_ON; mAeMode = ANDROID_CONTROL_AE_MODE_OFF; mAfModeChange = true; mStartAf = false; mCancelAf = true; mAeState = ANDROID_CONTROL_AE_STATE_INACTIVE; mAwbMode = ANDROID_CONTROL_AWB_MODE_OFF; return res; } res = find_camera_metadata_entry(request, ANDROID_CONTROL_EFFECT_MODE, &mode); mEffectMode = READ_IF_OK(res, mode.data.u8[0], ANDROID_CONTROL_EFFECT_MODE_OFF); res = find_camera_metadata_entry(request, ANDROID_CONTROL_SCENE_MODE, &mode); mSceneMode = READ_IF_OK(res, mode.data.u8[0], ANDROID_CONTROL_SCENE_MODE_DISABLED); res = find_camera_metadata_entry(request, ANDROID_CONTROL_AF_MODE, &mode); if (mAfMode != mode.data.u8[0]) { ALOGV("AF new mode: %d, old mode %d", mode.data.u8[0], mAfMode); mAfMode = mode.data.u8[0]; mAfModeChange = true; mStartAf = false; mCancelAf = false; } res = find_camera_metadata_entry(request, ANDROID_CONTROL_AE_MODE, &mode); mAeMode = READ_IF_OK(res, mode.data.u8[0], ANDROID_CONTROL_AE_MODE_OFF); res = find_camera_metadata_entry(request, ANDROID_CONTROL_AE_LOCK, &mode); uint8_t aeLockVal = READ_IF_OK(res, mode.data.u8[0], ANDROID_CONTROL_AE_LOCK_ON); bool aeLock = (aeLockVal == ANDROID_CONTROL_AE_LOCK_ON); if (mAeLock && !aeLock) { mAeState = ANDROID_CONTROL_AE_STATE_INACTIVE; } mAeLock = aeLock; res = find_camera_metadata_entry(request, ANDROID_CONTROL_AWB_MODE, &mode); mAwbMode = READ_IF_OK(res, mode.data.u8[0], ANDROID_CONTROL_AWB_MODE_OFF); // TODO: Override more control fields if (mAeMode != ANDROID_CONTROL_AE_MODE_OFF) { camera_metadata_entry_t exposureTime; res = find_camera_metadata_entry(request, ANDROID_SENSOR_EXPOSURE_TIME, &exposureTime); if (res == OK) { exposureTime.data.i64[0] = mExposureTime; } } #undef READ_IF_OK return OK; } status_t EmulatedFakeCamera2::ControlThread::triggerAction(uint32_t msgType, int32_t ext1, int32_t ext2) { ALOGV("%s: Triggering %d (%d, %d)", __FUNCTION__, msgType, ext1, ext2); Mutex::Autolock lock(mInputMutex); switch (msgType) { case CAMERA2_TRIGGER_AUTOFOCUS: mAfTriggerId = ext1; mStartAf = true; mCancelAf = false; break; case CAMERA2_TRIGGER_CANCEL_AUTOFOCUS: mAfTriggerId = ext1; mStartAf = false; mCancelAf = true; break; case CAMERA2_TRIGGER_PRECAPTURE_METERING: mPrecaptureTriggerId = ext1; mStartPrecapture = true; break; default: ALOGE("%s: Unknown action triggered: %d (arguments %d %d)", __FUNCTION__, msgType, ext1, ext2); return BAD_VALUE; } return OK; } const nsecs_t EmulatedFakeCamera2::ControlThread::kControlCycleDelay = 100 * MSEC; const nsecs_t EmulatedFakeCamera2::ControlThread::kMinAfDuration = 500 * MSEC; const nsecs_t EmulatedFakeCamera2::ControlThread::kMaxAfDuration = 900 * MSEC; const float EmulatedFakeCamera2::ControlThread::kAfSuccessRate = 0.9; // Once every 5 seconds const float EmulatedFakeCamera2::ControlThread::kContinuousAfStartRate = kControlCycleDelay / 5.0 * SEC; const nsecs_t EmulatedFakeCamera2::ControlThread::kMinAeDuration = 500 * MSEC; const nsecs_t EmulatedFakeCamera2::ControlThread::kMaxAeDuration = 2 * SEC; const nsecs_t EmulatedFakeCamera2::ControlThread::kMinPrecaptureAeDuration = 100 * MSEC; const nsecs_t EmulatedFakeCamera2::ControlThread::kMaxPrecaptureAeDuration = 400 * MSEC; // Once every 3 seconds const float EmulatedFakeCamera2::ControlThread::kAeScanStartRate = kControlCycleDelay / 3000000000.0; const nsecs_t EmulatedFakeCamera2::ControlThread::kNormalExposureTime = 10 * MSEC; const nsecs_t EmulatedFakeCamera2::ControlThread::kExposureJump = 2 * MSEC; const nsecs_t EmulatedFakeCamera2::ControlThread::kMinExposureTime = 1 * MSEC; bool EmulatedFakeCamera2::ControlThread::threadLoop() { bool afModeChange = false; bool afTriggered = false; bool afCancelled = false; uint8_t afState; uint8_t afMode; int32_t afTriggerId; bool precaptureTriggered = false; uint8_t aeState; uint8_t aeMode; bool aeLock; int32_t precaptureTriggerId; nsecs_t nextSleep = kControlCycleDelay; { Mutex::Autolock lock(mInputMutex); if (mStartAf) { ALOGD("Starting AF trigger processing"); afTriggered = true; mStartAf = false; } else if (mCancelAf) { ALOGD("Starting cancel AF trigger processing"); afCancelled = true; mCancelAf = false; } afState = mAfState; afMode = mAfMode; afModeChange = mAfModeChange; mAfModeChange = false; afTriggerId = mAfTriggerId; if(mStartPrecapture) { ALOGD("Starting precapture trigger processing"); precaptureTriggered = true; mStartPrecapture = false; } aeState = mAeState; aeMode = mAeMode; aeLock = mAeLock; precaptureTriggerId = mPrecaptureTriggerId; } if (afCancelled || afModeChange) { ALOGV("Resetting AF state due to cancel/mode change"); afState = ANDROID_CONTROL_AF_STATE_INACTIVE; updateAfState(afState, afTriggerId); mAfScanDuration = 0; mLockAfterPassiveScan = false; } uint8_t oldAfState = afState; if (afTriggered) { afState = processAfTrigger(afMode, afState); } afState = maybeStartAfScan(afMode, afState); afState = updateAfScan(afMode, afState, &nextSleep); updateAfState(afState, afTriggerId); if (precaptureTriggered) { aeState = processPrecaptureTrigger(aeMode, aeState); } aeState = maybeStartAeScan(aeMode, aeLock, aeState); aeState = updateAeScan(aeMode, aeLock, aeState, &nextSleep); updateAeState(aeState, precaptureTriggerId); int ret; timespec t; t.tv_sec = 0; t.tv_nsec = nextSleep; do { ret = nanosleep(&t, &t); } while (ret != 0); if (mAfScanDuration > 0) { mAfScanDuration -= nextSleep; } if (mAeScanDuration > 0) { mAeScanDuration -= nextSleep; } return true; } int EmulatedFakeCamera2::ControlThread::processAfTrigger(uint8_t afMode, uint8_t afState) { switch (afMode) { case ANDROID_CONTROL_AF_MODE_OFF: case ANDROID_CONTROL_AF_MODE_EDOF: // Do nothing break; case ANDROID_CONTROL_AF_MODE_MACRO: case ANDROID_CONTROL_AF_MODE_AUTO: switch (afState) { case ANDROID_CONTROL_AF_STATE_INACTIVE: case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED: case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: // Start new focusing cycle mAfScanDuration = ((double)rand() / RAND_MAX) * (kMaxAfDuration - kMinAfDuration) + kMinAfDuration; afState = ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN; ALOGV("%s: AF scan start, duration %" PRId64 " ms", __FUNCTION__, mAfScanDuration / 1000000); break; case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN: // Ignore new request, already scanning break; default: ALOGE("Unexpected AF state in AUTO/MACRO AF mode: %d", afState); } break; case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: switch (afState) { // Picture mode waits for passive scan to complete case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN: mLockAfterPassiveScan = true; break; case ANDROID_CONTROL_AF_STATE_INACTIVE: afState = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED; break; case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED: afState = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED; break; case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED: case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: // Must cancel to get out of these states break; default: ALOGE("Unexpected AF state in CONTINUOUS_PICTURE AF mode: %d", afState); } break; case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: switch (afState) { // Video mode does not wait for passive scan to complete case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN: case ANDROID_CONTROL_AF_STATE_INACTIVE: afState = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED; break; case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED: afState = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED; break; case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED: case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: // Must cancel to get out of these states break; default: ALOGE("Unexpected AF state in CONTINUOUS_VIDEO AF mode: %d", afState); } break; default: break; } return afState; } int EmulatedFakeCamera2::ControlThread::maybeStartAfScan(uint8_t afMode, uint8_t afState) { if ((afMode == ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO || afMode == ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE) && (afState == ANDROID_CONTROL_AF_STATE_INACTIVE || afState == ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED)) { bool startScan = ((double)rand() / RAND_MAX) < kContinuousAfStartRate; if (startScan) { // Start new passive focusing cycle mAfScanDuration = ((double)rand() / RAND_MAX) * (kMaxAfDuration - kMinAfDuration) + kMinAfDuration; afState = ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN; ALOGV("%s: AF passive scan start, duration %" PRId64 " ms", __FUNCTION__, mAfScanDuration / 1000000); } } return afState; } int EmulatedFakeCamera2::ControlThread::updateAfScan(uint8_t afMode, uint8_t afState, nsecs_t *maxSleep) { if (! (afState == ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN || afState == ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN ) ) { return afState; } if (mAfScanDuration <= 0) { ALOGV("%s: AF scan done", __FUNCTION__); switch (afMode) { case ANDROID_CONTROL_AF_MODE_MACRO: case ANDROID_CONTROL_AF_MODE_AUTO: { bool success = ((double)rand() / RAND_MAX) < kAfSuccessRate; if (success) { afState = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED; } else { afState = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED; } break; } case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: if (mLockAfterPassiveScan) { afState = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED; mLockAfterPassiveScan = false; } else { afState = ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED; } break; case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: afState = ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED; break; default: ALOGE("Unexpected AF mode in scan state"); } } else { if (mAfScanDuration <= *maxSleep) { *maxSleep = mAfScanDuration; } } return afState; } void EmulatedFakeCamera2::ControlThread::updateAfState(uint8_t newState, int32_t triggerId) { Mutex::Autolock lock(mInputMutex); if (mAfState != newState) { ALOGV("%s: Autofocus state now %d, id %d", __FUNCTION__, newState, triggerId); mAfState = newState; mParent->sendNotification(CAMERA2_MSG_AUTOFOCUS, newState, triggerId, 0); } } int EmulatedFakeCamera2::ControlThread::processPrecaptureTrigger(uint8_t aeMode, uint8_t aeState) { switch (aeMode) { case ANDROID_CONTROL_AE_MODE_OFF: // Don't do anything for these return aeState; case ANDROID_CONTROL_AE_MODE_ON: case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH: case ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH: case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE: // Trigger a precapture cycle aeState = ANDROID_CONTROL_AE_STATE_PRECAPTURE; mAeScanDuration = ((double)rand() / RAND_MAX) * (kMaxPrecaptureAeDuration - kMinPrecaptureAeDuration) + kMinPrecaptureAeDuration; ALOGD("%s: AE precapture scan start, duration %" PRId64 " ms", __FUNCTION__, mAeScanDuration / 1000000); } return aeState; } int EmulatedFakeCamera2::ControlThread::maybeStartAeScan(uint8_t aeMode, bool aeLocked, uint8_t aeState) { if (aeLocked) return aeState; switch (aeMode) { case ANDROID_CONTROL_AE_MODE_OFF: break; case ANDROID_CONTROL_AE_MODE_ON: case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH: case ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH: case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE: { if (aeState != ANDROID_CONTROL_AE_STATE_INACTIVE && aeState != ANDROID_CONTROL_AE_STATE_CONVERGED) break; bool startScan = ((double)rand() / RAND_MAX) < kAeScanStartRate; if (startScan) { mAeScanDuration = ((double)rand() / RAND_MAX) * (kMaxAeDuration - kMinAeDuration) + kMinAeDuration; aeState = ANDROID_CONTROL_AE_STATE_SEARCHING; ALOGV("%s: AE scan start, duration %" PRId64 " ms", __FUNCTION__, mAeScanDuration / 1000000); } } } return aeState; } int EmulatedFakeCamera2::ControlThread::updateAeScan(uint8_t aeMode, bool aeLock, uint8_t aeState, nsecs_t *maxSleep) { if (aeLock && aeState != ANDROID_CONTROL_AE_STATE_PRECAPTURE) { mAeScanDuration = 0; aeState = ANDROID_CONTROL_AE_STATE_LOCKED; } else if ((aeState == ANDROID_CONTROL_AE_STATE_SEARCHING) || (aeState == ANDROID_CONTROL_AE_STATE_PRECAPTURE ) ) { if (mAeScanDuration <= 0) { ALOGV("%s: AE scan done", __FUNCTION__); aeState = aeLock ? ANDROID_CONTROL_AE_STATE_LOCKED :ANDROID_CONTROL_AE_STATE_CONVERGED; Mutex::Autolock lock(mInputMutex); mExposureTime = kNormalExposureTime; } else { if (mAeScanDuration <= *maxSleep) { *maxSleep = mAeScanDuration; } int64_t exposureDelta = ((double)rand() / RAND_MAX) * 2 * kExposureJump - kExposureJump; Mutex::Autolock lock(mInputMutex); mExposureTime = mExposureTime + exposureDelta; if (mExposureTime < kMinExposureTime) mExposureTime = kMinExposureTime; } } return aeState; } void EmulatedFakeCamera2::ControlThread::updateAeState(uint8_t newState, int32_t triggerId) { Mutex::Autolock lock(mInputMutex); if (mAeState != newState) { ALOGV("%s: Autoexposure state now %d, id %d", __FUNCTION__, newState, triggerId); mAeState = newState; mParent->sendNotification(CAMERA2_MSG_AUTOEXPOSURE, newState, triggerId, 0); } } /** Private methods */ status_t EmulatedFakeCamera2::constructStaticInfo( camera_metadata_t **info, bool sizeRequest) const { size_t entryCount = 0; size_t dataCount = 0; status_t ret; #define ADD_OR_SIZE( tag, data, count ) \ if ( ( ret = addOrSize(*info, sizeRequest, &entryCount, &dataCount, \ tag, data, count) ) != OK ) return ret // android.lens // 5 cm min focus distance for back camera, infinity (fixed focus) for front const float minFocusDistance = mFacingBack ? 1.0/0.05 : 0.0; ADD_OR_SIZE(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, &minFocusDistance, 1); // 5 m hyperfocal distance for back camera, infinity (fixed focus) for front const float hyperFocalDistance = mFacingBack ? 1.0/5.0 : 0.0; ADD_OR_SIZE(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE, &minFocusDistance, 1); static const float focalLength = 3.30f; // mm ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, &focalLength, 1); static const float aperture = 2.8f; ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_APERTURES, &aperture, 1); static const float filterDensity = 0; ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES, &filterDensity, 1); static const uint8_t availableOpticalStabilization = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF; ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION, &availableOpticalStabilization, 1); static const int32_t lensShadingMapSize[] = {1, 1}; ADD_OR_SIZE(ANDROID_LENS_INFO_SHADING_MAP_SIZE, lensShadingMapSize, sizeof(lensShadingMapSize)/sizeof(int32_t)); int32_t lensFacing = mFacingBack ? ANDROID_LENS_FACING_BACK : ANDROID_LENS_FACING_FRONT; ADD_OR_SIZE(ANDROID_LENS_FACING, &lensFacing, 1); // android.sensor ADD_OR_SIZE(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE, Sensor::kExposureTimeRange, 2); ADD_OR_SIZE(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION, &Sensor::kFrameDurationRange[1], 1); ADD_OR_SIZE(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE, Sensor::kSensitivityRange, sizeof(Sensor::kSensitivityRange) /sizeof(int32_t)); ADD_OR_SIZE(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, &Sensor::kColorFilterArrangement, 1); static const float sensorPhysicalSize[2] = {3.20f, 2.40f}; // mm ADD_OR_SIZE(ANDROID_SENSOR_INFO_PHYSICAL_SIZE, sensorPhysicalSize, 2); ADD_OR_SIZE(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE, Sensor::kResolution, 2); ADD_OR_SIZE(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE, Sensor::kResolution, 2); ADD_OR_SIZE(ANDROID_SENSOR_INFO_WHITE_LEVEL, &Sensor::kMaxRawValue, 1); static const int32_t blackLevelPattern[4] = { static_cast(Sensor::kBlackLevel), static_cast(Sensor::kBlackLevel), static_cast(Sensor::kBlackLevel), static_cast(Sensor::kBlackLevel) }; ADD_OR_SIZE(ANDROID_SENSOR_BLACK_LEVEL_PATTERN, blackLevelPattern, sizeof(blackLevelPattern)/sizeof(int32_t)); //TODO: sensor color calibration fields // android.flash static const uint8_t flashAvailable = 0; ADD_OR_SIZE(ANDROID_FLASH_INFO_AVAILABLE, &flashAvailable, 1); static const int64_t flashChargeDuration = 0; ADD_OR_SIZE(ANDROID_FLASH_INFO_CHARGE_DURATION, &flashChargeDuration, 1); // android.tonemap static const int32_t tonemapCurvePoints = 128; ADD_OR_SIZE(ANDROID_TONEMAP_MAX_CURVE_POINTS, &tonemapCurvePoints, 1); // android.scaler ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_FORMATS, kAvailableFormats, sizeof(kAvailableFormats)/sizeof(uint32_t)); ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_RAW_SIZES, kAvailableRawSizes, sizeof(kAvailableRawSizes)/sizeof(uint32_t)); ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS, kAvailableRawMinDurations, sizeof(kAvailableRawMinDurations)/sizeof(uint64_t)); if (mFacingBack) { ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, kAvailableProcessedSizesBack, sizeof(kAvailableProcessedSizesBack)/sizeof(uint32_t)); } else { ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, kAvailableProcessedSizesFront, sizeof(kAvailableProcessedSizesFront)/sizeof(uint32_t)); } ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS, kAvailableProcessedMinDurations, sizeof(kAvailableProcessedMinDurations)/sizeof(uint64_t)); if (mFacingBack) { ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, kAvailableJpegSizesBack, sizeof(kAvailableJpegSizesBack)/sizeof(uint32_t)); } else { ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, kAvailableJpegSizesFront, sizeof(kAvailableJpegSizesFront)/sizeof(uint32_t)); } ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS, kAvailableJpegMinDurations, sizeof(kAvailableJpegMinDurations)/sizeof(uint64_t)); static const float maxZoom = 10; ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM, &maxZoom, 1); // android.jpeg static const int32_t jpegThumbnailSizes[] = { 0, 0, 160, 120, 320, 240 }; ADD_OR_SIZE(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, jpegThumbnailSizes, sizeof(jpegThumbnailSizes)/sizeof(int32_t)); static const int32_t jpegMaxSize = JpegCompressor::kMaxJpegSize; ADD_OR_SIZE(ANDROID_JPEG_MAX_SIZE, &jpegMaxSize, 1); // android.stats static const uint8_t availableFaceDetectModes[] = { ANDROID_STATISTICS_FACE_DETECT_MODE_OFF, ANDROID_STATISTICS_FACE_DETECT_MODE_SIMPLE, ANDROID_STATISTICS_FACE_DETECT_MODE_FULL }; ADD_OR_SIZE(ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES, availableFaceDetectModes, sizeof(availableFaceDetectModes)); static const int32_t maxFaceCount = 8; ADD_OR_SIZE(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT, &maxFaceCount, 1); static const int32_t histogramSize = 64; ADD_OR_SIZE(ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT, &histogramSize, 1); static const int32_t maxHistogramCount = 1000; ADD_OR_SIZE(ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT, &maxHistogramCount, 1); static const int32_t sharpnessMapSize[2] = {64, 64}; ADD_OR_SIZE(ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE, sharpnessMapSize, sizeof(sharpnessMapSize)/sizeof(int32_t)); static const int32_t maxSharpnessMapValue = 1000; ADD_OR_SIZE(ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE, &maxSharpnessMapValue, 1); // android.control static const uint8_t availableSceneModes[] = { ANDROID_CONTROL_SCENE_MODE_DISABLED }; ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_SCENE_MODES, availableSceneModes, sizeof(availableSceneModes)); static const uint8_t availableEffects[] = { ANDROID_CONTROL_EFFECT_MODE_OFF }; ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_EFFECTS, availableEffects, sizeof(availableEffects)); static const int32_t max3aRegions[] = {/*AE*/ 0,/*AWB*/ 0,/*AF*/ 0}; ADD_OR_SIZE(ANDROID_CONTROL_MAX_REGIONS, max3aRegions, sizeof(max3aRegions)/sizeof(max3aRegions[0])); static const uint8_t availableAeModes[] = { ANDROID_CONTROL_AE_MODE_OFF, ANDROID_CONTROL_AE_MODE_ON }; ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_MODES, availableAeModes, sizeof(availableAeModes)); static const camera_metadata_rational exposureCompensationStep = { 1, 3 }; ADD_OR_SIZE(ANDROID_CONTROL_AE_COMPENSATION_STEP, &exposureCompensationStep, 1); int32_t exposureCompensationRange[] = {-9, 9}; ADD_OR_SIZE(ANDROID_CONTROL_AE_COMPENSATION_RANGE, exposureCompensationRange, sizeof(exposureCompensationRange)/sizeof(int32_t)); static const int32_t availableTargetFpsRanges[] = { 5, 30, 15, 30 }; ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, availableTargetFpsRanges, sizeof(availableTargetFpsRanges)/sizeof(int32_t)); static const uint8_t availableAntibandingModes[] = { ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF, ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO }; ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES, availableAntibandingModes, sizeof(availableAntibandingModes)); static const uint8_t availableAwbModes[] = { ANDROID_CONTROL_AWB_MODE_OFF, ANDROID_CONTROL_AWB_MODE_AUTO, ANDROID_CONTROL_AWB_MODE_INCANDESCENT, ANDROID_CONTROL_AWB_MODE_FLUORESCENT, ANDROID_CONTROL_AWB_MODE_DAYLIGHT, ANDROID_CONTROL_AWB_MODE_SHADE }; ADD_OR_SIZE(ANDROID_CONTROL_AWB_AVAILABLE_MODES, availableAwbModes, sizeof(availableAwbModes)); static const uint8_t availableAfModesBack[] = { ANDROID_CONTROL_AF_MODE_OFF, ANDROID_CONTROL_AF_MODE_AUTO, ANDROID_CONTROL_AF_MODE_MACRO, ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO, ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE }; static const uint8_t availableAfModesFront[] = { ANDROID_CONTROL_AF_MODE_OFF }; if (mFacingBack) { ADD_OR_SIZE(ANDROID_CONTROL_AF_AVAILABLE_MODES, availableAfModesBack, sizeof(availableAfModesBack)); } else { ADD_OR_SIZE(ANDROID_CONTROL_AF_AVAILABLE_MODES, availableAfModesFront, sizeof(availableAfModesFront)); } static const uint8_t availableVstabModes[] = { ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF }; ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES, availableVstabModes, sizeof(availableVstabModes)); #undef ADD_OR_SIZE /** Allocate metadata if sizing */ if (sizeRequest) { ALOGV("Allocating %zu entries, %zu extra bytes for " "static camera info", entryCount, dataCount); *info = allocate_camera_metadata(entryCount, dataCount); if (*info == NULL) { ALOGE("Unable to allocate camera static info" "(%zu entries, %zu bytes extra data)", entryCount, dataCount); return NO_MEMORY; } } return OK; } status_t EmulatedFakeCamera2::constructDefaultRequest( int request_template, camera_metadata_t **request, bool sizeRequest) const { size_t entryCount = 0; size_t dataCount = 0; status_t ret; #define ADD_OR_SIZE( tag, data, count ) \ if ( ( ret = addOrSize(*request, sizeRequest, &entryCount, &dataCount, \ tag, data, count) ) != OK ) return ret /** android.request */ static const uint8_t requestType = ANDROID_REQUEST_TYPE_CAPTURE; ADD_OR_SIZE(ANDROID_REQUEST_TYPE, &requestType, 1); static const uint8_t metadataMode = ANDROID_REQUEST_METADATA_MODE_FULL; ADD_OR_SIZE(ANDROID_REQUEST_METADATA_MODE, &metadataMode, 1); static const int32_t id = 0; ADD_OR_SIZE(ANDROID_REQUEST_ID, &id, 1); static const int32_t frameCount = 0; ADD_OR_SIZE(ANDROID_REQUEST_FRAME_COUNT, &frameCount, 1); // OUTPUT_STREAMS set by user entryCount += 1; dataCount += 5; // TODO: Should be maximum stream number /** android.lens */ static const float focusDistance = 0; ADD_OR_SIZE(ANDROID_LENS_FOCUS_DISTANCE, &focusDistance, 1); static const float aperture = 2.8f; ADD_OR_SIZE(ANDROID_LENS_APERTURE, &aperture, 1); static const float focalLength = 5.0f; ADD_OR_SIZE(ANDROID_LENS_FOCAL_LENGTH, &focalLength, 1); static const float filterDensity = 0; ADD_OR_SIZE(ANDROID_LENS_FILTER_DENSITY, &filterDensity, 1); static const uint8_t opticalStabilizationMode = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF; ADD_OR_SIZE(ANDROID_LENS_OPTICAL_STABILIZATION_MODE, &opticalStabilizationMode, 1); // FOCUS_RANGE set only in frame /** android.sensor */ static const int64_t exposureTime = 10 * MSEC; ADD_OR_SIZE(ANDROID_SENSOR_EXPOSURE_TIME, &exposureTime, 1); static const int64_t frameDuration = 33333333L; // 1/30 s ADD_OR_SIZE(ANDROID_SENSOR_FRAME_DURATION, &frameDuration, 1); static const int32_t sensitivity = 100; ADD_OR_SIZE(ANDROID_SENSOR_SENSITIVITY, &sensitivity, 1); // TIMESTAMP set only in frame /** android.flash */ static const uint8_t flashMode = ANDROID_FLASH_MODE_OFF; ADD_OR_SIZE(ANDROID_FLASH_MODE, &flashMode, 1); static const uint8_t flashPower = 10; ADD_OR_SIZE(ANDROID_FLASH_FIRING_POWER, &flashPower, 1); static const int64_t firingTime = 0; ADD_OR_SIZE(ANDROID_FLASH_FIRING_TIME, &firingTime, 1); /** Processing block modes */ uint8_t hotPixelMode = 0; uint8_t demosaicMode = 0; uint8_t noiseMode = 0; uint8_t shadingMode = 0; uint8_t colorMode = 0; uint8_t tonemapMode = 0; uint8_t edgeMode = 0; switch (request_template) { case CAMERA2_TEMPLATE_STILL_CAPTURE: // fall-through case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT: // fall-through case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG: hotPixelMode = ANDROID_HOT_PIXEL_MODE_HIGH_QUALITY; demosaicMode = ANDROID_DEMOSAIC_MODE_HIGH_QUALITY; noiseMode = ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY; shadingMode = ANDROID_SHADING_MODE_HIGH_QUALITY; colorMode = ANDROID_COLOR_CORRECTION_MODE_HIGH_QUALITY; tonemapMode = ANDROID_TONEMAP_MODE_HIGH_QUALITY; edgeMode = ANDROID_EDGE_MODE_HIGH_QUALITY; break; case CAMERA2_TEMPLATE_PREVIEW: // fall-through case CAMERA2_TEMPLATE_VIDEO_RECORD: // fall-through default: hotPixelMode = ANDROID_HOT_PIXEL_MODE_FAST; demosaicMode = ANDROID_DEMOSAIC_MODE_FAST; noiseMode = ANDROID_NOISE_REDUCTION_MODE_FAST; shadingMode = ANDROID_SHADING_MODE_FAST; colorMode = ANDROID_COLOR_CORRECTION_MODE_FAST; tonemapMode = ANDROID_TONEMAP_MODE_FAST; edgeMode = ANDROID_EDGE_MODE_FAST; break; } ADD_OR_SIZE(ANDROID_HOT_PIXEL_MODE, &hotPixelMode, 1); ADD_OR_SIZE(ANDROID_DEMOSAIC_MODE, &demosaicMode, 1); ADD_OR_SIZE(ANDROID_NOISE_REDUCTION_MODE, &noiseMode, 1); ADD_OR_SIZE(ANDROID_SHADING_MODE, &shadingMode, 1); ADD_OR_SIZE(ANDROID_COLOR_CORRECTION_MODE, &colorMode, 1); ADD_OR_SIZE(ANDROID_TONEMAP_MODE, &tonemapMode, 1); ADD_OR_SIZE(ANDROID_EDGE_MODE, &edgeMode, 1); /** android.noise */ static const uint8_t noiseStrength = 5; ADD_OR_SIZE(ANDROID_NOISE_REDUCTION_STRENGTH, &noiseStrength, 1); /** android.color */ static const float colorTransform[9] = { 1.0f, 0.f, 0.f, 0.f, 1.f, 0.f, 0.f, 0.f, 1.f }; ADD_OR_SIZE(ANDROID_COLOR_CORRECTION_TRANSFORM, colorTransform, 9); /** android.tonemap */ static const float tonemapCurve[4] = { 0.f, 0.f, 1.f, 1.f }; ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_RED, tonemapCurve, 4); ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_GREEN, tonemapCurve, 4); ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_BLUE, tonemapCurve, 4); /** android.edge */ static const uint8_t edgeStrength = 5; ADD_OR_SIZE(ANDROID_EDGE_STRENGTH, &edgeStrength, 1); /** android.scaler */ static const int32_t cropRegion[3] = { 0, 0, static_cast(Sensor::kResolution[0]) }; ADD_OR_SIZE(ANDROID_SCALER_CROP_REGION, cropRegion, 3); /** android.jpeg */ static const int32_t jpegQuality = 80; ADD_OR_SIZE(ANDROID_JPEG_QUALITY, &jpegQuality, 1); static const int32_t thumbnailSize[2] = { 640, 480 }; ADD_OR_SIZE(ANDROID_JPEG_THUMBNAIL_SIZE, thumbnailSize, 2); static const int32_t thumbnailQuality = 80; ADD_OR_SIZE(ANDROID_JPEG_THUMBNAIL_QUALITY, &thumbnailQuality, 1); static const double gpsCoordinates[2] = { 0, 0 }; ADD_OR_SIZE(ANDROID_JPEG_GPS_COORDINATES, gpsCoordinates, 2); static const uint8_t gpsProcessingMethod[32] = "None"; ADD_OR_SIZE(ANDROID_JPEG_GPS_PROCESSING_METHOD, gpsProcessingMethod, 32); static const int64_t gpsTimestamp = 0; ADD_OR_SIZE(ANDROID_JPEG_GPS_TIMESTAMP, &gpsTimestamp, 1); static const int32_t jpegOrientation = 0; ADD_OR_SIZE(ANDROID_JPEG_ORIENTATION, &jpegOrientation, 1); /** android.stats */ static const uint8_t faceDetectMode = ANDROID_STATISTICS_FACE_DETECT_MODE_OFF; ADD_OR_SIZE(ANDROID_STATISTICS_FACE_DETECT_MODE, &faceDetectMode, 1); static const uint8_t histogramMode = ANDROID_STATISTICS_HISTOGRAM_MODE_OFF; ADD_OR_SIZE(ANDROID_STATISTICS_HISTOGRAM_MODE, &histogramMode, 1); static const uint8_t sharpnessMapMode = ANDROID_STATISTICS_SHARPNESS_MAP_MODE_OFF; ADD_OR_SIZE(ANDROID_STATISTICS_SHARPNESS_MAP_MODE, &sharpnessMapMode, 1); // faceRectangles, faceScores, faceLandmarks, faceIds, histogram, // sharpnessMap only in frames /** android.control */ uint8_t controlIntent = 0; switch (request_template) { case CAMERA2_TEMPLATE_PREVIEW: controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW; break; case CAMERA2_TEMPLATE_STILL_CAPTURE: controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE; break; case CAMERA2_TEMPLATE_VIDEO_RECORD: controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD; break; case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT: controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT; break; case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG: controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG; break; default: controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM; break; } ADD_OR_SIZE(ANDROID_CONTROL_CAPTURE_INTENT, &controlIntent, 1); static const uint8_t controlMode = ANDROID_CONTROL_MODE_AUTO; ADD_OR_SIZE(ANDROID_CONTROL_MODE, &controlMode, 1); static const uint8_t effectMode = ANDROID_CONTROL_EFFECT_MODE_OFF; ADD_OR_SIZE(ANDROID_CONTROL_EFFECT_MODE, &effectMode, 1); static const uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY; ADD_OR_SIZE(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1); static const uint8_t aeMode = ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH; ADD_OR_SIZE(ANDROID_CONTROL_AE_MODE, &aeMode, 1); static const uint8_t aeLock = ANDROID_CONTROL_AE_LOCK_OFF; ADD_OR_SIZE(ANDROID_CONTROL_AE_LOCK, &aeLock, 1); static const int32_t controlRegions[5] = { 0, 0, static_cast(Sensor::kResolution[0]), static_cast(Sensor::kResolution[1]), 1000 }; ADD_OR_SIZE(ANDROID_CONTROL_AE_REGIONS, controlRegions, 5); static const int32_t aeExpCompensation = 0; ADD_OR_SIZE(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExpCompensation, 1); static const int32_t aeTargetFpsRange[2] = { 10, 30 }; ADD_OR_SIZE(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, aeTargetFpsRange, 2); static const uint8_t aeAntibandingMode = ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO; ADD_OR_SIZE(ANDROID_CONTROL_AE_ANTIBANDING_MODE, &aeAntibandingMode, 1); static const uint8_t awbMode = ANDROID_CONTROL_AWB_MODE_AUTO; ADD_OR_SIZE(ANDROID_CONTROL_AWB_MODE, &awbMode, 1); static const uint8_t awbLock = ANDROID_CONTROL_AWB_LOCK_OFF; ADD_OR_SIZE(ANDROID_CONTROL_AWB_LOCK, &awbLock, 1); ADD_OR_SIZE(ANDROID_CONTROL_AWB_REGIONS, controlRegions, 5); uint8_t afMode = 0; switch (request_template) { case CAMERA2_TEMPLATE_PREVIEW: afMode = ANDROID_CONTROL_AF_MODE_AUTO; break; case CAMERA2_TEMPLATE_STILL_CAPTURE: afMode = ANDROID_CONTROL_AF_MODE_AUTO; break; case CAMERA2_TEMPLATE_VIDEO_RECORD: afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO; break; case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT: afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO; break; case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG: afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE; break; default: afMode = ANDROID_CONTROL_AF_MODE_AUTO; break; } ADD_OR_SIZE(ANDROID_CONTROL_AF_MODE, &afMode, 1); ADD_OR_SIZE(ANDROID_CONTROL_AF_REGIONS, controlRegions, 5); static const uint8_t vstabMode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF; ADD_OR_SIZE(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, &vstabMode, 1); // aeState, awbState, afState only in frame /** Allocate metadata if sizing */ if (sizeRequest) { ALOGV("Allocating %zu entries, %zu extra bytes for " "request template type %d", entryCount, dataCount, request_template); *request = allocate_camera_metadata(entryCount, dataCount); if (*request == NULL) { ALOGE("Unable to allocate new request template type %d " "(%zu entries, %zu bytes extra data)", request_template, entryCount, dataCount); return NO_MEMORY; } } return OK; #undef ADD_OR_SIZE } status_t EmulatedFakeCamera2::addOrSize(camera_metadata_t *request, bool sizeRequest, size_t *entryCount, size_t *dataCount, uint32_t tag, const void *entryData, size_t entryDataCount) { status_t res; if (!sizeRequest) { return add_camera_metadata_entry(request, tag, entryData, entryDataCount); } else { int type = get_camera_metadata_tag_type(tag); if (type < 0 ) return BAD_VALUE; (*entryCount)++; (*dataCount) += calculate_camera_metadata_entry_data_size(type, entryDataCount); return OK; } } bool EmulatedFakeCamera2::isStreamInUse(uint32_t id) { // Assumes mMutex is locked; otherwise new requests could enter // configureThread while readoutThread is being checked // Order of isStreamInUse calls matters if (mConfigureThread->isStreamInUse(id) || mReadoutThread->isStreamInUse(id) || mJpegCompressor->isStreamInUse(id) ) { ALOGE("%s: Stream %d is in use in active requests!", __FUNCTION__, id); return true; } return false; } bool EmulatedFakeCamera2::isReprocessStreamInUse(uint32_t id) { // TODO: implement return false; } const Stream& EmulatedFakeCamera2::getStreamInfo(uint32_t streamId) { Mutex::Autolock lock(mMutex); return mStreams.valueFor(streamId); } const ReprocessStream& EmulatedFakeCamera2::getReprocessStreamInfo(uint32_t streamId) { Mutex::Autolock lock(mMutex); return mReprocessStreams.valueFor(streamId); } }; /* namespace android */ anbox-0.0~git20191115/android/camera/EmulatedFakeCamera2.h000066400000000000000000000333201356361734700227710ustar00rootroot00000000000000/* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA2_H #define HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA2_H /* * Contains declaration of a class EmulatedFakeCamera2 that encapsulates * functionality of a fake camera that implements version 2 of the camera device * interface. */ #include "EmulatedCamera2.h" #include "fake-pipeline2/Base.h" #include "fake-pipeline2/Sensor.h" #include "fake-pipeline2/JpegCompressor.h" #include #include #include #include namespace android { /* Encapsulates functionality of an advanced fake camera. This camera contains * a simple simulation of a scene, sensor, and image processing pipeline. */ class EmulatedFakeCamera2 : public EmulatedCamera2 { public: /* Constructs EmulatedFakeCamera instance. */ EmulatedFakeCamera2(int cameraId, bool facingBack, struct hw_module_t* module); /* Destructs EmulatedFakeCamera instance. */ ~EmulatedFakeCamera2(); /**************************************************************************** * EmulatedCamera2 virtual overrides. ***************************************************************************/ public: /* Initializes EmulatedFakeCamera2 instance. */ status_t Initialize(); /**************************************************************************** * Camera Module API and generic hardware device API implementation ***************************************************************************/ public: virtual status_t connectCamera(hw_device_t** device); virtual status_t plugCamera(); virtual status_t unplugCamera(); virtual camera_device_status_t getHotplugStatus(); virtual status_t closeCamera(); virtual status_t getCameraInfo(struct camera_info *info); /**************************************************************************** * EmulatedCamera2 abstract API implementation. ***************************************************************************/ protected: /** Request input queue */ virtual int requestQueueNotify(); /** Count of requests in flight */ virtual int getInProgressCount(); /** Cancel all captures in flight */ //virtual int flushCapturesInProgress(); /** Construct default request */ virtual int constructDefaultRequest( int request_template, camera_metadata_t **request); virtual int allocateStream( uint32_t width, uint32_t height, int format, const camera2_stream_ops_t *stream_ops, uint32_t *stream_id, uint32_t *format_actual, uint32_t *usage, uint32_t *max_buffers); virtual int registerStreamBuffers( uint32_t stream_id, int num_buffers, buffer_handle_t *buffers); virtual int releaseStream(uint32_t stream_id); // virtual int allocateReprocessStream( // uint32_t width, // uint32_t height, // uint32_t format, // const camera2_stream_ops_t *stream_ops, // uint32_t *stream_id, // uint32_t *format_actual, // uint32_t *usage, // uint32_t *max_buffers); virtual int allocateReprocessStreamFromStream( uint32_t output_stream_id, const camera2_stream_in_ops_t *stream_ops, uint32_t *stream_id); virtual int releaseReprocessStream(uint32_t stream_id); virtual int triggerAction(uint32_t trigger_id, int32_t ext1, int32_t ext2); /** Debug methods */ virtual int dump(int fd); public: /**************************************************************************** * Utility methods called by configure/readout threads and pipeline ***************************************************************************/ // Get information about a given stream. Will lock mMutex const Stream &getStreamInfo(uint32_t streamId); const ReprocessStream &getReprocessStreamInfo(uint32_t streamId); // Notifies rest of camera subsystem of serious error void signalError(); private: /**************************************************************************** * Utility methods ***************************************************************************/ /** Construct static camera metadata, two-pass */ status_t constructStaticInfo( camera_metadata_t **info, bool sizeRequest) const; /** Two-pass implementation of constructDefaultRequest */ status_t constructDefaultRequest( int request_template, camera_metadata_t **request, bool sizeRequest) const; /** Helper function for constructDefaultRequest */ static status_t addOrSize( camera_metadata_t *request, bool sizeRequest, size_t *entryCount, size_t *dataCount, uint32_t tag, const void *entry_data, size_t entry_count); /** Determine if the stream id is listed in any currently-in-flight * requests. Assumes mMutex is locked */ bool isStreamInUse(uint32_t streamId); /** Determine if the reprocess stream id is listed in any * currently-in-flight requests. Assumes mMutex is locked */ bool isReprocessStreamInUse(uint32_t streamId); /**************************************************************************** * Pipeline controller threads ***************************************************************************/ class ConfigureThread: public Thread { public: ConfigureThread(EmulatedFakeCamera2 *parent); ~ConfigureThread(); status_t waitUntilRunning(); status_t newRequestAvailable(); status_t readyToRun(); bool isStreamInUse(uint32_t id); int getInProgressCount(); private: EmulatedFakeCamera2 *mParent; static const nsecs_t kWaitPerLoop = 10000000L; // 10 ms bool mRunning; bool threadLoop(); bool setupCapture(); bool setupReprocess(); bool configureNextCapture(); bool configureNextReprocess(); bool getBuffers(); Mutex mInputMutex; // Protects mActive, mRequestCount Condition mInputSignal; bool mActive; // Whether we're waiting for input requests or actively // working on them size_t mRequestCount; camera_metadata_t *mRequest; Mutex mInternalsMutex; // Lock before accessing below members. bool mWaitingForReadout; bool mNextNeedsJpeg; bool mNextIsCapture; int32_t mNextFrameNumber; int64_t mNextExposureTime; int64_t mNextFrameDuration; int32_t mNextSensitivity; Buffers *mNextBuffers; }; class ReadoutThread: public Thread, private JpegCompressor::JpegListener { public: ReadoutThread(EmulatedFakeCamera2 *parent); ~ReadoutThread(); status_t readyToRun(); // Input status_t waitUntilRunning(); bool waitForReady(nsecs_t timeout); void setNextOperation(bool isCapture, camera_metadata_t *request, Buffers *buffers); bool isStreamInUse(uint32_t id); int getInProgressCount(); private: EmulatedFakeCamera2 *mParent; bool mRunning; bool threadLoop(); bool readyForNextCapture(); status_t collectStatisticsMetadata(camera_metadata_t *frame); // Inputs Mutex mInputMutex; // Protects mActive, mInFlightQueue, mRequestCount Condition mInputSignal; Condition mReadySignal; bool mActive; static const int kInFlightQueueSize = 4; struct InFlightQueue { bool isCapture; camera_metadata_t *request; Buffers *buffers; } *mInFlightQueue; size_t mInFlightHead; size_t mInFlightTail; size_t mRequestCount; // Internals Mutex mInternalsMutex; bool mIsCapture; camera_metadata_t *mRequest; Buffers *mBuffers; // Jpeg completion listeners void onJpegDone(const StreamBuffer &jpegBuffer, bool success); void onJpegInputDone(const StreamBuffer &inputBuffer); nsecs_t mJpegTimestamp; }; // 3A management thread (auto-exposure, focus, white balance) class ControlThread: public Thread { public: ControlThread(EmulatedFakeCamera2 *parent); ~ControlThread(); status_t readyToRun(); status_t waitUntilRunning(); // Interpret request's control parameters and override // capture settings as needed status_t processRequest(camera_metadata_t *request); status_t triggerAction(uint32_t msgType, int32_t ext1, int32_t ext2); private: ControlThread(const ControlThread &t); ControlThread& operator=(const ControlThread &t); // Constants controlling fake 3A behavior static const nsecs_t kControlCycleDelay; static const nsecs_t kMinAfDuration; static const nsecs_t kMaxAfDuration; static const float kAfSuccessRate; static const float kContinuousAfStartRate; static const float kAeScanStartRate; static const nsecs_t kMinAeDuration; static const nsecs_t kMaxAeDuration; static const nsecs_t kMinPrecaptureAeDuration; static const nsecs_t kMaxPrecaptureAeDuration; static const nsecs_t kNormalExposureTime; static const nsecs_t kExposureJump; static const nsecs_t kMinExposureTime; EmulatedFakeCamera2 *mParent; bool mRunning; bool threadLoop(); Mutex mInputMutex; // Protects input methods Condition mInputSignal; // Trigger notifications bool mStartAf; bool mCancelAf; bool mStartPrecapture; // Latest state for 3A request fields uint8_t mControlMode; uint8_t mEffectMode; uint8_t mSceneMode; uint8_t mAfMode; bool mAfModeChange; uint8_t mAwbMode; uint8_t mAeMode; // Latest trigger IDs int32_t mAfTriggerId; int32_t mPrecaptureTriggerId; // Current state for 3A algorithms uint8_t mAfState; uint8_t mAeState; uint8_t mAwbState; bool mAeLock; // Current control parameters nsecs_t mExposureTime; // Private to threadLoop and its utility methods nsecs_t mAfScanDuration; nsecs_t mAeScanDuration; bool mLockAfterPassiveScan; // Utility methods for AF int processAfTrigger(uint8_t afMode, uint8_t afState); int maybeStartAfScan(uint8_t afMode, uint8_t afState); int updateAfScan(uint8_t afMode, uint8_t afState, nsecs_t *maxSleep); void updateAfState(uint8_t newState, int32_t triggerId); // Utility methods for precapture trigger int processPrecaptureTrigger(uint8_t aeMode, uint8_t aeState); int maybeStartAeScan(uint8_t aeMode, bool aeLock, uint8_t aeState); int updateAeScan(uint8_t aeMode, bool aeLock, uint8_t aeState, nsecs_t *maxSleep); void updateAeState(uint8_t newState, int32_t triggerId); }; /**************************************************************************** * Static configuration information ***************************************************************************/ private: static const uint32_t kMaxRawStreamCount = 1; static const uint32_t kMaxProcessedStreamCount = 3; static const uint32_t kMaxJpegStreamCount = 1; static const uint32_t kMaxReprocessStreamCount = 2; static const uint32_t kMaxBufferCount = 4; static const uint32_t kAvailableFormats[]; static const uint32_t kAvailableRawSizes[]; static const uint64_t kAvailableRawMinDurations[]; static const uint32_t kAvailableProcessedSizesBack[]; static const uint32_t kAvailableProcessedSizesFront[]; static const uint64_t kAvailableProcessedMinDurations[]; static const uint32_t kAvailableJpegSizesBack[]; static const uint32_t kAvailableJpegSizesFront[]; static const uint64_t kAvailableJpegMinDurations[]; /**************************************************************************** * Data members. ***************************************************************************/ protected: /* Facing back (true) or front (false) switch. */ bool mFacingBack; private: bool mIsConnected; /** Stream manipulation */ uint32_t mNextStreamId; uint32_t mRawStreamCount; uint32_t mProcessedStreamCount; uint32_t mJpegStreamCount; uint32_t mNextReprocessStreamId; uint32_t mReprocessStreamCount; KeyedVector mStreams; KeyedVector mReprocessStreams; /** Simulated hardware interfaces */ sp mSensor; sp mJpegCompressor; /** Pipeline control threads */ sp mConfigureThread; sp mReadoutThread; sp mControlThread; }; }; /* namespace android */ #endif /* HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA2_H */ anbox-0.0~git20191115/android/camera/EmulatedFakeCamera3.cpp000066400000000000000000002653561356361734700233450ustar00rootroot00000000000000/* * Copyright (C) 2013 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * Contains implementation of a class EmulatedFakeCamera3 that encapsulates * functionality of an advanced fake camera. */ #include //#define LOG_NDEBUG 0 //#define LOG_NNDEBUG 0 #define LOG_TAG "EmulatedCamera_FakeCamera3" #include #include #include "EmulatedFakeCamera3.h" #include "EmulatedCameraFactory.h" #include #include #include #include "gralloc_cb.h" #include "fake-pipeline2/Sensor.h" #include "fake-pipeline2/JpegCompressor.h" #include #include #if defined(LOG_NNDEBUG) && LOG_NNDEBUG == 0 #define ALOGVV ALOGV #else #define ALOGVV(...) ((void)0) #endif namespace android { /** * Constants for camera capabilities */ const int64_t USEC = 1000LL; const int64_t MSEC = USEC * 1000LL; const int64_t SEC = MSEC * 1000LL; const int32_t EmulatedFakeCamera3::kAvailableFormats[] = { HAL_PIXEL_FORMAT_RAW16, HAL_PIXEL_FORMAT_BLOB, HAL_PIXEL_FORMAT_RGBA_8888, HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, // These are handled by YCbCr_420_888 // HAL_PIXEL_FORMAT_YV12, // HAL_PIXEL_FORMAT_YCrCb_420_SP, HAL_PIXEL_FORMAT_YCbCr_420_888, HAL_PIXEL_FORMAT_Y16 }; /** * 3A constants */ // Default exposure and gain targets for different scenarios const nsecs_t EmulatedFakeCamera3::kNormalExposureTime = 10 * MSEC; const nsecs_t EmulatedFakeCamera3::kFacePriorityExposureTime = 30 * MSEC; const int EmulatedFakeCamera3::kNormalSensitivity = 100; const int EmulatedFakeCamera3::kFacePrioritySensitivity = 400; const float EmulatedFakeCamera3::kExposureTrackRate = 0.1; const int EmulatedFakeCamera3::kPrecaptureMinFrames = 10; const int EmulatedFakeCamera3::kStableAeMaxFrames = 100; const float EmulatedFakeCamera3::kExposureWanderMin = -2; const float EmulatedFakeCamera3::kExposureWanderMax = 1; /** * Camera device lifecycle methods */ EmulatedFakeCamera3::EmulatedFakeCamera3(int cameraId, bool facingBack, struct hw_module_t* module) : EmulatedCamera3(cameraId, module), mFacingBack(facingBack) { ALOGI("Constructing emulated fake camera 3: ID %d, facing %s", mCameraID, facingBack ? "back" : "front"); for (size_t i = 0; i < CAMERA3_TEMPLATE_COUNT; i++) { mDefaultTemplates[i] = NULL; } } EmulatedFakeCamera3::~EmulatedFakeCamera3() { for (size_t i = 0; i < CAMERA3_TEMPLATE_COUNT; i++) { if (mDefaultTemplates[i] != NULL) { free_camera_metadata(mDefaultTemplates[i]); } } } status_t EmulatedFakeCamera3::Initialize() { ALOGV("%s: E", __FUNCTION__); status_t res; if (mStatus != STATUS_ERROR) { ALOGE("%s: Already initialized!", __FUNCTION__); return INVALID_OPERATION; } res = getCameraCapabilities(); if (res != OK) { ALOGE("%s: Unable to get camera capabilities: %s (%d)", __FUNCTION__, strerror(-res), res); return res; } res = constructStaticInfo(); if (res != OK) { ALOGE("%s: Unable to allocate static info: %s (%d)", __FUNCTION__, strerror(-res), res); return res; } return EmulatedCamera3::Initialize(); } status_t EmulatedFakeCamera3::connectCamera(hw_device_t** device) { ALOGV("%s: E", __FUNCTION__); Mutex::Autolock l(mLock); status_t res; if (mStatus != STATUS_CLOSED) { ALOGE("%s: Can't connect in state %d", __FUNCTION__, mStatus); return INVALID_OPERATION; } mSensor = new Sensor(); mSensor->setSensorListener(this); res = mSensor->startUp(); if (res != NO_ERROR) return res; mReadoutThread = new ReadoutThread(this); mJpegCompressor = new JpegCompressor(); res = mReadoutThread->run("EmuCam3::readoutThread"); if (res != NO_ERROR) return res; // Initialize fake 3A mControlMode = ANDROID_CONTROL_MODE_AUTO; mFacePriority = false; mAeMode = ANDROID_CONTROL_AE_MODE_ON; mAfMode = ANDROID_CONTROL_AF_MODE_AUTO; mAwbMode = ANDROID_CONTROL_AWB_MODE_AUTO; mAeState = ANDROID_CONTROL_AE_STATE_INACTIVE; mAfState = ANDROID_CONTROL_AF_STATE_INACTIVE; mAwbState = ANDROID_CONTROL_AWB_STATE_INACTIVE; mAeCounter = 0; mAeTargetExposureTime = kNormalExposureTime; mAeCurrentExposureTime = kNormalExposureTime; mAeCurrentSensitivity = kNormalSensitivity; return EmulatedCamera3::connectCamera(device); } status_t EmulatedFakeCamera3::closeCamera() { ALOGV("%s: E", __FUNCTION__); status_t res; { Mutex::Autolock l(mLock); if (mStatus == STATUS_CLOSED) return OK; res = mSensor->shutDown(); if (res != NO_ERROR) { ALOGE("%s: Unable to shut down sensor: %d", __FUNCTION__, res); return res; } mSensor.clear(); mReadoutThread->requestExit(); } mReadoutThread->join(); { Mutex::Autolock l(mLock); // Clear out private stream information for (StreamIterator s = mStreams.begin(); s != mStreams.end(); s++) { PrivateStreamInfo *privStream = static_cast((*s)->priv); delete privStream; (*s)->priv = NULL; } mStreams.clear(); mReadoutThread.clear(); } return EmulatedCamera3::closeCamera(); } status_t EmulatedFakeCamera3::getCameraInfo(struct camera_info *info) { info->facing = mFacingBack ? CAMERA_FACING_BACK : CAMERA_FACING_FRONT; info->orientation = gEmulatedCameraFactory.getFakeCameraOrientation(); return EmulatedCamera3::getCameraInfo(info); } /** * Camera3 interface methods */ status_t EmulatedFakeCamera3::configureStreams( camera3_stream_configuration *streamList) { Mutex::Autolock l(mLock); ALOGV("%s: %d streams", __FUNCTION__, streamList->num_streams); if (mStatus != STATUS_OPEN && mStatus != STATUS_READY) { ALOGE("%s: Cannot configure streams in state %d", __FUNCTION__, mStatus); return NO_INIT; } /** * Sanity-check input list. */ if (streamList == NULL) { ALOGE("%s: NULL stream configuration", __FUNCTION__); return BAD_VALUE; } if (streamList->streams == NULL) { ALOGE("%s: NULL stream list", __FUNCTION__); return BAD_VALUE; } if (streamList->num_streams < 1) { ALOGE("%s: Bad number of streams requested: %d", __FUNCTION__, streamList->num_streams); return BAD_VALUE; } camera3_stream_t *inputStream = NULL; for (size_t i = 0; i < streamList->num_streams; i++) { camera3_stream_t *newStream = streamList->streams[i]; if (newStream == NULL) { ALOGE("%s: Stream index %zu was NULL", __FUNCTION__, i); return BAD_VALUE; } ALOGV("%s: Stream %p (id %zu), type %d, usage 0x%x, format 0x%x", __FUNCTION__, newStream, i, newStream->stream_type, newStream->usage, newStream->format); if (newStream->stream_type == CAMERA3_STREAM_INPUT || newStream->stream_type == CAMERA3_STREAM_BIDIRECTIONAL) { if (inputStream != NULL) { ALOGE("%s: Multiple input streams requested!", __FUNCTION__); return BAD_VALUE; } inputStream = newStream; } bool validFormat = false; for (size_t f = 0; f < sizeof(kAvailableFormats)/sizeof(kAvailableFormats[0]); f++) { if (newStream->format == kAvailableFormats[f]) { validFormat = true; break; } } if (!validFormat) { ALOGE("%s: Unsupported stream format 0x%x requested", __FUNCTION__, newStream->format); return BAD_VALUE; } } mInputStream = inputStream; /** * Initially mark all existing streams as not alive */ for (StreamIterator s = mStreams.begin(); s != mStreams.end(); ++s) { PrivateStreamInfo *privStream = static_cast((*s)->priv); privStream->alive = false; } /** * Find new streams and mark still-alive ones */ for (size_t i = 0; i < streamList->num_streams; i++) { camera3_stream_t *newStream = streamList->streams[i]; if (newStream->priv == NULL) { // New stream, construct info PrivateStreamInfo *privStream = new PrivateStreamInfo(); privStream->alive = true; newStream->max_buffers = kMaxBufferCount; newStream->priv = privStream; mStreams.push_back(newStream); } else { // Existing stream, mark as still alive. PrivateStreamInfo *privStream = static_cast(newStream->priv); privStream->alive = true; } // Always update usage and max buffers newStream->max_buffers = kMaxBufferCount; switch (newStream->stream_type) { case CAMERA3_STREAM_OUTPUT: newStream->usage = GRALLOC_USAGE_HW_CAMERA_WRITE; break; case CAMERA3_STREAM_INPUT: newStream->usage = GRALLOC_USAGE_HW_CAMERA_READ; break; case CAMERA3_STREAM_BIDIRECTIONAL: newStream->usage = GRALLOC_USAGE_HW_CAMERA_READ | GRALLOC_USAGE_HW_CAMERA_WRITE; break; } } /** * Reap the dead streams */ for (StreamIterator s = mStreams.begin(); s != mStreams.end();) { PrivateStreamInfo *privStream = static_cast((*s)->priv); if (!privStream->alive) { (*s)->priv = NULL; delete privStream; s = mStreams.erase(s); } else { ++s; } } /** * Can't reuse settings across configure call */ mPrevSettings.clear(); return OK; } status_t EmulatedFakeCamera3::registerStreamBuffers( const camera3_stream_buffer_set *bufferSet) { ALOGV("%s: E", __FUNCTION__); Mutex::Autolock l(mLock); // Should not be called in HAL versions >= 3.2 ALOGE("%s: Should not be invoked on new HALs!", __FUNCTION__); return NO_INIT; } const camera_metadata_t* EmulatedFakeCamera3::constructDefaultRequestSettings( int type) { ALOGV("%s: E", __FUNCTION__); Mutex::Autolock l(mLock); if (type < 0 || type >= CAMERA3_TEMPLATE_COUNT) { ALOGE("%s: Unknown request settings template: %d", __FUNCTION__, type); return NULL; } if (!hasCapability(BACKWARD_COMPATIBLE) && type != CAMERA3_TEMPLATE_PREVIEW) { ALOGE("%s: Template %d not supported w/o BACKWARD_COMPATIBLE capability", __FUNCTION__, type); return NULL; } /** * Cache is not just an optimization - pointer returned has to live at * least as long as the camera device instance does. */ if (mDefaultTemplates[type] != NULL) { return mDefaultTemplates[type]; } CameraMetadata settings; /** android.request */ static const uint8_t metadataMode = ANDROID_REQUEST_METADATA_MODE_FULL; settings.update(ANDROID_REQUEST_METADATA_MODE, &metadataMode, 1); static const int32_t id = 0; settings.update(ANDROID_REQUEST_ID, &id, 1); static const int32_t frameCount = 0; settings.update(ANDROID_REQUEST_FRAME_COUNT, &frameCount, 1); /** android.lens */ static const float focalLength = 5.0f; settings.update(ANDROID_LENS_FOCAL_LENGTH, &focalLength, 1); if (hasCapability(BACKWARD_COMPATIBLE)) { static const float focusDistance = 0; settings.update(ANDROID_LENS_FOCUS_DISTANCE, &focusDistance, 1); static const float aperture = 2.8f; settings.update(ANDROID_LENS_APERTURE, &aperture, 1); static const float filterDensity = 0; settings.update(ANDROID_LENS_FILTER_DENSITY, &filterDensity, 1); static const uint8_t opticalStabilizationMode = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF; settings.update(ANDROID_LENS_OPTICAL_STABILIZATION_MODE, &opticalStabilizationMode, 1); // FOCUS_RANGE set only in frame } /** android.sensor */ if (hasCapability(MANUAL_SENSOR)) { static const int64_t exposureTime = 10 * MSEC; settings.update(ANDROID_SENSOR_EXPOSURE_TIME, &exposureTime, 1); static const int64_t frameDuration = 33333333L; // 1/30 s settings.update(ANDROID_SENSOR_FRAME_DURATION, &frameDuration, 1); static const int32_t sensitivity = 100; settings.update(ANDROID_SENSOR_SENSITIVITY, &sensitivity, 1); } // TIMESTAMP set only in frame /** android.flash */ if (hasCapability(BACKWARD_COMPATIBLE)) { static const uint8_t flashMode = ANDROID_FLASH_MODE_OFF; settings.update(ANDROID_FLASH_MODE, &flashMode, 1); static const uint8_t flashPower = 10; settings.update(ANDROID_FLASH_FIRING_POWER, &flashPower, 1); static const int64_t firingTime = 0; settings.update(ANDROID_FLASH_FIRING_TIME, &firingTime, 1); } /** Processing block modes */ if (hasCapability(MANUAL_POST_PROCESSING)) { uint8_t hotPixelMode = 0; uint8_t demosaicMode = 0; uint8_t noiseMode = 0; uint8_t shadingMode = 0; uint8_t colorMode = 0; uint8_t tonemapMode = 0; uint8_t edgeMode = 0; switch (type) { case CAMERA3_TEMPLATE_STILL_CAPTURE: // fall-through case CAMERA3_TEMPLATE_VIDEO_SNAPSHOT: // fall-through case CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG: hotPixelMode = ANDROID_HOT_PIXEL_MODE_HIGH_QUALITY; demosaicMode = ANDROID_DEMOSAIC_MODE_HIGH_QUALITY; noiseMode = ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY; shadingMode = ANDROID_SHADING_MODE_HIGH_QUALITY; colorMode = ANDROID_COLOR_CORRECTION_MODE_HIGH_QUALITY; tonemapMode = ANDROID_TONEMAP_MODE_HIGH_QUALITY; edgeMode = ANDROID_EDGE_MODE_HIGH_QUALITY; break; case CAMERA3_TEMPLATE_PREVIEW: // fall-through case CAMERA3_TEMPLATE_VIDEO_RECORD: // fall-through default: hotPixelMode = ANDROID_HOT_PIXEL_MODE_FAST; demosaicMode = ANDROID_DEMOSAIC_MODE_FAST; noiseMode = ANDROID_NOISE_REDUCTION_MODE_FAST; shadingMode = ANDROID_SHADING_MODE_FAST; colorMode = ANDROID_COLOR_CORRECTION_MODE_FAST; tonemapMode = ANDROID_TONEMAP_MODE_FAST; edgeMode = ANDROID_EDGE_MODE_FAST; break; } settings.update(ANDROID_HOT_PIXEL_MODE, &hotPixelMode, 1); settings.update(ANDROID_DEMOSAIC_MODE, &demosaicMode, 1); settings.update(ANDROID_NOISE_REDUCTION_MODE, &noiseMode, 1); settings.update(ANDROID_SHADING_MODE, &shadingMode, 1); settings.update(ANDROID_COLOR_CORRECTION_MODE, &colorMode, 1); settings.update(ANDROID_TONEMAP_MODE, &tonemapMode, 1); settings.update(ANDROID_EDGE_MODE, &edgeMode, 1); } /** android.colorCorrection */ if (hasCapability(MANUAL_POST_PROCESSING)) { static const camera_metadata_rational colorTransform[9] = { {1,1}, {0,1}, {0,1}, {0,1}, {1,1}, {0,1}, {0,1}, {0,1}, {1,1} }; settings.update(ANDROID_COLOR_CORRECTION_TRANSFORM, colorTransform, 9); static const float colorGains[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; settings.update(ANDROID_COLOR_CORRECTION_GAINS, colorGains, 4); } /** android.tonemap */ if (hasCapability(MANUAL_POST_PROCESSING)) { static const float tonemapCurve[4] = { 0.f, 0.f, 1.f, 1.f }; settings.update(ANDROID_TONEMAP_CURVE_RED, tonemapCurve, 4); settings.update(ANDROID_TONEMAP_CURVE_GREEN, tonemapCurve, 4); settings.update(ANDROID_TONEMAP_CURVE_BLUE, tonemapCurve, 4); } /** android.scaler */ if (hasCapability(BACKWARD_COMPATIBLE)) { static const int32_t cropRegion[4] = { 0, 0, (int32_t)Sensor::kResolution[0], (int32_t)Sensor::kResolution[1] }; settings.update(ANDROID_SCALER_CROP_REGION, cropRegion, 4); } /** android.jpeg */ if (hasCapability(BACKWARD_COMPATIBLE)) { static const uint8_t jpegQuality = 80; settings.update(ANDROID_JPEG_QUALITY, &jpegQuality, 1); static const int32_t thumbnailSize[2] = { 640, 480 }; settings.update(ANDROID_JPEG_THUMBNAIL_SIZE, thumbnailSize, 2); static const uint8_t thumbnailQuality = 80; settings.update(ANDROID_JPEG_THUMBNAIL_QUALITY, &thumbnailQuality, 1); static const double gpsCoordinates[2] = { 0, 0 }; settings.update(ANDROID_JPEG_GPS_COORDINATES, gpsCoordinates, 2); static const uint8_t gpsProcessingMethod[32] = "None"; settings.update(ANDROID_JPEG_GPS_PROCESSING_METHOD, gpsProcessingMethod, 32); static const int64_t gpsTimestamp = 0; settings.update(ANDROID_JPEG_GPS_TIMESTAMP, &gpsTimestamp, 1); static const int32_t jpegOrientation = 0; settings.update(ANDROID_JPEG_ORIENTATION, &jpegOrientation, 1); } /** android.stats */ if (hasCapability(BACKWARD_COMPATIBLE)) { static const uint8_t faceDetectMode = ANDROID_STATISTICS_FACE_DETECT_MODE_OFF; settings.update(ANDROID_STATISTICS_FACE_DETECT_MODE, &faceDetectMode, 1); static const uint8_t hotPixelMapMode = ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF; settings.update(ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE, &hotPixelMapMode, 1); } // faceRectangles, faceScores, faceLandmarks, faceIds, histogram, // sharpnessMap only in frames /** android.control */ uint8_t controlIntent = 0; switch (type) { case CAMERA3_TEMPLATE_PREVIEW: controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW; break; case CAMERA3_TEMPLATE_STILL_CAPTURE: controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE; break; case CAMERA3_TEMPLATE_VIDEO_RECORD: controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD; break; case CAMERA3_TEMPLATE_VIDEO_SNAPSHOT: controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT; break; case CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG: controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG; break; case CAMERA3_TEMPLATE_MANUAL: controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_MANUAL; break; default: controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM; break; } settings.update(ANDROID_CONTROL_CAPTURE_INTENT, &controlIntent, 1); const uint8_t controlMode = (type == CAMERA3_TEMPLATE_MANUAL) ? ANDROID_CONTROL_MODE_OFF : ANDROID_CONTROL_MODE_AUTO; settings.update(ANDROID_CONTROL_MODE, &controlMode, 1); int32_t aeTargetFpsRange[2] = { 5, 30 }; if (type == CAMERA3_TEMPLATE_VIDEO_RECORD || type == CAMERA3_TEMPLATE_VIDEO_SNAPSHOT) { aeTargetFpsRange[0] = 30; } settings.update(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, aeTargetFpsRange, 2); if (hasCapability(BACKWARD_COMPATIBLE)) { static const uint8_t effectMode = ANDROID_CONTROL_EFFECT_MODE_OFF; settings.update(ANDROID_CONTROL_EFFECT_MODE, &effectMode, 1); static const uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY; settings.update(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1); const uint8_t aeMode = (type == CAMERA3_TEMPLATE_MANUAL) ? ANDROID_CONTROL_AE_MODE_OFF : ANDROID_CONTROL_AE_MODE_ON; settings.update(ANDROID_CONTROL_AE_MODE, &aeMode, 1); static const uint8_t aeLock = ANDROID_CONTROL_AE_LOCK_OFF; settings.update(ANDROID_CONTROL_AE_LOCK, &aeLock, 1); static const int32_t controlRegions[5] = { 0, 0, 0, 0, 0 }; settings.update(ANDROID_CONTROL_AE_REGIONS, controlRegions, 5); static const int32_t aeExpCompensation = 0; settings.update(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExpCompensation, 1); static const uint8_t aeAntibandingMode = ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO; settings.update(ANDROID_CONTROL_AE_ANTIBANDING_MODE, &aeAntibandingMode, 1); static const uint8_t aePrecaptureTrigger = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE; settings.update(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER, &aePrecaptureTrigger, 1); const uint8_t awbMode = (type == CAMERA3_TEMPLATE_MANUAL) ? ANDROID_CONTROL_AWB_MODE_OFF : ANDROID_CONTROL_AWB_MODE_AUTO; settings.update(ANDROID_CONTROL_AWB_MODE, &awbMode, 1); static const uint8_t awbLock = ANDROID_CONTROL_AWB_LOCK_OFF; settings.update(ANDROID_CONTROL_AWB_LOCK, &awbLock, 1); uint8_t afMode = 0; switch (type) { case CAMERA3_TEMPLATE_PREVIEW: afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE; break; case CAMERA3_TEMPLATE_STILL_CAPTURE: afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE; break; case CAMERA3_TEMPLATE_VIDEO_RECORD: afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO; break; case CAMERA3_TEMPLATE_VIDEO_SNAPSHOT: afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO; break; case CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG: afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE; break; case CAMERA3_TEMPLATE_MANUAL: afMode = ANDROID_CONTROL_AF_MODE_OFF; break; default: afMode = ANDROID_CONTROL_AF_MODE_AUTO; break; } settings.update(ANDROID_CONTROL_AF_MODE, &afMode, 1); settings.update(ANDROID_CONTROL_AF_REGIONS, controlRegions, 5); static const uint8_t afTrigger = ANDROID_CONTROL_AF_TRIGGER_IDLE; settings.update(ANDROID_CONTROL_AF_TRIGGER, &afTrigger, 1); static const uint8_t vstabMode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF; settings.update(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, &vstabMode, 1); static const uint8_t blackLevelLock = ANDROID_BLACK_LEVEL_LOCK_OFF; settings.update(ANDROID_BLACK_LEVEL_LOCK, &blackLevelLock, 1); static const uint8_t lensShadingMapMode = ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF; settings.update(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE, &lensShadingMapMode, 1); static const uint8_t aberrationMode = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST; settings.update(ANDROID_COLOR_CORRECTION_ABERRATION_MODE, &aberrationMode, 1); static const int32_t testPatternMode = ANDROID_SENSOR_TEST_PATTERN_MODE_OFF; settings.update(ANDROID_SENSOR_TEST_PATTERN_MODE, &testPatternMode, 1); } mDefaultTemplates[type] = settings.release(); return mDefaultTemplates[type]; } status_t EmulatedFakeCamera3::processCaptureRequest( camera3_capture_request *request) { Mutex::Autolock l(mLock); status_t res; /** Validation */ if (mStatus < STATUS_READY) { ALOGE("%s: Can't submit capture requests in state %d", __FUNCTION__, mStatus); return INVALID_OPERATION; } if (request == NULL) { ALOGE("%s: NULL request!", __FUNCTION__); return BAD_VALUE; } uint32_t frameNumber = request->frame_number; if (request->settings == NULL && mPrevSettings.isEmpty()) { ALOGE("%s: Request %d: NULL settings for first request after" "configureStreams()", __FUNCTION__, frameNumber); return BAD_VALUE; } if (request->input_buffer != NULL && request->input_buffer->stream != mInputStream) { ALOGE("%s: Request %d: Input buffer not from input stream!", __FUNCTION__, frameNumber); ALOGV("%s: Bad stream %p, expected: %p", __FUNCTION__, request->input_buffer->stream, mInputStream); ALOGV("%s: Bad stream type %d, expected stream type %d", __FUNCTION__, request->input_buffer->stream->stream_type, mInputStream ? mInputStream->stream_type : -1); return BAD_VALUE; } if (request->num_output_buffers < 1 || request->output_buffers == NULL) { ALOGE("%s: Request %d: No output buffers provided!", __FUNCTION__, frameNumber); return BAD_VALUE; } // Validate all buffers, starting with input buffer if it's given ssize_t idx; const camera3_stream_buffer_t *b; if (request->input_buffer != NULL) { idx = -1; b = request->input_buffer; } else { idx = 0; b = request->output_buffers; } do { PrivateStreamInfo *priv = static_cast(b->stream->priv); if (priv == NULL) { ALOGE("%s: Request %d: Buffer %zu: Unconfigured stream!", __FUNCTION__, frameNumber, idx); return BAD_VALUE; } if (!priv->alive) { ALOGE("%s: Request %d: Buffer %zu: Dead stream!", __FUNCTION__, frameNumber, idx); return BAD_VALUE; } if (b->status != CAMERA3_BUFFER_STATUS_OK) { ALOGE("%s: Request %d: Buffer %zu: Status not OK!", __FUNCTION__, frameNumber, idx); return BAD_VALUE; } if (b->release_fence != -1) { ALOGE("%s: Request %d: Buffer %zu: Has a release fence!", __FUNCTION__, frameNumber, idx); return BAD_VALUE; } if (b->buffer == NULL) { ALOGE("%s: Request %d: Buffer %zu: NULL buffer handle!", __FUNCTION__, frameNumber, idx); return BAD_VALUE; } idx++; b = &(request->output_buffers[idx]); } while (idx < (ssize_t)request->num_output_buffers); // TODO: Validate settings parameters /** * Start processing this request */ mStatus = STATUS_ACTIVE; CameraMetadata settings; if (request->settings == NULL) { settings.acquire(mPrevSettings); } else { settings = request->settings; } res = process3A(settings); if (res != OK) { return res; } // TODO: Handle reprocessing /** * Get ready for sensor config */ nsecs_t exposureTime; nsecs_t frameDuration; uint32_t sensitivity; bool needJpeg = false; camera_metadata_entry_t entry; entry = settings.find(ANDROID_SENSOR_EXPOSURE_TIME); exposureTime = (entry.count > 0) ? entry.data.i64[0] : Sensor::kExposureTimeRange[0]; entry = settings.find(ANDROID_SENSOR_FRAME_DURATION); frameDuration = (entry.count > 0)? entry.data.i64[0] : Sensor::kFrameDurationRange[0]; entry = settings.find(ANDROID_SENSOR_SENSITIVITY); sensitivity = (entry.count > 0) ? entry.data.i32[0] : Sensor::kSensitivityRange[0]; if (exposureTime > frameDuration) { frameDuration = exposureTime + Sensor::kMinVerticalBlank; settings.update(ANDROID_SENSOR_FRAME_DURATION, &frameDuration, 1); } Buffers *sensorBuffers = new Buffers(); HalBufferVector *buffers = new HalBufferVector(); sensorBuffers->setCapacity(request->num_output_buffers); buffers->setCapacity(request->num_output_buffers); // Process all the buffers we got for output, constructing internal buffer // structures for them, and lock them for writing. for (size_t i = 0; i < request->num_output_buffers; i++) { const camera3_stream_buffer &srcBuf = request->output_buffers[i]; const cb_handle_t *privBuffer = static_cast(*srcBuf.buffer); StreamBuffer destBuf; destBuf.streamId = kGenericStreamId; destBuf.width = srcBuf.stream->width; destBuf.height = srcBuf.stream->height; destBuf.format = privBuffer->format; // Use real private format destBuf.stride = srcBuf.stream->width; // TODO: query from gralloc destBuf.dataSpace = srcBuf.stream->data_space; destBuf.buffer = srcBuf.buffer; if (destBuf.format == HAL_PIXEL_FORMAT_BLOB) { needJpeg = true; } // Wait on fence sp bufferAcquireFence = new Fence(srcBuf.acquire_fence); res = bufferAcquireFence->wait(kFenceTimeoutMs); if (res == TIMED_OUT) { ALOGE("%s: Request %d: Buffer %zu: Fence timed out after %d ms", __FUNCTION__, frameNumber, i, kFenceTimeoutMs); } if (res == OK) { // Lock buffer for writing const Rect rect(destBuf.width, destBuf.height); if (srcBuf.stream->format == HAL_PIXEL_FORMAT_YCbCr_420_888) { if (privBuffer->format == HAL_PIXEL_FORMAT_YCrCb_420_SP) { android_ycbcr ycbcr = android_ycbcr(); res = GraphicBufferMapper::get().lockYCbCr( *(destBuf.buffer), GRALLOC_USAGE_HW_CAMERA_WRITE, rect, &ycbcr); // This is only valid because we know that emulator's // YCbCr_420_888 is really contiguous NV21 under the hood destBuf.img = static_cast(ycbcr.y); } else { ALOGE("Unexpected private format for flexible YUV: 0x%x", privBuffer->format); res = INVALID_OPERATION; } } else { res = GraphicBufferMapper::get().lock(*(destBuf.buffer), GRALLOC_USAGE_HW_CAMERA_WRITE, rect, (void**)&(destBuf.img)); } if (res != OK) { ALOGE("%s: Request %d: Buffer %zu: Unable to lock buffer", __FUNCTION__, frameNumber, i); } } if (res != OK) { // Either waiting or locking failed. Unlock locked buffers and bail // out. for (size_t j = 0; j < i; j++) { GraphicBufferMapper::get().unlock( *(request->output_buffers[i].buffer)); } return NO_INIT; } sensorBuffers->push_back(destBuf); buffers->push_back(srcBuf); } /** * Wait for JPEG compressor to not be busy, if needed */ if (needJpeg) { bool ready = mJpegCompressor->waitForDone(kFenceTimeoutMs); if (!ready) { ALOGE("%s: Timeout waiting for JPEG compression to complete!", __FUNCTION__); return NO_INIT; } } /** * Wait until the in-flight queue has room */ res = mReadoutThread->waitForReadout(); if (res != OK) { ALOGE("%s: Timeout waiting for previous requests to complete!", __FUNCTION__); return NO_INIT; } /** * Wait until sensor's ready. This waits for lengthy amounts of time with * mLock held, but the interface spec is that no other calls may by done to * the HAL by the framework while process_capture_request is happening. */ int syncTimeoutCount = 0; while(!mSensor->waitForVSync(kSyncWaitTimeout)) { if (mStatus == STATUS_ERROR) { return NO_INIT; } if (syncTimeoutCount == kMaxSyncTimeoutCount) { ALOGE("%s: Request %d: Sensor sync timed out after %" PRId64 " ms", __FUNCTION__, frameNumber, kSyncWaitTimeout * kMaxSyncTimeoutCount / 1000000); return NO_INIT; } syncTimeoutCount++; } /** * Configure sensor and queue up the request to the readout thread */ mSensor->setExposureTime(exposureTime); mSensor->setFrameDuration(frameDuration); mSensor->setSensitivity(sensitivity); mSensor->setDestinationBuffers(sensorBuffers); mSensor->setFrameNumber(request->frame_number); ReadoutThread::Request r; r.frameNumber = request->frame_number; r.settings = settings; r.sensorBuffers = sensorBuffers; r.buffers = buffers; mReadoutThread->queueCaptureRequest(r); ALOGVV("%s: Queued frame %d", __FUNCTION__, request->frame_number); // Cache the settings for next time mPrevSettings.acquire(settings); return OK; } status_t EmulatedFakeCamera3::flush() { ALOGW("%s: Not implemented; ignored", __FUNCTION__); return OK; } /** Debug methods */ void EmulatedFakeCamera3::dump(int fd) { } /** * Private methods */ status_t EmulatedFakeCamera3::getCameraCapabilities() { const char *key = mFacingBack ? "qemu.sf.back_camera_caps" : "qemu.sf.front_camera_caps"; /* Defined by 'qemu.sf.*_camera_caps' boot property: if the * property doesn't exist, it is assumed to list FULL. */ char prop[PROPERTY_VALUE_MAX]; if (property_get(key, prop, NULL) > 0) { char *saveptr = nullptr; char *cap = strtok_r(prop, " ,", &saveptr); while (cap != NULL) { for (int i = 0; i < NUM_CAPABILITIES; i++) { if (!strcasecmp(cap, sAvailableCapabilitiesStrings[i])) { mCapabilities.add(static_cast(i)); break; } } cap = strtok_r(NULL, " ,", &saveptr); } if (mCapabilities.size() == 0) { ALOGE("qemu.sf.back_camera_caps had no valid capabilities: %s", prop); } } // Default to FULL_LEVEL plus RAW if nothing is defined if (mCapabilities.size() == 0) { mCapabilities.add(FULL_LEVEL); mCapabilities.add(RAW); } // Add level-based caps if (hasCapability(FULL_LEVEL)) { mCapabilities.add(BURST_CAPTURE); mCapabilities.add(READ_SENSOR_SETTINGS); mCapabilities.add(MANUAL_SENSOR); mCapabilities.add(MANUAL_POST_PROCESSING); }; // Backwards-compatible is required for most other caps // Not required for DEPTH_OUTPUT, though. if (hasCapability(BURST_CAPTURE) || hasCapability(READ_SENSOR_SETTINGS) || hasCapability(RAW) || hasCapability(MANUAL_SENSOR) || hasCapability(MANUAL_POST_PROCESSING) || hasCapability(PRIVATE_REPROCESSING) || hasCapability(YUV_REPROCESSING) || hasCapability(CONSTRAINED_HIGH_SPEED_VIDEO)) { mCapabilities.add(BACKWARD_COMPATIBLE); } ALOGI("Camera %d capabilities:", mCameraID); for (size_t i = 0; i < mCapabilities.size(); i++) { ALOGI(" %s", sAvailableCapabilitiesStrings[mCapabilities[i]]); } return OK; } bool EmulatedFakeCamera3::hasCapability(AvailableCapabilities cap) { ssize_t idx = mCapabilities.indexOf(cap); return idx >= 0; } status_t EmulatedFakeCamera3::constructStaticInfo() { CameraMetadata info; Vector availableCharacteristicsKeys; status_t res; #define ADD_STATIC_ENTRY(name, varptr, count) \ availableCharacteristicsKeys.add(name); \ res = info.update(name, varptr, count); \ if (res != OK) return res // android.sensor if (hasCapability(MANUAL_SENSOR)) { ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE, Sensor::kExposureTimeRange, 2); ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION, &Sensor::kFrameDurationRange[1], 1); ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE, Sensor::kSensitivityRange, sizeof(Sensor::kSensitivityRange) /sizeof(int32_t)); ADD_STATIC_ENTRY(ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY, &Sensor::kSensitivityRange[1], 1); } static const float sensorPhysicalSize[2] = {3.20f, 2.40f}; // mm ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_PHYSICAL_SIZE, sensorPhysicalSize, 2); ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE, (int32_t*)Sensor::kResolution, 2); ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE, (int32_t*)Sensor::kActiveArray, 4); static const int32_t orientation = 90; // Aligned with 'long edge' ADD_STATIC_ENTRY(ANDROID_SENSOR_ORIENTATION, &orientation, 1); static const uint8_t timestampSource = ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_REALTIME; ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE, ×tampSource, 1); if (hasCapability(RAW)) { ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, &Sensor::kColorFilterArrangement, 1); ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_WHITE_LEVEL, (int32_t*)&Sensor::kMaxRawValue, 1); static const int32_t blackLevelPattern[4] = { (int32_t)Sensor::kBlackLevel, (int32_t)Sensor::kBlackLevel, (int32_t)Sensor::kBlackLevel, (int32_t)Sensor::kBlackLevel }; ADD_STATIC_ENTRY(ANDROID_SENSOR_BLACK_LEVEL_PATTERN, blackLevelPattern, sizeof(blackLevelPattern)/sizeof(int32_t)); } if (hasCapability(BACKWARD_COMPATIBLE)) { static const int32_t availableTestPatternModes[] = { ANDROID_SENSOR_TEST_PATTERN_MODE_OFF }; ADD_STATIC_ENTRY(ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES, availableTestPatternModes, sizeof(availableTestPatternModes)/sizeof(int32_t)); } // android.lens static const float focalLength = 3.30f; // mm ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, &focalLength, 1); if (hasCapability(BACKWARD_COMPATIBLE)) { // 5 cm min focus distance for back camera, infinity (fixed focus) for front const float minFocusDistance = mFacingBack ? 1.0/0.05 : 0.0; ADD_STATIC_ENTRY(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, &minFocusDistance, 1); // 5 m hyperfocal distance for back camera, infinity (fixed focus) for front const float hyperFocalDistance = mFacingBack ? 1.0/5.0 : 0.0; ADD_STATIC_ENTRY(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE, &minFocusDistance, 1); static const float aperture = 2.8f; ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_APERTURES, &aperture, 1); static const float filterDensity = 0; ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES, &filterDensity, 1); static const uint8_t availableOpticalStabilization = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF; ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION, &availableOpticalStabilization, 1); static const int32_t lensShadingMapSize[] = {1, 1}; ADD_STATIC_ENTRY(ANDROID_LENS_INFO_SHADING_MAP_SIZE, lensShadingMapSize, sizeof(lensShadingMapSize)/sizeof(int32_t)); static const uint8_t lensFocusCalibration = ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_APPROXIMATE; ADD_STATIC_ENTRY(ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION, &lensFocusCalibration, 1); } if (hasCapability(DEPTH_OUTPUT)) { // These could be included for non-DEPTH capability as well, but making this variable for // testing coverage // 90 degree rotation to align with long edge of a phone device that's by default portrait static const float qO[] = { 0.707107f, 0.f, 0.f, 0.707107f}; // Either a 180-degree rotation for back-facing, or no rotation for front-facing const float qF[] = {0, (mFacingBack ? 1.f : 0.f), 0, (mFacingBack ? 0.f : 1.f)}; // Quarternion product, orientation change then facing const float lensPoseRotation[] = {qO[0]*qF[0] - qO[1]*qF[1] - qO[2]*qF[2] - qO[3]*qF[3], qO[0]*qF[1] + qO[1]*qF[0] + qO[2]*qF[3] - qO[3]*qF[2], qO[0]*qF[2] + qO[2]*qF[0] + qO[1]*qF[3] - qO[3]*qF[1], qO[0]*qF[3] + qO[3]*qF[0] + qO[1]*qF[2] - qO[2]*qF[1]}; ADD_STATIC_ENTRY(ANDROID_LENS_POSE_ROTATION, lensPoseRotation, sizeof(lensPoseRotation)/sizeof(float)); // Only one camera facing each way, so 0 translation needed to the center of the 'main' // camera static const float lensPoseTranslation[] = {0.f, 0.f, 0.f}; ADD_STATIC_ENTRY(ANDROID_LENS_POSE_TRANSLATION, lensPoseTranslation, sizeof(lensPoseTranslation)/sizeof(float)); // Intrinsics are 'ideal' (f_x, f_y, c_x, c_y, s) match focal length and active array size float f_x = focalLength * Sensor::kActiveArray[2] / sensorPhysicalSize[0]; float f_y = focalLength * Sensor::kActiveArray[3] / sensorPhysicalSize[1]; float c_x = Sensor::kActiveArray[2] / 2.f; float c_y = Sensor::kActiveArray[3] / 2.f; float s = 0.f; const float lensIntrinsics[] = { f_x, f_y, c_x, c_y, s }; ADD_STATIC_ENTRY(ANDROID_LENS_INTRINSIC_CALIBRATION, lensIntrinsics, sizeof(lensIntrinsics)/sizeof(float)); // No radial or tangential distortion float lensRadialDistortion[] = {1.0f, 0.f, 0.f, 0.f, 0.f, 0.f}; ADD_STATIC_ENTRY(ANDROID_LENS_RADIAL_DISTORTION, lensRadialDistortion, sizeof(lensRadialDistortion)/sizeof(float)); } static const uint8_t lensFacing = mFacingBack ? ANDROID_LENS_FACING_BACK : ANDROID_LENS_FACING_FRONT; ADD_STATIC_ENTRY(ANDROID_LENS_FACING, &lensFacing, 1); // android.flash static const uint8_t flashAvailable = 0; ADD_STATIC_ENTRY(ANDROID_FLASH_INFO_AVAILABLE, &flashAvailable, 1); // android.tonemap if (hasCapability(MANUAL_POST_PROCESSING)) { static const int32_t tonemapCurvePoints = 128; ADD_STATIC_ENTRY(ANDROID_TONEMAP_MAX_CURVE_POINTS, &tonemapCurvePoints, 1); static const uint8_t availableToneMapModes[] = { ANDROID_TONEMAP_MODE_CONTRAST_CURVE, ANDROID_TONEMAP_MODE_FAST, ANDROID_TONEMAP_MODE_HIGH_QUALITY }; ADD_STATIC_ENTRY(ANDROID_TONEMAP_AVAILABLE_TONE_MAP_MODES, availableToneMapModes, sizeof(availableToneMapModes)); } // android.scaler const std::vector availableStreamConfigurationsBasic = { HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 320, 240, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT, HAL_PIXEL_FORMAT_YCbCr_420_888, 320, 240, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT, HAL_PIXEL_FORMAT_RGBA_8888, 320, 240, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT, HAL_PIXEL_FORMAT_BLOB, 640, 480, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT }; const std::vector availableStreamConfigurationsRaw = { HAL_PIXEL_FORMAT_RAW16, 640, 480, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT }; const std::vector availableStreamConfigurationsBurst = { HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 640, 480, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT, HAL_PIXEL_FORMAT_YCbCr_420_888, 640, 480, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT, HAL_PIXEL_FORMAT_RGBA_8888, 640, 480, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT }; std::vector availableStreamConfigurations; if (hasCapability(BACKWARD_COMPATIBLE)) { availableStreamConfigurations.insert(availableStreamConfigurations.end(), availableStreamConfigurationsBasic.begin(), availableStreamConfigurationsBasic.end()); } if (hasCapability(RAW)) { availableStreamConfigurations.insert(availableStreamConfigurations.end(), availableStreamConfigurationsRaw.begin(), availableStreamConfigurationsRaw.end()); } if (hasCapability(BURST_CAPTURE)) { availableStreamConfigurations.insert(availableStreamConfigurations.end(), availableStreamConfigurationsBurst.begin(), availableStreamConfigurationsBurst.end()); } if (availableStreamConfigurations.size() > 0) { ADD_STATIC_ENTRY(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, &availableStreamConfigurations[0], availableStreamConfigurations.size()); } const std::vector availableMinFrameDurationsBasic = { HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 320, 240, Sensor::kFrameDurationRange[0], HAL_PIXEL_FORMAT_YCbCr_420_888, 320, 240, Sensor::kFrameDurationRange[0], HAL_PIXEL_FORMAT_RGBA_8888, 320, 240, Sensor::kFrameDurationRange[0], HAL_PIXEL_FORMAT_BLOB, 640, 480, Sensor::kFrameDurationRange[0] }; const std::vector availableMinFrameDurationsRaw = { HAL_PIXEL_FORMAT_RAW16, 640, 480, Sensor::kFrameDurationRange[0] }; const std::vector availableMinFrameDurationsBurst = { HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 640, 480, Sensor::kFrameDurationRange[0], HAL_PIXEL_FORMAT_YCbCr_420_888, 640, 480, Sensor::kFrameDurationRange[0], HAL_PIXEL_FORMAT_RGBA_8888, 640, 480, Sensor::kFrameDurationRange[0], }; std::vector availableMinFrameDurations; if (hasCapability(BACKWARD_COMPATIBLE)) { availableMinFrameDurations.insert(availableMinFrameDurations.end(), availableMinFrameDurationsBasic.begin(), availableMinFrameDurationsBasic.end()); } if (hasCapability(RAW)) { availableMinFrameDurations.insert(availableMinFrameDurations.end(), availableMinFrameDurationsRaw.begin(), availableMinFrameDurationsRaw.end()); } if (hasCapability(BURST_CAPTURE)) { availableMinFrameDurations.insert(availableMinFrameDurations.end(), availableMinFrameDurationsBurst.begin(), availableMinFrameDurationsBurst.end()); } if (availableMinFrameDurations.size() > 0) { ADD_STATIC_ENTRY(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS, &availableMinFrameDurations[0], availableMinFrameDurations.size()); } const std::vector availableStallDurationsBasic = { HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 320, 240, 0, HAL_PIXEL_FORMAT_YCbCr_420_888, 320, 240, 0, HAL_PIXEL_FORMAT_RGBA_8888, 320, 240, 0, HAL_PIXEL_FORMAT_BLOB, 640, 480, Sensor::kFrameDurationRange[0] }; const std::vector availableStallDurationsRaw = { HAL_PIXEL_FORMAT_RAW16, 640, 480, Sensor::kFrameDurationRange[0] }; const std::vector availableStallDurationsBurst = { HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 640, 480, 0, HAL_PIXEL_FORMAT_YCbCr_420_888, 640, 480, 0, HAL_PIXEL_FORMAT_RGBA_8888, 640, 480, 0 }; std::vector availableStallDurations; if (hasCapability(BACKWARD_COMPATIBLE)) { availableStallDurations.insert(availableStallDurations.end(), availableStallDurationsBasic.begin(), availableStallDurationsBasic.end()); } if (hasCapability(RAW)) { availableStallDurations.insert(availableStallDurations.end(), availableStallDurationsRaw.begin(), availableStallDurationsRaw.end()); } if (hasCapability(BURST_CAPTURE)) { availableStallDurations.insert(availableStallDurations.end(), availableStallDurationsBurst.begin(), availableStallDurationsBurst.end()); } if (availableStallDurations.size() > 0) { ADD_STATIC_ENTRY(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS, &availableStallDurations[0], availableStallDurations.size()); } if (hasCapability(BACKWARD_COMPATIBLE)) { static const uint8_t croppingType = ANDROID_SCALER_CROPPING_TYPE_FREEFORM; ADD_STATIC_ENTRY(ANDROID_SCALER_CROPPING_TYPE, &croppingType, 1); static const float maxZoom = 10; ADD_STATIC_ENTRY(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM, &maxZoom, 1); } // android.jpeg if (hasCapability(BACKWARD_COMPATIBLE)) { static const int32_t jpegThumbnailSizes[] = { 0, 0, 160, 120, 320, 240 }; ADD_STATIC_ENTRY(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, jpegThumbnailSizes, sizeof(jpegThumbnailSizes)/sizeof(int32_t)); static const int32_t jpegMaxSize = JpegCompressor::kMaxJpegSize; ADD_STATIC_ENTRY(ANDROID_JPEG_MAX_SIZE, &jpegMaxSize, 1); } // android.stats if (hasCapability(BACKWARD_COMPATIBLE)) { static const uint8_t availableFaceDetectModes[] = { ANDROID_STATISTICS_FACE_DETECT_MODE_OFF, ANDROID_STATISTICS_FACE_DETECT_MODE_SIMPLE, ANDROID_STATISTICS_FACE_DETECT_MODE_FULL }; ADD_STATIC_ENTRY(ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES, availableFaceDetectModes, sizeof(availableFaceDetectModes)); static const int32_t maxFaceCount = 8; ADD_STATIC_ENTRY(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT, &maxFaceCount, 1); static const uint8_t availableShadingMapModes[] = { ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF }; ADD_STATIC_ENTRY(ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES, availableShadingMapModes, sizeof(availableShadingMapModes)); } // android.sync static const int32_t maxLatency = hasCapability(FULL_LEVEL) ? ANDROID_SYNC_MAX_LATENCY_PER_FRAME_CONTROL : 3; ADD_STATIC_ENTRY(ANDROID_SYNC_MAX_LATENCY, &maxLatency, 1); // android.control if (hasCapability(BACKWARD_COMPATIBLE)) { static const uint8_t availableControlModes[] = { ANDROID_CONTROL_MODE_OFF, ANDROID_CONTROL_MODE_AUTO, ANDROID_CONTROL_MODE_USE_SCENE_MODE }; ADD_STATIC_ENTRY(ANDROID_CONTROL_AVAILABLE_MODES, availableControlModes, sizeof(availableControlModes)); } else { static const uint8_t availableControlModes[] = { ANDROID_CONTROL_MODE_AUTO }; ADD_STATIC_ENTRY(ANDROID_CONTROL_AVAILABLE_MODES, availableControlModes, sizeof(availableControlModes)); } static const uint8_t availableSceneModes[] = { hasCapability(BACKWARD_COMPATIBLE) ? ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY : ANDROID_CONTROL_SCENE_MODE_DISABLED }; ADD_STATIC_ENTRY(ANDROID_CONTROL_AVAILABLE_SCENE_MODES, availableSceneModes, sizeof(availableSceneModes)); if (hasCapability(BACKWARD_COMPATIBLE)) { static const uint8_t availableEffects[] = { ANDROID_CONTROL_EFFECT_MODE_OFF }; ADD_STATIC_ENTRY(ANDROID_CONTROL_AVAILABLE_EFFECTS, availableEffects, sizeof(availableEffects)); } if (hasCapability(BACKWARD_COMPATIBLE)) { static const int32_t max3aRegions[] = {/*AE*/ 1,/*AWB*/ 0,/*AF*/ 1}; ADD_STATIC_ENTRY(ANDROID_CONTROL_MAX_REGIONS, max3aRegions, sizeof(max3aRegions)/sizeof(max3aRegions[0])); static const uint8_t availableAeModes[] = { ANDROID_CONTROL_AE_MODE_OFF, ANDROID_CONTROL_AE_MODE_ON }; ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_AVAILABLE_MODES, availableAeModes, sizeof(availableAeModes)); static const camera_metadata_rational exposureCompensationStep = { 1, 3 }; ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_COMPENSATION_STEP, &exposureCompensationStep, 1); int32_t exposureCompensationRange[] = {-9, 9}; ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_COMPENSATION_RANGE, exposureCompensationRange, sizeof(exposureCompensationRange)/sizeof(int32_t)); } static const int32_t availableTargetFpsRanges[] = { 5, 30, 15, 30, 15, 15, 30, 30 }; ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, availableTargetFpsRanges, sizeof(availableTargetFpsRanges)/sizeof(int32_t)); if (hasCapability(BACKWARD_COMPATIBLE)) { static const uint8_t availableAntibandingModes[] = { ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF, ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO }; ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES, availableAntibandingModes, sizeof(availableAntibandingModes)); } static const uint8_t aeLockAvailable = hasCapability(BACKWARD_COMPATIBLE) ? ANDROID_CONTROL_AE_LOCK_AVAILABLE_TRUE : ANDROID_CONTROL_AE_LOCK_AVAILABLE_FALSE; ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_LOCK_AVAILABLE, &aeLockAvailable, 1); if (hasCapability(BACKWARD_COMPATIBLE)) { static const uint8_t availableAwbModes[] = { ANDROID_CONTROL_AWB_MODE_OFF, ANDROID_CONTROL_AWB_MODE_AUTO, ANDROID_CONTROL_AWB_MODE_INCANDESCENT, ANDROID_CONTROL_AWB_MODE_FLUORESCENT, ANDROID_CONTROL_AWB_MODE_DAYLIGHT, ANDROID_CONTROL_AWB_MODE_SHADE }; ADD_STATIC_ENTRY(ANDROID_CONTROL_AWB_AVAILABLE_MODES, availableAwbModes, sizeof(availableAwbModes)); } static const uint8_t awbLockAvailable = hasCapability(BACKWARD_COMPATIBLE) ? ANDROID_CONTROL_AWB_LOCK_AVAILABLE_TRUE : ANDROID_CONTROL_AWB_LOCK_AVAILABLE_FALSE; ADD_STATIC_ENTRY(ANDROID_CONTROL_AWB_LOCK_AVAILABLE, &awbLockAvailable, 1); static const uint8_t availableAfModesBack[] = { ANDROID_CONTROL_AF_MODE_OFF, ANDROID_CONTROL_AF_MODE_AUTO, ANDROID_CONTROL_AF_MODE_MACRO, ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO, ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE }; static const uint8_t availableAfModesFront[] = { ANDROID_CONTROL_AF_MODE_OFF }; if (mFacingBack && hasCapability(BACKWARD_COMPATIBLE)) { ADD_STATIC_ENTRY(ANDROID_CONTROL_AF_AVAILABLE_MODES, availableAfModesBack, sizeof(availableAfModesBack)); } else { ADD_STATIC_ENTRY(ANDROID_CONTROL_AF_AVAILABLE_MODES, availableAfModesFront, sizeof(availableAfModesFront)); } static const uint8_t availableVstabModes[] = { ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF }; ADD_STATIC_ENTRY(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES, availableVstabModes, sizeof(availableVstabModes)); // android.colorCorrection if (hasCapability(BACKWARD_COMPATIBLE)) { static const uint8_t availableAberrationModes[] = { ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF, ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST, ANDROID_COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY }; ADD_STATIC_ENTRY(ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES, availableAberrationModes, sizeof(availableAberrationModes)); } else { static const uint8_t availableAberrationModes[] = { ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF, }; ADD_STATIC_ENTRY(ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES, availableAberrationModes, sizeof(availableAberrationModes)); } // android.edge if (hasCapability(BACKWARD_COMPATIBLE)) { static const uint8_t availableEdgeModes[] = { ANDROID_EDGE_MODE_OFF, ANDROID_EDGE_MODE_FAST, ANDROID_EDGE_MODE_HIGH_QUALITY }; ADD_STATIC_ENTRY(ANDROID_EDGE_AVAILABLE_EDGE_MODES, availableEdgeModes, sizeof(availableEdgeModes)); } else { static const uint8_t availableEdgeModes[] = { ANDROID_EDGE_MODE_OFF }; ADD_STATIC_ENTRY(ANDROID_EDGE_AVAILABLE_EDGE_MODES, availableEdgeModes, sizeof(availableEdgeModes)); } // android.info static const uint8_t supportedHardwareLevel = hasCapability(FULL_LEVEL) ? ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_FULL : ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED; ADD_STATIC_ENTRY(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL, &supportedHardwareLevel, /*count*/1); // android.noiseReduction if (hasCapability(BACKWARD_COMPATIBLE)) { static const uint8_t availableNoiseReductionModes[] = { ANDROID_NOISE_REDUCTION_MODE_OFF, ANDROID_NOISE_REDUCTION_MODE_FAST, ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY }; ADD_STATIC_ENTRY(ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES, availableNoiseReductionModes, sizeof(availableNoiseReductionModes)); } else { static const uint8_t availableNoiseReductionModes[] = { ANDROID_NOISE_REDUCTION_MODE_OFF, }; ADD_STATIC_ENTRY(ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES, availableNoiseReductionModes, sizeof(availableNoiseReductionModes)); } // android.depth if (hasCapability(DEPTH_OUTPUT)) { static const int32_t maxDepthSamples = 100; ADD_STATIC_ENTRY(ANDROID_DEPTH_MAX_DEPTH_SAMPLES, &maxDepthSamples, 1); static const int32_t availableDepthStreamConfigurations[] = { HAL_PIXEL_FORMAT_Y16, 160, 120, ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_OUTPUT, HAL_PIXEL_FORMAT_BLOB, maxDepthSamples,1, ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_OUTPUT }; ADD_STATIC_ENTRY(ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS, availableDepthStreamConfigurations, sizeof(availableDepthStreamConfigurations)/sizeof(int32_t)); static const int64_t availableDepthMinFrameDurations[] = { HAL_PIXEL_FORMAT_Y16, 160, 120, Sensor::kFrameDurationRange[0], HAL_PIXEL_FORMAT_BLOB, maxDepthSamples,1, Sensor::kFrameDurationRange[0] }; ADD_STATIC_ENTRY(ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS, availableDepthMinFrameDurations, sizeof(availableDepthMinFrameDurations)/sizeof(int64_t)); static const int64_t availableDepthStallDurations[] = { HAL_PIXEL_FORMAT_Y16, 160, 120, Sensor::kFrameDurationRange[0], HAL_PIXEL_FORMAT_BLOB, maxDepthSamples,1, Sensor::kFrameDurationRange[0] }; ADD_STATIC_ENTRY(ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS, availableDepthStallDurations, sizeof(availableDepthStallDurations)/sizeof(int64_t)); uint8_t depthIsExclusive = ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE_FALSE; ADD_STATIC_ENTRY(ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE, &depthIsExclusive, 1); } // android.shading if (hasCapability(BACKWARD_COMPATIBLE)) { static const uint8_t availableShadingModes[] = { ANDROID_SHADING_MODE_OFF, ANDROID_SHADING_MODE_FAST, ANDROID_SHADING_MODE_HIGH_QUALITY }; ADD_STATIC_ENTRY(ANDROID_SHADING_AVAILABLE_MODES, availableShadingModes, sizeof(availableShadingModes)); } else { static const uint8_t availableShadingModes[] = { ANDROID_SHADING_MODE_OFF }; ADD_STATIC_ENTRY(ANDROID_SHADING_AVAILABLE_MODES, availableShadingModes, sizeof(availableShadingModes)); } // android.request static const int32_t maxNumOutputStreams[] = { kMaxRawStreamCount, kMaxProcessedStreamCount, kMaxJpegStreamCount }; ADD_STATIC_ENTRY(ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS, maxNumOutputStreams, 3); static const uint8_t maxPipelineDepth = kMaxBufferCount; ADD_STATIC_ENTRY(ANDROID_REQUEST_PIPELINE_MAX_DEPTH, &maxPipelineDepth, 1); static const int32_t partialResultCount = 1; ADD_STATIC_ENTRY(ANDROID_REQUEST_PARTIAL_RESULT_COUNT, &partialResultCount, /*count*/1); SortedVector caps; for (size_t i = 0; i < mCapabilities.size(); i++) { switch(mCapabilities[i]) { case BACKWARD_COMPATIBLE: caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE); break; case MANUAL_SENSOR: caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR); break; case MANUAL_POST_PROCESSING: caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING); break; case RAW: caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_RAW); break; case PRIVATE_REPROCESSING: caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING); break; case READ_SENSOR_SETTINGS: caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_READ_SENSOR_SETTINGS); break; case BURST_CAPTURE: caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE); break; case YUV_REPROCESSING: caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_YUV_REPROCESSING); break; case DEPTH_OUTPUT: caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT); break; case CONSTRAINED_HIGH_SPEED_VIDEO: caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_CONSTRAINED_HIGH_SPEED_VIDEO); break; default: // Ignore LEVELs break; } } ADD_STATIC_ENTRY(ANDROID_REQUEST_AVAILABLE_CAPABILITIES, caps.array(), caps.size()); // Scan a default request template for included request keys Vector availableRequestKeys; const camera_metadata_t *previewRequest = constructDefaultRequestSettings(CAMERA3_TEMPLATE_PREVIEW); for (size_t i = 0; i < get_camera_metadata_entry_count(previewRequest); i++) { camera_metadata_ro_entry_t entry; get_camera_metadata_ro_entry(previewRequest, i, &entry); availableRequestKeys.add(entry.tag); } ADD_STATIC_ENTRY(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS, availableRequestKeys.array(), availableRequestKeys.size()); // Add a few more result keys. Must be kept up to date with the various places that add these Vector availableResultKeys(availableRequestKeys); if (hasCapability(BACKWARD_COMPATIBLE)) { availableResultKeys.add(ANDROID_CONTROL_AE_STATE); availableResultKeys.add(ANDROID_CONTROL_AF_STATE); availableResultKeys.add(ANDROID_CONTROL_AWB_STATE); availableResultKeys.add(ANDROID_FLASH_STATE); availableResultKeys.add(ANDROID_LENS_STATE); availableResultKeys.add(ANDROID_LENS_FOCUS_RANGE); availableResultKeys.add(ANDROID_SENSOR_ROLLING_SHUTTER_SKEW); availableResultKeys.add(ANDROID_STATISTICS_SCENE_FLICKER); } if (hasCapability(DEPTH_OUTPUT)) { availableResultKeys.add(ANDROID_LENS_POSE_ROTATION); availableResultKeys.add(ANDROID_LENS_POSE_TRANSLATION); availableResultKeys.add(ANDROID_LENS_INTRINSIC_CALIBRATION); availableResultKeys.add(ANDROID_LENS_RADIAL_DISTORTION); } availableResultKeys.add(ANDROID_REQUEST_PIPELINE_DEPTH); availableResultKeys.add(ANDROID_SENSOR_TIMESTAMP); ADD_STATIC_ENTRY(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS, availableResultKeys.array(), availableResultKeys.size()); // Needs to be last, to collect all the keys set availableCharacteristicsKeys.add(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS); info.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, availableCharacteristicsKeys); mCameraInfo = info.release(); #undef ADD_STATIC_ENTRY return OK; } status_t EmulatedFakeCamera3::process3A(CameraMetadata &settings) { /** * Extract top-level 3A controls */ status_t res; bool facePriority = false; camera_metadata_entry e; e = settings.find(ANDROID_CONTROL_MODE); if (e.count == 0) { ALOGE("%s: No control mode entry!", __FUNCTION__); return BAD_VALUE; } uint8_t controlMode = e.data.u8[0]; if (controlMode == ANDROID_CONTROL_MODE_OFF) { mAeState = ANDROID_CONTROL_AE_STATE_INACTIVE; mAfState = ANDROID_CONTROL_AF_STATE_INACTIVE; mAwbState = ANDROID_CONTROL_AWB_STATE_INACTIVE; update3A(settings); return OK; } else if (controlMode == ANDROID_CONTROL_MODE_USE_SCENE_MODE) { if (!hasCapability(BACKWARD_COMPATIBLE)) { ALOGE("%s: Can't use scene mode when BACKWARD_COMPATIBLE not supported!", __FUNCTION__); return BAD_VALUE; } e = settings.find(ANDROID_CONTROL_SCENE_MODE); if (e.count == 0) { ALOGE("%s: No scene mode entry!", __FUNCTION__); return BAD_VALUE; } uint8_t sceneMode = e.data.u8[0]; switch(sceneMode) { case ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY: mFacePriority = true; break; default: ALOGE("%s: Emulator doesn't support scene mode %d", __FUNCTION__, sceneMode); return BAD_VALUE; } } else { mFacePriority = false; } // controlMode == AUTO or sceneMode = FACE_PRIORITY // Process individual 3A controls res = doFakeAE(settings); if (res != OK) return res; res = doFakeAF(settings); if (res != OK) return res; res = doFakeAWB(settings); if (res != OK) return res; update3A(settings); return OK; } status_t EmulatedFakeCamera3::doFakeAE(CameraMetadata &settings) { camera_metadata_entry e; e = settings.find(ANDROID_CONTROL_AE_MODE); if (e.count == 0 && hasCapability(BACKWARD_COMPATIBLE)) { ALOGE("%s: No AE mode entry!", __FUNCTION__); return BAD_VALUE; } uint8_t aeMode = (e.count > 0) ? e.data.u8[0] : (uint8_t)ANDROID_CONTROL_AE_MODE_ON; switch (aeMode) { case ANDROID_CONTROL_AE_MODE_OFF: // AE is OFF mAeState = ANDROID_CONTROL_AE_STATE_INACTIVE; return OK; case ANDROID_CONTROL_AE_MODE_ON: // OK for AUTO modes break; default: // Mostly silently ignore unsupported modes ALOGV("%s: Emulator doesn't support AE mode %d, assuming ON", __FUNCTION__, aeMode); break; } e = settings.find(ANDROID_CONTROL_AE_LOCK); bool aeLocked = (e.count > 0) ? (e.data.u8[0] == ANDROID_CONTROL_AE_LOCK_ON) : false; e = settings.find(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER); bool precaptureTrigger = false; if (e.count != 0) { precaptureTrigger = (e.data.u8[0] == ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_START); } if (precaptureTrigger) { ALOGV("%s: Pre capture trigger = %d", __FUNCTION__, precaptureTrigger); } else if (e.count > 0) { ALOGV("%s: Pre capture trigger was present? %zu", __FUNCTION__, e.count); } if (precaptureTrigger || mAeState == ANDROID_CONTROL_AE_STATE_PRECAPTURE) { // Run precapture sequence if (mAeState != ANDROID_CONTROL_AE_STATE_PRECAPTURE) { mAeCounter = 0; } if (mFacePriority) { mAeTargetExposureTime = kFacePriorityExposureTime; } else { mAeTargetExposureTime = kNormalExposureTime; } if (mAeCounter > kPrecaptureMinFrames && (mAeTargetExposureTime - mAeCurrentExposureTime) < mAeTargetExposureTime / 10) { // Done with precapture mAeCounter = 0; mAeState = aeLocked ? ANDROID_CONTROL_AE_STATE_LOCKED : ANDROID_CONTROL_AE_STATE_CONVERGED; } else { // Converge some more mAeCurrentExposureTime += (mAeTargetExposureTime - mAeCurrentExposureTime) * kExposureTrackRate; mAeCounter++; mAeState = ANDROID_CONTROL_AE_STATE_PRECAPTURE; } } else if (!aeLocked) { // Run standard occasional AE scan switch (mAeState) { case ANDROID_CONTROL_AE_STATE_CONVERGED: case ANDROID_CONTROL_AE_STATE_INACTIVE: mAeCounter++; if (mAeCounter > kStableAeMaxFrames) { mAeTargetExposureTime = mFacePriority ? kFacePriorityExposureTime : kNormalExposureTime; float exposureStep = ((double)rand() / RAND_MAX) * (kExposureWanderMax - kExposureWanderMin) + kExposureWanderMin; mAeTargetExposureTime *= std::pow(2, exposureStep); mAeState = ANDROID_CONTROL_AE_STATE_SEARCHING; } break; case ANDROID_CONTROL_AE_STATE_SEARCHING: mAeCurrentExposureTime += (mAeTargetExposureTime - mAeCurrentExposureTime) * kExposureTrackRate; if (abs(mAeTargetExposureTime - mAeCurrentExposureTime) < mAeTargetExposureTime / 10) { // Close enough mAeState = ANDROID_CONTROL_AE_STATE_CONVERGED; mAeCounter = 0; } break; case ANDROID_CONTROL_AE_STATE_LOCKED: mAeState = ANDROID_CONTROL_AE_STATE_CONVERGED; mAeCounter = 0; break; default: ALOGE("%s: Emulator in unexpected AE state %d", __FUNCTION__, mAeState); return INVALID_OPERATION; } } else { // AE is locked mAeState = ANDROID_CONTROL_AE_STATE_LOCKED; } return OK; } status_t EmulatedFakeCamera3::doFakeAF(CameraMetadata &settings) { camera_metadata_entry e; e = settings.find(ANDROID_CONTROL_AF_MODE); if (e.count == 0 && hasCapability(BACKWARD_COMPATIBLE)) { ALOGE("%s: No AF mode entry!", __FUNCTION__); return BAD_VALUE; } uint8_t afMode = (e.count > 0) ? e.data.u8[0] : (uint8_t)ANDROID_CONTROL_AF_MODE_OFF; e = settings.find(ANDROID_CONTROL_AF_TRIGGER); typedef camera_metadata_enum_android_control_af_trigger af_trigger_t; af_trigger_t afTrigger; if (e.count != 0) { afTrigger = static_cast(e.data.u8[0]); ALOGV("%s: AF trigger set to 0x%x", __FUNCTION__, afTrigger); ALOGV("%s: AF mode is 0x%x", __FUNCTION__, afMode); } else { afTrigger = ANDROID_CONTROL_AF_TRIGGER_IDLE; } switch (afMode) { case ANDROID_CONTROL_AF_MODE_OFF: mAfState = ANDROID_CONTROL_AF_STATE_INACTIVE; return OK; case ANDROID_CONTROL_AF_MODE_AUTO: case ANDROID_CONTROL_AF_MODE_MACRO: case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: if (!mFacingBack) { ALOGE("%s: Front camera doesn't support AF mode %d", __FUNCTION__, afMode); return BAD_VALUE; } // OK, handle transitions lower on break; default: ALOGE("%s: Emulator doesn't support AF mode %d", __FUNCTION__, afMode); return BAD_VALUE; } bool afModeChanged = mAfMode != afMode; mAfMode = afMode; /** * Simulate AF triggers. Transition at most 1 state per frame. * - Focusing always succeeds (goes into locked, or PASSIVE_SCAN). */ bool afTriggerStart = false; bool afTriggerCancel = false; switch (afTrigger) { case ANDROID_CONTROL_AF_TRIGGER_IDLE: break; case ANDROID_CONTROL_AF_TRIGGER_START: afTriggerStart = true; break; case ANDROID_CONTROL_AF_TRIGGER_CANCEL: afTriggerCancel = true; // Cancel trigger always transitions into INACTIVE mAfState = ANDROID_CONTROL_AF_STATE_INACTIVE; ALOGV("%s: AF State transition to STATE_INACTIVE", __FUNCTION__); // Stay in 'inactive' until at least next frame return OK; default: ALOGE("%s: Unknown af trigger value %d", __FUNCTION__, afTrigger); return BAD_VALUE; } // If we get down here, we're either in an autofocus mode // or in a continuous focus mode (and no other modes) int oldAfState = mAfState; switch (mAfState) { case ANDROID_CONTROL_AF_STATE_INACTIVE: if (afTriggerStart) { switch (afMode) { case ANDROID_CONTROL_AF_MODE_AUTO: // fall-through case ANDROID_CONTROL_AF_MODE_MACRO: mAfState = ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN; break; case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: // fall-through case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: mAfState = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED; break; } } else { // At least one frame stays in INACTIVE if (!afModeChanged) { switch (afMode) { case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: // fall-through case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: mAfState = ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN; break; } } } break; case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN: /** * When the AF trigger is activated, the algorithm should finish * its PASSIVE_SCAN if active, and then transition into AF_FOCUSED * or AF_NOT_FOCUSED as appropriate */ if (afTriggerStart) { // Randomly transition to focused or not focused if (rand() % 3) { mAfState = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED; } else { mAfState = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED; } } /** * When the AF trigger is not involved, the AF algorithm should * start in INACTIVE state, and then transition into PASSIVE_SCAN * and PASSIVE_FOCUSED states */ else if (!afTriggerCancel) { // Randomly transition to passive focus if (rand() % 3 == 0) { mAfState = ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED; } } break; case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED: if (afTriggerStart) { // Randomly transition to focused or not focused if (rand() % 3) { mAfState = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED; } else { mAfState = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED; } } // TODO: initiate passive scan (PASSIVE_SCAN) break; case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN: // Simulate AF sweep completing instantaneously // Randomly transition to focused or not focused if (rand() % 3) { mAfState = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED; } else { mAfState = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED; } break; case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED: if (afTriggerStart) { switch (afMode) { case ANDROID_CONTROL_AF_MODE_AUTO: // fall-through case ANDROID_CONTROL_AF_MODE_MACRO: mAfState = ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN; break; case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: // fall-through case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: // continuous autofocus => trigger start has no effect break; } } break; case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: if (afTriggerStart) { switch (afMode) { case ANDROID_CONTROL_AF_MODE_AUTO: // fall-through case ANDROID_CONTROL_AF_MODE_MACRO: mAfState = ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN; break; case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: // fall-through case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: // continuous autofocus => trigger start has no effect break; } } break; default: ALOGE("%s: Bad af state %d", __FUNCTION__, mAfState); } { char afStateString[100] = {0,}; camera_metadata_enum_snprint(ANDROID_CONTROL_AF_STATE, oldAfState, afStateString, sizeof(afStateString)); char afNewStateString[100] = {0,}; camera_metadata_enum_snprint(ANDROID_CONTROL_AF_STATE, mAfState, afNewStateString, sizeof(afNewStateString)); ALOGVV("%s: AF state transitioned from %s to %s", __FUNCTION__, afStateString, afNewStateString); } return OK; } status_t EmulatedFakeCamera3::doFakeAWB(CameraMetadata &settings) { camera_metadata_entry e; e = settings.find(ANDROID_CONTROL_AWB_MODE); if (e.count == 0 && hasCapability(BACKWARD_COMPATIBLE)) { ALOGE("%s: No AWB mode entry!", __FUNCTION__); return BAD_VALUE; } uint8_t awbMode = (e.count > 0) ? e.data.u8[0] : (uint8_t)ANDROID_CONTROL_AWB_MODE_AUTO; // TODO: Add white balance simulation switch (awbMode) { case ANDROID_CONTROL_AWB_MODE_OFF: mAwbState = ANDROID_CONTROL_AWB_STATE_INACTIVE; return OK; case ANDROID_CONTROL_AWB_MODE_AUTO: case ANDROID_CONTROL_AWB_MODE_INCANDESCENT: case ANDROID_CONTROL_AWB_MODE_FLUORESCENT: case ANDROID_CONTROL_AWB_MODE_DAYLIGHT: case ANDROID_CONTROL_AWB_MODE_SHADE: // OK break; default: ALOGE("%s: Emulator doesn't support AWB mode %d", __FUNCTION__, awbMode); return BAD_VALUE; } return OK; } void EmulatedFakeCamera3::update3A(CameraMetadata &settings) { if (mAeMode != ANDROID_CONTROL_AE_MODE_OFF) { settings.update(ANDROID_SENSOR_EXPOSURE_TIME, &mAeCurrentExposureTime, 1); settings.update(ANDROID_SENSOR_SENSITIVITY, &mAeCurrentSensitivity, 1); } settings.update(ANDROID_CONTROL_AE_STATE, &mAeState, 1); settings.update(ANDROID_CONTROL_AF_STATE, &mAfState, 1); settings.update(ANDROID_CONTROL_AWB_STATE, &mAwbState, 1); uint8_t lensState; switch (mAfState) { case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN: case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN: lensState = ANDROID_LENS_STATE_MOVING; break; case ANDROID_CONTROL_AF_STATE_INACTIVE: case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED: case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED: case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED: default: lensState = ANDROID_LENS_STATE_STATIONARY; break; } settings.update(ANDROID_LENS_STATE, &lensState, 1); } void EmulatedFakeCamera3::signalReadoutIdle() { Mutex::Autolock l(mLock); // Need to chek isIdle again because waiting on mLock may have allowed // something to be placed in the in-flight queue. if (mStatus == STATUS_ACTIVE && mReadoutThread->isIdle()) { ALOGV("Now idle"); mStatus = STATUS_READY; } } void EmulatedFakeCamera3::onSensorEvent(uint32_t frameNumber, Event e, nsecs_t timestamp) { switch(e) { case Sensor::SensorListener::EXPOSURE_START: { ALOGVV("%s: Frame %d: Sensor started exposure at %lld", __FUNCTION__, frameNumber, timestamp); // Trigger shutter notify to framework camera3_notify_msg_t msg; msg.type = CAMERA3_MSG_SHUTTER; msg.message.shutter.frame_number = frameNumber; msg.message.shutter.timestamp = timestamp; sendNotify(&msg); break; } default: ALOGW("%s: Unexpected sensor event %d at %" PRId64, __FUNCTION__, e, timestamp); break; } } EmulatedFakeCamera3::ReadoutThread::ReadoutThread(EmulatedFakeCamera3 *parent) : mParent(parent), mJpegWaiting(false) { } EmulatedFakeCamera3::ReadoutThread::~ReadoutThread() { for (List::iterator i = mInFlightQueue.begin(); i != mInFlightQueue.end(); i++) { delete i->buffers; delete i->sensorBuffers; } } void EmulatedFakeCamera3::ReadoutThread::queueCaptureRequest(const Request &r) { Mutex::Autolock l(mLock); mInFlightQueue.push_back(r); mInFlightSignal.signal(); } bool EmulatedFakeCamera3::ReadoutThread::isIdle() { Mutex::Autolock l(mLock); return mInFlightQueue.empty() && !mThreadActive; } status_t EmulatedFakeCamera3::ReadoutThread::waitForReadout() { status_t res; Mutex::Autolock l(mLock); int loopCount = 0; while (mInFlightQueue.size() >= kMaxQueueSize) { res = mInFlightSignal.waitRelative(mLock, kWaitPerLoop); if (res != OK && res != TIMED_OUT) { ALOGE("%s: Error waiting for in-flight queue to shrink", __FUNCTION__); return INVALID_OPERATION; } if (loopCount == kMaxWaitLoops) { ALOGE("%s: Timed out waiting for in-flight queue to shrink", __FUNCTION__); return TIMED_OUT; } loopCount++; } return OK; } bool EmulatedFakeCamera3::ReadoutThread::threadLoop() { status_t res; ALOGVV("%s: ReadoutThread waiting for request", __FUNCTION__); // First wait for a request from the in-flight queue if (mCurrentRequest.settings.isEmpty()) { Mutex::Autolock l(mLock); if (mInFlightQueue.empty()) { res = mInFlightSignal.waitRelative(mLock, kWaitPerLoop); if (res == TIMED_OUT) { ALOGVV("%s: ReadoutThread: Timed out waiting for request", __FUNCTION__); return true; } else if (res != NO_ERROR) { ALOGE("%s: Error waiting for capture requests: %d", __FUNCTION__, res); return false; } } mCurrentRequest.frameNumber = mInFlightQueue.begin()->frameNumber; mCurrentRequest.settings.acquire(mInFlightQueue.begin()->settings); mCurrentRequest.buffers = mInFlightQueue.begin()->buffers; mCurrentRequest.sensorBuffers = mInFlightQueue.begin()->sensorBuffers; mInFlightQueue.erase(mInFlightQueue.begin()); mInFlightSignal.signal(); mThreadActive = true; ALOGVV("%s: Beginning readout of frame %d", __FUNCTION__, mCurrentRequest.frameNumber); } // Then wait for it to be delivered from the sensor ALOGVV("%s: ReadoutThread: Wait for frame to be delivered from sensor", __FUNCTION__); nsecs_t captureTime; bool gotFrame = mParent->mSensor->waitForNewFrame(kWaitPerLoop, &captureTime); if (!gotFrame) { ALOGVV("%s: ReadoutThread: Timed out waiting for sensor frame", __FUNCTION__); return true; } ALOGVV("Sensor done with readout for frame %d, captured at %lld ", mCurrentRequest.frameNumber, captureTime); // Check if we need to JPEG encode a buffer, and send it for async // compression if so. Otherwise prepare the buffer for return. bool needJpeg = false; HalBufferVector::iterator buf = mCurrentRequest.buffers->begin(); while(buf != mCurrentRequest.buffers->end()) { bool goodBuffer = true; if ( buf->stream->format == HAL_PIXEL_FORMAT_BLOB && buf->stream->data_space != HAL_DATASPACE_DEPTH) { Mutex::Autolock jl(mJpegLock); if (mJpegWaiting) { // This shouldn't happen, because processCaptureRequest should // be stalling until JPEG compressor is free. ALOGE("%s: Already processing a JPEG!", __FUNCTION__); goodBuffer = false; } if (goodBuffer) { // Compressor takes ownership of sensorBuffers here res = mParent->mJpegCompressor->start(mCurrentRequest.sensorBuffers, this); goodBuffer = (res == OK); } if (goodBuffer) { needJpeg = true; mJpegHalBuffer = *buf; mJpegFrameNumber = mCurrentRequest.frameNumber; mJpegWaiting = true; mCurrentRequest.sensorBuffers = NULL; buf = mCurrentRequest.buffers->erase(buf); continue; } ALOGE("%s: Error compressing output buffer: %s (%d)", __FUNCTION__, strerror(-res), res); // fallthrough for cleanup } GraphicBufferMapper::get().unlock(*(buf->buffer)); buf->status = goodBuffer ? CAMERA3_BUFFER_STATUS_OK : CAMERA3_BUFFER_STATUS_ERROR; buf->acquire_fence = -1; buf->release_fence = -1; ++buf; } // end while // Construct result for all completed buffers and results camera3_capture_result result; if (mParent->hasCapability(BACKWARD_COMPATIBLE)) { static const uint8_t sceneFlicker = ANDROID_STATISTICS_SCENE_FLICKER_NONE; mCurrentRequest.settings.update(ANDROID_STATISTICS_SCENE_FLICKER, &sceneFlicker, 1); static const uint8_t flashState = ANDROID_FLASH_STATE_UNAVAILABLE; mCurrentRequest.settings.update(ANDROID_FLASH_STATE, &flashState, 1); nsecs_t rollingShutterSkew = Sensor::kFrameDurationRange[0]; mCurrentRequest.settings.update(ANDROID_SENSOR_ROLLING_SHUTTER_SKEW, &rollingShutterSkew, 1); float focusRange[] = { 1.0f/5.0f, 0 }; // 5 m to infinity in focus mCurrentRequest.settings.update(ANDROID_LENS_FOCUS_RANGE, focusRange, sizeof(focusRange)/sizeof(float)); } if (mParent->hasCapability(DEPTH_OUTPUT)) { camera_metadata_entry_t entry; find_camera_metadata_entry(mParent->mCameraInfo, ANDROID_LENS_POSE_TRANSLATION, &entry); mCurrentRequest.settings.update(ANDROID_LENS_POSE_TRANSLATION, entry.data.f, entry.count); find_camera_metadata_entry(mParent->mCameraInfo, ANDROID_LENS_POSE_ROTATION, &entry); mCurrentRequest.settings.update(ANDROID_LENS_POSE_ROTATION, entry.data.f, entry.count); find_camera_metadata_entry(mParent->mCameraInfo, ANDROID_LENS_INTRINSIC_CALIBRATION, &entry); mCurrentRequest.settings.update(ANDROID_LENS_INTRINSIC_CALIBRATION, entry.data.f, entry.count); find_camera_metadata_entry(mParent->mCameraInfo, ANDROID_LENS_RADIAL_DISTORTION, &entry); mCurrentRequest.settings.update(ANDROID_LENS_RADIAL_DISTORTION, entry.data.f, entry.count); } mCurrentRequest.settings.update(ANDROID_SENSOR_TIMESTAMP, &captureTime, 1); // JPEGs take a stage longer const uint8_t pipelineDepth = needJpeg ? kMaxBufferCount : kMaxBufferCount - 1; mCurrentRequest.settings.update(ANDROID_REQUEST_PIPELINE_DEPTH, &pipelineDepth, 1); result.frame_number = mCurrentRequest.frameNumber; result.result = mCurrentRequest.settings.getAndLock(); result.num_output_buffers = mCurrentRequest.buffers->size(); result.output_buffers = mCurrentRequest.buffers->array(); result.input_buffer = nullptr; result.partial_result = 1; // Go idle if queue is empty, before sending result bool signalIdle = false; { Mutex::Autolock l(mLock); if (mInFlightQueue.empty()) { mThreadActive = false; signalIdle = true; } } if (signalIdle) mParent->signalReadoutIdle(); // Send it off to the framework ALOGVV("%s: ReadoutThread: Send result to framework", __FUNCTION__); mParent->sendCaptureResult(&result); // Clean up mCurrentRequest.settings.unlock(result.result); delete mCurrentRequest.buffers; mCurrentRequest.buffers = NULL; if (!needJpeg) { delete mCurrentRequest.sensorBuffers; mCurrentRequest.sensorBuffers = NULL; } mCurrentRequest.settings.clear(); return true; } void EmulatedFakeCamera3::ReadoutThread::onJpegDone( const StreamBuffer &jpegBuffer, bool success) { Mutex::Autolock jl(mJpegLock); GraphicBufferMapper::get().unlock(*(jpegBuffer.buffer)); mJpegHalBuffer.status = success ? CAMERA3_BUFFER_STATUS_OK : CAMERA3_BUFFER_STATUS_ERROR; mJpegHalBuffer.acquire_fence = -1; mJpegHalBuffer.release_fence = -1; mJpegWaiting = false; camera3_capture_result result; result.frame_number = mJpegFrameNumber; result.result = NULL; result.num_output_buffers = 1; result.output_buffers = &mJpegHalBuffer; if (!success) { ALOGE("%s: Compression failure, returning error state buffer to" " framework", __FUNCTION__); } else { ALOGV("%s: Compression complete, returning buffer to framework", __FUNCTION__); } mParent->sendCaptureResult(&result); } void EmulatedFakeCamera3::ReadoutThread::onJpegInputDone( const StreamBuffer &inputBuffer) { // Should never get here, since the input buffer has to be returned // by end of processCaptureRequest ALOGE("%s: Unexpected input buffer from JPEG compressor!", __FUNCTION__); } }; // namespace android anbox-0.0~git20191115/android/camera/EmulatedFakeCamera3.h000066400000000000000000000225271356361734700230010ustar00rootroot00000000000000/* * Copyright (C) 2013 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA3_H #define HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA3_H /** * Contains declaration of a class EmulatedCamera that encapsulates * functionality of a fake camera that implements version 3 of the camera device * interace. */ #include "EmulatedCamera3.h" #include "fake-pipeline2/Base.h" #include "fake-pipeline2/Sensor.h" #include "fake-pipeline2/JpegCompressor.h" #include #include #include #include namespace android { /** * Encapsulates functionality for a v3 HAL camera which produces synthetic data. * * Note that EmulatedCameraFactory instantiates an object of this class just * once, when EmulatedCameraFactory instance gets constructed. Connection to / * disconnection from the actual camera device is handled by calls to * connectDevice(), and closeCamera() methods of this class that are invoked in * response to hw_module_methods_t::open, and camera_device::close callbacks. */ class EmulatedFakeCamera3 : public EmulatedCamera3, private Sensor::SensorListener { public: EmulatedFakeCamera3(int cameraId, bool facingBack, struct hw_module_t* module); virtual ~EmulatedFakeCamera3(); /**************************************************************************** * EmulatedCamera3 virtual overrides ***************************************************************************/ public: virtual status_t Initialize(); /**************************************************************************** * Camera module API and generic hardware device API implementation ***************************************************************************/ public: virtual status_t connectCamera(hw_device_t** device); virtual status_t closeCamera(); virtual status_t getCameraInfo(struct camera_info *info); /**************************************************************************** * EmulatedCamera3 abstract API implementation ***************************************************************************/ protected: virtual status_t configureStreams( camera3_stream_configuration *streamList); virtual status_t registerStreamBuffers( const camera3_stream_buffer_set *bufferSet) ; virtual const camera_metadata_t* constructDefaultRequestSettings( int type); virtual status_t processCaptureRequest(camera3_capture_request *request); virtual status_t flush(); /** Debug methods */ virtual void dump(int fd); private: /** * Get the requested capability set for this camera */ status_t getCameraCapabilities(); bool hasCapability(AvailableCapabilities cap); /** * Build the static info metadata buffer for this device */ status_t constructStaticInfo(); /** * Run the fake 3A algorithms as needed. May override/modify settings * values. */ status_t process3A(CameraMetadata &settings); status_t doFakeAE(CameraMetadata &settings); status_t doFakeAF(CameraMetadata &settings); status_t doFakeAWB(CameraMetadata &settings); void update3A(CameraMetadata &settings); /** Signal from readout thread that it doesn't have anything to do */ void signalReadoutIdle(); /** Handle interrupt events from the sensor */ void onSensorEvent(uint32_t frameNumber, Event e, nsecs_t timestamp); /**************************************************************************** * Static configuration information ***************************************************************************/ private: static const uint32_t kMaxRawStreamCount = 1; static const uint32_t kMaxProcessedStreamCount = 3; static const uint32_t kMaxJpegStreamCount = 1; static const uint32_t kMaxReprocessStreamCount = 2; static const uint32_t kMaxBufferCount = 4; // We need a positive stream ID to distinguish external buffers from // sensor-generated buffers which use a nonpositive ID. Otherwise, HAL3 has // no concept of a stream id. static const uint32_t kGenericStreamId = 1; static const int32_t kAvailableFormats[]; static const int64_t kSyncWaitTimeout = 10000000; // 10 ms static const int32_t kMaxSyncTimeoutCount = 1000; // 1000 kSyncWaitTimeouts static const uint32_t kFenceTimeoutMs = 2000; // 2 s /**************************************************************************** * Data members. ***************************************************************************/ /* HAL interface serialization lock. */ Mutex mLock; /* Facing back (true) or front (false) switch. */ bool mFacingBack; SortedVector mCapabilities; /** * Cache for default templates. Once one is requested, the pointer must be * valid at least until close() is called on the device */ camera_metadata_t *mDefaultTemplates[CAMERA3_TEMPLATE_COUNT]; /** * Private stream information, stored in camera3_stream_t->priv. */ struct PrivateStreamInfo { bool alive; }; // Shortcut to the input stream camera3_stream_t* mInputStream; typedef List StreamList; typedef List::iterator StreamIterator; typedef Vector HalBufferVector; // All streams, including input stream StreamList mStreams; // Cached settings from latest submitted request CameraMetadata mPrevSettings; /** Fake hardware interfaces */ sp mSensor; sp mJpegCompressor; friend class JpegCompressor; /** Processing thread for sending out results */ class ReadoutThread : public Thread, private JpegCompressor::JpegListener { public: ReadoutThread(EmulatedFakeCamera3 *parent); ~ReadoutThread(); struct Request { uint32_t frameNumber; CameraMetadata settings; HalBufferVector *buffers; Buffers *sensorBuffers; }; /** * Interface to parent class */ // Place request in the in-flight queue to wait for sensor capture void queueCaptureRequest(const Request &r); // Test if the readout thread is idle (no in-flight requests, not // currently reading out anything bool isIdle(); // Wait until isIdle is true status_t waitForReadout(); private: static const nsecs_t kWaitPerLoop = 10000000L; // 10 ms static const nsecs_t kMaxWaitLoops = 1000; static const size_t kMaxQueueSize = 2; EmulatedFakeCamera3 *mParent; Mutex mLock; List mInFlightQueue; Condition mInFlightSignal; bool mThreadActive; virtual bool threadLoop(); // Only accessed by threadLoop Request mCurrentRequest; // Jpeg completion callbacks Mutex mJpegLock; bool mJpegWaiting; camera3_stream_buffer mJpegHalBuffer; uint32_t mJpegFrameNumber; virtual void onJpegDone(const StreamBuffer &jpegBuffer, bool success); virtual void onJpegInputDone(const StreamBuffer &inputBuffer); }; sp mReadoutThread; /** Fake 3A constants */ static const nsecs_t kNormalExposureTime; static const nsecs_t kFacePriorityExposureTime; static const int kNormalSensitivity; static const int kFacePrioritySensitivity; // Rate of converging AE to new target value, as fraction of difference between // current and target value. static const float kExposureTrackRate; // Minimum duration for precapture state. May be longer if slow to converge // to target exposure static const int kPrecaptureMinFrames; // How often to restart AE 'scanning' static const int kStableAeMaxFrames; // Maximum stop below 'normal' exposure time that we'll wander to while // pretending to converge AE. In powers of 2. (-2 == 1/4 as bright) static const float kExposureWanderMin; // Maximum stop above 'normal' exposure time that we'll wander to while // pretending to converge AE. In powers of 2. (2 == 4x as bright) static const float kExposureWanderMax; /** Fake 3A state */ uint8_t mControlMode; bool mFacePriority; uint8_t mAeState; uint8_t mAfState; uint8_t mAwbState; uint8_t mAeMode; uint8_t mAfMode; uint8_t mAwbMode; int mAeCounter; nsecs_t mAeCurrentExposureTime; nsecs_t mAeTargetExposureTime; int mAeCurrentSensitivity; }; } // namespace android #endif // HW_EMULATOR_CAMERA_EMULATED_CAMERA3_H anbox-0.0~git20191115/android/camera/EmulatedFakeCameraDevice.cpp000077500000000000000000000324541356361734700243740ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * Contains implementation of a class EmulatedFakeCameraDevice that encapsulates * fake camera device. */ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_FakeDevice" #include #include "EmulatedFakeCamera.h" #include "EmulatedFakeCameraDevice.h" namespace android { EmulatedFakeCameraDevice::EmulatedFakeCameraDevice(EmulatedFakeCamera* camera_hal) : EmulatedCameraDevice(camera_hal), mBlackYUV(kBlack32), mWhiteYUV(kWhite32), mRedYUV(kRed8), mGreenYUV(kGreen8), mBlueYUV(kBlue8), mLastRedrawn(0), mCheckX(0), mCheckY(0), mCcounter(0) #if EFCD_ROTATE_FRAME , mLastRotatedAt(0), mCurrentFrameType(0), mCurrentColor(&mWhiteYUV) #endif // EFCD_ROTATE_FRAME { // Makes the image with the original exposure compensation darker. // So the effects of changing the exposure compensation can be seen. mBlackYUV.Y = mBlackYUV.Y / 2; mWhiteYUV.Y = mWhiteYUV.Y / 2; mRedYUV.Y = mRedYUV.Y / 2; mGreenYUV.Y = mGreenYUV.Y / 2; mBlueYUV.Y = mBlueYUV.Y / 2; } EmulatedFakeCameraDevice::~EmulatedFakeCameraDevice() { } /**************************************************************************** * Emulated camera device abstract interface implementation. ***************************************************************************/ status_t EmulatedFakeCameraDevice::connectDevice() { ALOGV("%s", __FUNCTION__); Mutex::Autolock locker(&mObjectLock); if (!isInitialized()) { ALOGE("%s: Fake camera device is not initialized.", __FUNCTION__); return EINVAL; } if (isConnected()) { ALOGW("%s: Fake camera device is already connected.", __FUNCTION__); return NO_ERROR; } /* There is no device to connect to. */ mState = ECDS_CONNECTED; return NO_ERROR; } status_t EmulatedFakeCameraDevice::disconnectDevice() { ALOGV("%s", __FUNCTION__); Mutex::Autolock locker(&mObjectLock); if (!isConnected()) { ALOGW("%s: Fake camera device is already disconnected.", __FUNCTION__); return NO_ERROR; } if (isStarted()) { ALOGE("%s: Cannot disconnect from the started device.", __FUNCTION__); return EINVAL; } /* There is no device to disconnect from. */ mState = ECDS_INITIALIZED; return NO_ERROR; } status_t EmulatedFakeCameraDevice::startDevice(int width, int height, uint32_t pix_fmt) { ALOGV("%s", __FUNCTION__); Mutex::Autolock locker(&mObjectLock); if (!isConnected()) { ALOGE("%s: Fake camera device is not connected.", __FUNCTION__); return EINVAL; } if (isStarted()) { ALOGE("%s: Fake camera device is already started.", __FUNCTION__); return EINVAL; } /* Initialize the base class. */ const status_t res = EmulatedCameraDevice::commonStartDevice(width, height, pix_fmt); if (res == NO_ERROR) { /* Calculate U/V panes inside the framebuffer. */ switch (mPixelFormat) { case V4L2_PIX_FMT_YVU420: mFrameV = mCurrentFrame + mTotalPixels; mFrameU = mFrameU + mTotalPixels / 4; mUVStep = 1; mUVTotalNum = mTotalPixels / 4; break; case V4L2_PIX_FMT_YUV420: mFrameU = mCurrentFrame + mTotalPixels; mFrameV = mFrameU + mTotalPixels / 4; mUVStep = 1; mUVTotalNum = mTotalPixels / 4; break; case V4L2_PIX_FMT_NV21: /* Interleaved UV pane, V first. */ mFrameV = mCurrentFrame + mTotalPixels; mFrameU = mFrameV + 1; mUVStep = 2; mUVTotalNum = mTotalPixels / 4; break; case V4L2_PIX_FMT_NV12: /* Interleaved UV pane, U first. */ mFrameU = mCurrentFrame + mTotalPixels; mFrameV = mFrameU + 1; mUVStep = 2; mUVTotalNum = mTotalPixels / 4; break; default: ALOGE("%s: Unknown pixel format %.4s", __FUNCTION__, reinterpret_cast(&mPixelFormat)); return EINVAL; } /* Number of items in a single row inside U/V panes. */ mUVInRow = (width / 2) * mUVStep; mState = ECDS_STARTED; } else { ALOGE("%s: commonStartDevice failed", __FUNCTION__); } return res; } status_t EmulatedFakeCameraDevice::stopDevice() { ALOGV("%s", __FUNCTION__); Mutex::Autolock locker(&mObjectLock); if (!isStarted()) { ALOGW("%s: Fake camera device is not started.", __FUNCTION__); return NO_ERROR; } mFrameU = mFrameV = NULL; EmulatedCameraDevice::commonStopDevice(); mState = ECDS_CONNECTED; return NO_ERROR; } /**************************************************************************** * Worker thread management overrides. ***************************************************************************/ bool EmulatedFakeCameraDevice::inWorkerThread() { /* Wait till FPS timeout expires, or thread exit message is received. */ WorkerThread::SelectRes res = getWorkerThread()->Select(-1, 1000000 / mEmulatedFPS); if (res == WorkerThread::EXIT_THREAD) { ALOGV("%s: Worker thread has been terminated.", __FUNCTION__); return false; } /* Lets see if we need to generate a new frame. */ if ((systemTime(SYSTEM_TIME_MONOTONIC) - mLastRedrawn) >= mRedrawAfter) { /* * Time to generate a new frame. */ #if EFCD_ROTATE_FRAME const int frame_type = rotateFrame(); switch (frame_type) { case 0: drawCheckerboard(); break; case 1: drawStripes(); break; case 2: drawSolid(mCurrentColor); break; } #else /* Draw the checker board. */ drawCheckerboard(); #endif // EFCD_ROTATE_FRAME mLastRedrawn = systemTime(SYSTEM_TIME_MONOTONIC); } /* Timestamp the current frame, and notify the camera HAL about new frame. */ mCurFrameTimestamp = systemTime(SYSTEM_TIME_MONOTONIC); mCameraHAL->onNextFrameAvailable(mCurrentFrame, mCurFrameTimestamp, this); return true; } /**************************************************************************** * Fake camera device private API ***************************************************************************/ void EmulatedFakeCameraDevice::drawCheckerboard() { const int size = mFrameWidth / 10; bool black = true; if (size == 0) { // When this happens, it happens at a very high rate, // so don't log any messages and just return. return; } if((mCheckX / size) & 1) black = false; if((mCheckY / size) & 1) black = !black; int county = mCheckY % size; int checkxremainder = mCheckX % size; uint8_t* Y = mCurrentFrame; uint8_t* U_pos = mFrameU; uint8_t* V_pos = mFrameV; uint8_t* U = U_pos; uint8_t* V = V_pos; YUVPixel adjustedWhite = YUVPixel(mWhiteYUV); changeWhiteBalance(adjustedWhite.Y, adjustedWhite.U, adjustedWhite.V); for(int y = 0; y < mFrameHeight; y++) { int countx = checkxremainder; bool current = black; for(int x = 0; x < mFrameWidth; x += 2) { if (current) { mBlackYUV.get(Y, U, V); } else { adjustedWhite.get(Y, U, V); } *Y = changeExposure(*Y); Y[1] = *Y; Y += 2; U += mUVStep; V += mUVStep; countx += 2; if(countx >= size) { countx = 0; current = !current; } } if (y & 0x1) { U_pos = U; V_pos = V; } else { U = U_pos; V = V_pos; } if(county++ >= size) { county = 0; black = !black; } } mCheckX += 3; mCheckY++; /* Run the square. */ int sqx = ((mCcounter * 3) & 255); if(sqx > 128) sqx = 255 - sqx; int sqy = ((mCcounter * 5) & 255); if(sqy > 128) sqy = 255 - sqy; const int sqsize = mFrameWidth / 10; drawSquare(sqx * sqsize / 32, sqy * sqsize / 32, (sqsize * 5) >> 1, (mCcounter & 0x100) ? &mRedYUV : &mGreenYUV); mCcounter++; } void EmulatedFakeCameraDevice::drawSquare(int x, int y, int size, const YUVPixel* color) { const int square_xstop = min(mFrameWidth, x + size); const int square_ystop = min(mFrameHeight, y + size); uint8_t* Y_pos = mCurrentFrame + y * mFrameWidth + x; YUVPixel adjustedColor = *color; changeWhiteBalance(adjustedColor.Y, adjustedColor.U, adjustedColor.V); // Draw the square. for (; y < square_ystop; y++) { const int iUV = (y / 2) * mUVInRow + (x / 2) * mUVStep; uint8_t* sqU = mFrameU + iUV; uint8_t* sqV = mFrameV + iUV; uint8_t* sqY = Y_pos; for (int i = x; i < square_xstop; i += 2) { adjustedColor.get(sqY, sqU, sqV); *sqY = changeExposure(*sqY); sqY[1] = *sqY; sqY += 2; sqU += mUVStep; sqV += mUVStep; } Y_pos += mFrameWidth; } } #if EFCD_ROTATE_FRAME void EmulatedFakeCameraDevice::drawSolid(YUVPixel* color) { YUVPixel adjustedColor = *color; changeWhiteBalance(adjustedColor.Y, adjustedColor.U, adjustedColor.V); /* All Ys are the same. */ memset(mCurrentFrame, changeExposure(adjustedColor.Y), mTotalPixels); /* Fill U, and V panes. */ uint8_t* U = mFrameU; uint8_t* V = mFrameV; for (int k = 0; k < mUVTotalNum; k++, U += mUVStep, V += mUVStep) { *U = color->U; *V = color->V; } } void EmulatedFakeCameraDevice::drawStripes() { /* Divide frame into 4 stripes. */ const int change_color_at = mFrameHeight / 4; const int each_in_row = mUVInRow / mUVStep; uint8_t* pY = mCurrentFrame; for (int y = 0; y < mFrameHeight; y++, pY += mFrameWidth) { /* Select the color. */ YUVPixel* color; const int color_index = y / change_color_at; if (color_index == 0) { /* White stripe on top. */ color = &mWhiteYUV; } else if (color_index == 1) { /* Then the red stripe. */ color = &mRedYUV; } else if (color_index == 2) { /* Then the green stripe. */ color = &mGreenYUV; } else { /* And the blue stripe at the bottom. */ color = &mBlueYUV; } changeWhiteBalance(color->Y, color->U, color->V); /* All Ys at the row are the same. */ memset(pY, changeExposure(color->Y), mFrameWidth); /* Offset of the current row inside U/V panes. */ const int uv_off = (y / 2) * mUVInRow; /* Fill U, and V panes. */ uint8_t* U = mFrameU + uv_off; uint8_t* V = mFrameV + uv_off; for (int k = 0; k < each_in_row; k++, U += mUVStep, V += mUVStep) { *U = color->U; *V = color->V; } } } int EmulatedFakeCameraDevice::rotateFrame() { if ((systemTime(SYSTEM_TIME_MONOTONIC) - mLastRotatedAt) >= mRotateFreq) { mLastRotatedAt = systemTime(SYSTEM_TIME_MONOTONIC); mCurrentFrameType++; if (mCurrentFrameType > 2) { mCurrentFrameType = 0; } if (mCurrentFrameType == 2) { ALOGD("********** Rotated to the SOLID COLOR frame **********"); /* Solid color: lets rotate color too. */ if (mCurrentColor == &mWhiteYUV) { ALOGD("----- Painting a solid RED frame -----"); mCurrentColor = &mRedYUV; } else if (mCurrentColor == &mRedYUV) { ALOGD("----- Painting a solid GREEN frame -----"); mCurrentColor = &mGreenYUV; } else if (mCurrentColor == &mGreenYUV) { ALOGD("----- Painting a solid BLUE frame -----"); mCurrentColor = &mBlueYUV; } else { /* Back to white. */ ALOGD("----- Painting a solid WHITE frame -----"); mCurrentColor = &mWhiteYUV; } } else if (mCurrentFrameType == 0) { ALOGD("********** Rotated to the CHECKERBOARD frame **********"); } else if (mCurrentFrameType == 1) { ALOGD("********** Rotated to the STRIPED frame **********"); } } return mCurrentFrameType; } #endif // EFCD_ROTATE_FRAME }; /* namespace android */ anbox-0.0~git20191115/android/camera/EmulatedFakeCameraDevice.h000077500000000000000000000152161356361734700240360ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA_DEVICE_H #define HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA_DEVICE_H /* * Contains declaration of a class EmulatedFakeCameraDevice that encapsulates * a fake camera device. */ #include "Converters.h" #include "EmulatedCameraDevice.h" /* This is used for debugging format / conversion issues. If EFCD_ROTATE_FRAME is * set to 0, the frame content will be always the "checkerboard". Otherwise, if * EFCD_ROTATE_FRAME is set to a non-zero value, the frame content will "rotate" * from a "checkerboard" frame to a "white/red/green/blue stripes" frame, to a * "white/red/green/blue" frame. Frame content rotation helps finding bugs in * format conversions. */ #define EFCD_ROTATE_FRAME 0 namespace android { class EmulatedFakeCamera; /* Encapsulates a fake camera device. * Fake camera device emulates a camera device by providing frames containing * a black and white checker board, moving diagonally towards the 0,0 corner. * There is also a green, or red square that bounces inside the frame, changing * its color when bouncing off the 0,0 corner. */ class EmulatedFakeCameraDevice : public EmulatedCameraDevice { public: /* Constructs EmulatedFakeCameraDevice instance. */ explicit EmulatedFakeCameraDevice(EmulatedFakeCamera* camera_hal); /* Destructs EmulatedFakeCameraDevice instance. */ ~EmulatedFakeCameraDevice(); /*************************************************************************** * Emulated camera device abstract interface implementation. * See declarations of these methods in EmulatedCameraDevice class for * information on each of these methods. **************************************************************************/ public: /* Connects to the camera device. * Since there is no real device to connect to, this method does nothing, * but changes the state. */ status_t connectDevice(); /* Disconnects from the camera device. * Since there is no real device to disconnect from, this method does * nothing, but changes the state. */ status_t disconnectDevice(); /* Starts the camera device. */ status_t startDevice(int width, int height, uint32_t pix_fmt); /* Stops the camera device. */ status_t stopDevice(); /* Gets current preview fame into provided buffer. */ status_t getPreviewFrame(void* buffer); /*************************************************************************** * Worker thread management overrides. * See declarations of these methods in EmulatedCameraDevice class for * information on each of these methods. **************************************************************************/ protected: /* Implementation of the worker thread routine. * This method simply sleeps for a period of time defined by the FPS property * of the fake camera (simulating frame frequency), and then calls emulated * camera's onNextFrameAvailable method. */ bool inWorkerThread(); /**************************************************************************** * Fake camera device private API ***************************************************************************/ private: /* Draws a black and white checker board in the current frame buffer. */ void drawCheckerboard(); /* Draws a square of the given color in the current frame buffer. * Param: * x, y - Coordinates of the top left corner of the square in the buffer. * size - Size of the square's side. * color - Square's color. */ void drawSquare(int x, int y, int size, const YUVPixel* color); #if EFCD_ROTATE_FRAME void drawSolid(YUVPixel* color); void drawStripes(); int rotateFrame(); #endif // EFCD_ROTATE_FRAME /**************************************************************************** * Fake camera device data members ***************************************************************************/ private: /* * Pixel colors in YUV format used when drawing the checker board. */ YUVPixel mBlackYUV; YUVPixel mWhiteYUV; YUVPixel mRedYUV; YUVPixel mGreenYUV; YUVPixel mBlueYUV; /* Last time the frame has been redrawn. */ nsecs_t mLastRedrawn; /* * Precalculated values related to U/V panes. */ /* U pane inside the framebuffer. */ uint8_t* mFrameU; /* V pane inside the framebuffer. */ uint8_t* mFrameV; /* Defines byte distance between adjacent U, and V values. */ int mUVStep; /* Defines number of Us and Vs in a row inside the U/V panes. * Note that if U/V panes are interleaved, this value reflects the total * number of both, Us and Vs in a single row in the interleaved UV pane. */ int mUVInRow; /* Total number of each, U, and V elements in the framebuffer. */ int mUVTotalNum; /* * Checkerboard drawing related stuff */ int mCheckX; int mCheckY; int mCcounter; /* Emulated FPS (frames per second). * We will emulate 50 FPS. */ static const int mEmulatedFPS = 50; /* Defines time (in nanoseconds) between redrawing the checker board. * We will redraw the checker board every 15 milliseconds. */ static const nsecs_t mRedrawAfter = 15000000LL; #if EFCD_ROTATE_FRAME /* Frame rotation frequency in nanosec (currently - 3 sec) */ static const nsecs_t mRotateFreq = 3000000000LL; /* Last time the frame has rotated. */ nsecs_t mLastRotatedAt; /* Type of the frame to display in the current rotation: * 0 - Checkerboard. * 1 - White/Red/Green/Blue horisontal stripes * 2 - Solid color. */ int mCurrentFrameType; /* Color to use to paint the solid color frame. Colors will rotate between * white, red, gree, and blue each time rotation comes to the solid color * frame. */ YUVPixel* mCurrentColor; #endif // EFCD_ROTATE_FRAME }; }; /* namespace android */ #endif /* HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA_DEVICE_H */ anbox-0.0~git20191115/android/camera/EmulatedQemuCamera.cpp000077500000000000000000000072111356361734700233060ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * Contains implementation of a class EmulatedQemuCamera that encapsulates * functionality of an emulated camera connected to the host. */ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_QemuCamera" #include #include "EmulatedQemuCamera.h" #include "EmulatedCameraFactory.h" namespace android { EmulatedQemuCamera::EmulatedQemuCamera(int cameraId, struct hw_module_t* module) : EmulatedCamera(cameraId, module), mQemuCameraDevice(this) { } EmulatedQemuCamera::~EmulatedQemuCamera() { } /**************************************************************************** * EmulatedCamera virtual overrides. ***************************************************************************/ status_t EmulatedQemuCamera::Initialize(const char* device_name, const char* frame_dims, const char* facing_dir) { ALOGV("%s:\n Name=%s\n Facing '%s'\n Dimensions=%s", __FUNCTION__, device_name, facing_dir, frame_dims); /* Save dimensions. */ mFrameDims = frame_dims; /* Initialize camera device. */ status_t res = mQemuCameraDevice.Initialize(device_name); if (res != NO_ERROR) { return res; } /* Initialize base class. */ res = EmulatedCamera::Initialize(); if (res != NO_ERROR) { return res; } /* * Set customizable parameters. */ mParameters.set(EmulatedCamera::FACING_KEY, facing_dir); mParameters.set(EmulatedCamera::ORIENTATION_KEY, gEmulatedCameraFactory.getQemuCameraOrientation()); mParameters.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, frame_dims); mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, frame_dims); /* * Use first dimension reported by the device to set current preview and * picture sizes. */ char first_dim[128]; /* Dimensions are separated with ',' */ const char* c = strchr(frame_dims, ','); if (c == NULL) { strncpy(first_dim, frame_dims, sizeof(first_dim)); first_dim[sizeof(first_dim)-1] = '\0'; } else if (static_cast(c - frame_dims) < sizeof(first_dim)) { memcpy(first_dim, frame_dims, c - frame_dims); first_dim[c - frame_dims] = '\0'; } else { memcpy(first_dim, frame_dims, sizeof(first_dim)); first_dim[sizeof(first_dim)-1] = '\0'; } /* Width and height are separated with 'x' */ char* sep = strchr(first_dim, 'x'); if (sep == NULL) { ALOGE("%s: Invalid first dimension format in %s", __FUNCTION__, frame_dims); return EINVAL; } *sep = '\0'; const int x = atoi(first_dim); const int y = atoi(sep + 1); mParameters.setPreviewSize(x, y); mParameters.setPictureSize(x, y); ALOGV("%s: Qemu camera %s is initialized. Current frame is %dx%d", __FUNCTION__, device_name, x, y); return NO_ERROR; } EmulatedCameraDevice* EmulatedQemuCamera::getCameraDevice() { return &mQemuCameraDevice; } }; /* namespace android */ anbox-0.0~git20191115/android/camera/EmulatedQemuCamera.h000077500000000000000000000047701356361734700227620ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef HW_EMULATOR_CAMERA_EMULATED_QEMU_CAMERA_H #define HW_EMULATOR_CAMERA_EMULATED_QEMU_CAMERA_H /* * Contains declaration of a class EmulatedQemuCamera that encapsulates * functionality of an emulated camera connected to the host. */ #include "EmulatedCamera.h" #include "EmulatedQemuCameraDevice.h" namespace android { /* Encapsulates functionality of an emulated camera connected to the host. */ class EmulatedQemuCamera : public EmulatedCamera { public: /* Constructs EmulatedQemuCamera instance. */ EmulatedQemuCamera(int cameraId, struct hw_module_t* module); /* Destructs EmulatedQemuCamera instance. */ ~EmulatedQemuCamera(); /*************************************************************************** * EmulatedCamera virtual overrides. **************************************************************************/ public: /* Initializes EmulatedQemuCamera instance. */ status_t Initialize(const char* device_name, const char* frame_dims, const char* facing_dir); /*************************************************************************** * EmulatedCamera abstract API implementation. **************************************************************************/ protected: /* Gets emulated camera device ised by this instance of the emulated camera. */ EmulatedCameraDevice* getCameraDevice(); /*************************************************************************** * Data memebers. **************************************************************************/ protected: /* Contained qemu camera device object. */ EmulatedQemuCameraDevice mQemuCameraDevice; /* Supported frame dimensions reported by the camera device. */ String8 mFrameDims; }; }; /* namespace android */ #endif /* HW_EMULATOR_CAMERA_EMULATED_QEMU_CAMERA_H */ anbox-0.0~git20191115/android/camera/EmulatedQemuCamera2.cpp000066400000000000000000000031721356361734700233670ustar00rootroot00000000000000/* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * Contains implementation of a class EmulatedQemuCamera2 that encapsulates * functionality of a host webcam with further processing to simulate the * capabilities of a v2 camera device. */ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_QemuCamera2" #include #include #include "EmulatedQemuCamera2.h" #include "EmulatedCameraFactory.h" namespace android { EmulatedQemuCamera2::EmulatedQemuCamera2(int cameraId, bool facingBack, struct hw_module_t* module) : EmulatedCamera2(cameraId,module), mFacingBack(facingBack) { ALOGD("Constructing emulated qemu camera 2 facing %s", facingBack ? "back" : "front"); } EmulatedQemuCamera2::~EmulatedQemuCamera2() { } /**************************************************************************** * Public API overrides ***************************************************************************/ status_t EmulatedQemuCamera2::Initialize() { return NO_ERROR; } }; /* namespace android */ anbox-0.0~git20191115/android/camera/EmulatedQemuCamera2.h000066400000000000000000000043101356361734700230270ustar00rootroot00000000000000/* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef HW_EMULATOR_CAMERA_EMULATED_QEMU_CAMERA2_H #define HW_EMULATOR_CAMERA_EMULATED_QEMU_CAMERA2_H /* * Contains declaration of a class EmulatedQemuCamera2 that encapsulates * functionality of a host webcam with added processing to implement version 2 * of the camera device interface. */ #include "EmulatedCamera2.h" namespace android { /* Encapsulates functionality of an advanced fake camera based on real host camera data. */ class EmulatedQemuCamera2 : public EmulatedCamera2 { public: /* Constructs EmulatedFakeCamera instance. */ EmulatedQemuCamera2(int cameraId, bool facingBack, struct hw_module_t* module); /* Destructs EmulatedFakeCamera instance. */ ~EmulatedQemuCamera2(); /**************************************************************************** * EmulatedCamera2 virtual overrides. ***************************************************************************/ public: /* Initializes EmulatedQemuCamera2 instance. */ status_t Initialize(); /**************************************************************************** * EmulatedCamera abstract API implementation. ***************************************************************************/ protected: /**************************************************************************** * Data memebers. ***************************************************************************/ protected: /* Facing back (true) or front (false) switch. */ bool mFacingBack; }; }; /* namespace android */ #endif /* HW_EMULATOR_CAMERA_EMULATED_QEMU_CAMERA2_H */ anbox-0.0~git20191115/android/camera/EmulatedQemuCameraDevice.cpp000077500000000000000000000212631356361734700244310ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * Contains implementation of a class EmulatedQemuCameraDevice that encapsulates * an emulated camera device connected to the host. */ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_QemuDevice" #include #include "EmulatedQemuCamera.h" #include "EmulatedQemuCameraDevice.h" namespace android { EmulatedQemuCameraDevice::EmulatedQemuCameraDevice(EmulatedQemuCamera* camera_hal) : EmulatedCameraDevice(camera_hal), mQemuClient(), mPreviewFrame(NULL) { } EmulatedQemuCameraDevice::~EmulatedQemuCameraDevice() { if (mPreviewFrame != NULL) { delete[] mPreviewFrame; } } /**************************************************************************** * Public API ***************************************************************************/ status_t EmulatedQemuCameraDevice::Initialize(const char* device_name) { /* Connect to the service. */ char connect_str[256]; snprintf(connect_str, sizeof(connect_str), "name=%s", device_name); status_t res = mQemuClient.connectClient(connect_str); if (res != NO_ERROR) { return res; } /* Initialize base class. */ res = EmulatedCameraDevice::Initialize(); if (res == NO_ERROR) { ALOGV("%s: Connected to the emulated camera service '%s'", __FUNCTION__, device_name); mDeviceName = device_name; } else { mQemuClient.queryDisconnect(); } return res; } /**************************************************************************** * Emulated camera device abstract interface implementation. ***************************************************************************/ status_t EmulatedQemuCameraDevice::connectDevice() { ALOGV("%s", __FUNCTION__); Mutex::Autolock locker(&mObjectLock); if (!isInitialized()) { ALOGE("%s: Qemu camera device is not initialized.", __FUNCTION__); return EINVAL; } if (isConnected()) { ALOGW("%s: Qemu camera device '%s' is already connected.", __FUNCTION__, (const char*)mDeviceName); return NO_ERROR; } /* Connect to the camera device via emulator. */ const status_t res = mQemuClient.queryConnect(); if (res == NO_ERROR) { ALOGV("%s: Connected to device '%s'", __FUNCTION__, (const char*)mDeviceName); mState = ECDS_CONNECTED; } else { ALOGE("%s: Connection to device '%s' failed", __FUNCTION__, (const char*)mDeviceName); } return res; } status_t EmulatedQemuCameraDevice::disconnectDevice() { ALOGV("%s", __FUNCTION__); Mutex::Autolock locker(&mObjectLock); if (!isConnected()) { ALOGW("%s: Qemu camera device '%s' is already disconnected.", __FUNCTION__, (const char*)mDeviceName); return NO_ERROR; } if (isStarted()) { ALOGE("%s: Cannot disconnect from the started device '%s.", __FUNCTION__, (const char*)mDeviceName); return EINVAL; } /* Disconnect from the camera device via emulator. */ const status_t res = mQemuClient.queryDisconnect(); if (res == NO_ERROR) { ALOGV("%s: Disonnected from device '%s'", __FUNCTION__, (const char*)mDeviceName); mState = ECDS_INITIALIZED; } else { ALOGE("%s: Disconnection from device '%s' failed", __FUNCTION__, (const char*)mDeviceName); } return res; } status_t EmulatedQemuCameraDevice::startDevice(int width, int height, uint32_t pix_fmt) { ALOGV("%s", __FUNCTION__); Mutex::Autolock locker(&mObjectLock); if (!isConnected()) { ALOGE("%s: Qemu camera device '%s' is not connected.", __FUNCTION__, (const char*)mDeviceName); return EINVAL; } if (isStarted()) { ALOGW("%s: Qemu camera device '%s' is already started.", __FUNCTION__, (const char*)mDeviceName); return NO_ERROR; } status_t res = EmulatedCameraDevice::commonStartDevice(width, height, pix_fmt); if (res != NO_ERROR) { ALOGE("%s: commonStartDevice failed", __FUNCTION__); return res; } /* Allocate preview frame buffer. */ /* TODO: Watch out for preview format changes! At this point we implement * RGB32 only.*/ mPreviewFrame = new uint32_t[mTotalPixels]; if (mPreviewFrame == NULL) { ALOGE("%s: Unable to allocate %d bytes for preview frame", __FUNCTION__, mTotalPixels); return ENOMEM; } /* Start the actual camera device. */ res = mQemuClient.queryStart(mPixelFormat, mFrameWidth, mFrameHeight); if (res == NO_ERROR) { ALOGV("%s: Qemu camera device '%s' is started for %.4s[%dx%d] frames", __FUNCTION__, (const char*)mDeviceName, reinterpret_cast(&mPixelFormat), mFrameWidth, mFrameHeight); mState = ECDS_STARTED; } else { ALOGE("%s: Unable to start device '%s' for %.4s[%dx%d] frames", __FUNCTION__, (const char*)mDeviceName, reinterpret_cast(&pix_fmt), width, height); } return res; } status_t EmulatedQemuCameraDevice::stopDevice() { ALOGV("%s", __FUNCTION__); Mutex::Autolock locker(&mObjectLock); if (!isStarted()) { ALOGW("%s: Qemu camera device '%s' is not started.", __FUNCTION__, (const char*)mDeviceName); return NO_ERROR; } /* Stop the actual camera device. */ status_t res = mQemuClient.queryStop(); if (res == NO_ERROR) { if (mPreviewFrame == NULL) { delete[] mPreviewFrame; mPreviewFrame = NULL; } EmulatedCameraDevice::commonStopDevice(); mState = ECDS_CONNECTED; ALOGV("%s: Qemu camera device '%s' is stopped", __FUNCTION__, (const char*)mDeviceName); } else { ALOGE("%s: Unable to stop device '%s'", __FUNCTION__, (const char*)mDeviceName); } return res; } /**************************************************************************** * EmulatedCameraDevice virtual overrides ***************************************************************************/ status_t EmulatedQemuCameraDevice::getCurrentPreviewFrame(void* buffer) { ALOGW_IF(mPreviewFrame == NULL, "%s: No preview frame", __FUNCTION__); if (mPreviewFrame != NULL) { memcpy(buffer, mPreviewFrame, mTotalPixels * 4); return 0; } else { return EmulatedCameraDevice::getCurrentPreviewFrame(buffer); } } /**************************************************************************** * Worker thread management overrides. ***************************************************************************/ bool EmulatedQemuCameraDevice::inWorkerThread() { /* Wait till FPS timeout expires, or thread exit message is received. */ WorkerThread::SelectRes res = getWorkerThread()->Select(-1, 1000000 / mEmulatedFPS); if (res == WorkerThread::EXIT_THREAD) { ALOGV("%s: Worker thread has been terminated.", __FUNCTION__); return false; } /* Query frames from the service. */ status_t query_res = mQemuClient.queryFrame(mCurrentFrame, mPreviewFrame, mFrameBufferSize, mTotalPixels * 4, mWhiteBalanceScale[0], mWhiteBalanceScale[1], mWhiteBalanceScale[2], mExposureCompensation); if (query_res == NO_ERROR) { /* Timestamp the current frame, and notify the camera HAL. */ mCurFrameTimestamp = systemTime(SYSTEM_TIME_MONOTONIC); mCameraHAL->onNextFrameAvailable(mCurrentFrame, mCurFrameTimestamp, this); return true; } else { ALOGE("%s: Unable to get current video frame: %s", __FUNCTION__, strerror(query_res)); mCameraHAL->onCameraDeviceError(CAMERA_ERROR_SERVER_DIED); return false; } } }; /* namespace android */ anbox-0.0~git20191115/android/camera/EmulatedQemuCameraDevice.h000077500000000000000000000105061356361734700240740ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef HW_EMULATOR_CAMERA_EMULATED_QEMU_CAMERA_DEVICE_H #define HW_EMULATOR_CAMERA_EMULATED_QEMU_CAMERA_DEVICE_H /* * Contains declaration of a class EmulatedQemuCameraDevice that encapsulates * an emulated camera device connected to the host. */ #include "EmulatedCameraDevice.h" #include "QemuClient.h" namespace android { class EmulatedQemuCamera; /* Encapsulates an emulated camera device connected to the host. */ class EmulatedQemuCameraDevice : public EmulatedCameraDevice { public: /* Constructs EmulatedQemuCameraDevice instance. */ explicit EmulatedQemuCameraDevice(EmulatedQemuCamera* camera_hal); /* Destructs EmulatedQemuCameraDevice instance. */ ~EmulatedQemuCameraDevice(); /*************************************************************************** * Public API **************************************************************************/ public: /* Initializes EmulatedQemuCameraDevice instance. * Param: * device_name - Name of the camera device connected to the host. The name * that is used here must have been reported by the 'factory' camera * service when it listed camera devices connected to the host. * Return: * NO_ERROR on success, or an appropriate error status. */ status_t Initialize(const char* device_name); /*************************************************************************** * Emulated camera device abstract interface implementation. * See declarations of these methods in EmulatedCameraDevice class for * information on each of these methods. **************************************************************************/ public: /* Connects to the camera device. */ status_t connectDevice(); /* Disconnects from the camera device. */ status_t disconnectDevice(); /* Starts capturing frames from the camera device. */ status_t startDevice(int width, int height, uint32_t pix_fmt); /* Stops capturing frames from the camera device. */ status_t stopDevice(); /*************************************************************************** * EmulatedCameraDevice virtual overrides * See declarations of these methods in EmulatedCameraDevice class for * information on each of these methods. **************************************************************************/ public: /* Gets current preview fame into provided buffer. * We override this method in order to provide preview frames cached in this * object. */ status_t getCurrentPreviewFrame(void* buffer); /*************************************************************************** * Worker thread management overrides. * See declarations of these methods in EmulatedCameraDevice class for * information on each of these methods. **************************************************************************/ protected: /* Implementation of the worker thread routine. */ bool inWorkerThread(); /*************************************************************************** * Qemu camera device data members **************************************************************************/ private: /* Qemu client that is used to communicate with the 'emulated camera' * service, created for this instance in the emulator. */ CameraQemuClient mQemuClient; /* Name of the camera device connected to the host. */ String8 mDeviceName; /* Current preview framebuffer. */ uint32_t* mPreviewFrame; /* Emulated FPS (frames per second). * We will emulate 50 FPS. */ static const int mEmulatedFPS = 50; }; }; /* namespace android */ #endif /* HW_EMULATOR_CAMERA_EMULATED_QEMU_CAMERA_DEVICE_H */ anbox-0.0~git20191115/android/camera/JpegCompressor.cpp000066400000000000000000000055101356361734700225440ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * Contains implementation of a class NV21JpegCompressor that encapsulates a * converter between NV21, and JPEG formats. */ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_JPEG" #include #include #include #include "JpegCompressor.h" namespace android { void* NV21JpegCompressor::mDl = NULL; static void* getSymbol(void* dl, const char* signature) { void* res = dlsym(dl, signature); assert (res != NULL); return res; } typedef void (*InitFunc)(JpegStub* stub, int* strides); typedef void (*CleanupFunc)(JpegStub* stub); typedef int (*CompressFunc)(JpegStub* stub, const void* image, int width, int height, int quality); typedef void (*GetCompressedImageFunc)(JpegStub* stub, void* buff); typedef size_t (*GetCompressedSizeFunc)(JpegStub* stub); NV21JpegCompressor::NV21JpegCompressor() { const char dlName[] = "/system/lib/hw/camera.goldfish.jpeg.so"; if (mDl == NULL) { mDl = dlopen(dlName, RTLD_NOW); } assert(mDl != NULL); InitFunc f = (InitFunc)getSymbol(mDl, "JpegStub_init"); (*f)(&mStub, mStrides); } NV21JpegCompressor::~NV21JpegCompressor() { CleanupFunc f = (CleanupFunc)getSymbol(mDl, "JpegStub_cleanup"); (*f)(&mStub); } /**************************************************************************** * Public API ***************************************************************************/ status_t NV21JpegCompressor::compressRawImage(const void* image, int width, int height, int quality) { mStrides[0] = width; mStrides[1] = width; CompressFunc f = (CompressFunc)getSymbol(mDl, "JpegStub_compress"); return (status_t)(*f)(&mStub, image, width, height, quality); } size_t NV21JpegCompressor::getCompressedSize() { GetCompressedSizeFunc f = (GetCompressedSizeFunc)getSymbol(mDl, "JpegStub_getCompressedSize"); return (*f)(&mStub); } void NV21JpegCompressor::getCompressedImage(void* buff) { GetCompressedImageFunc f = (GetCompressedImageFunc)getSymbol(mDl, "JpegStub_getCompressedImage"); (*f)(&mStub, buff); } }; /* namespace android */ anbox-0.0~git20191115/android/camera/JpegCompressor.h000066400000000000000000000057441356361734700222220ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef HW_EMULATOR_CAMERA_JPEG_COMPRESSOR_H #define HW_EMULATOR_CAMERA_JPEG_COMPRESSOR_H /* * Contains declaration of a class NV21JpegCompressor that encapsulates a * converter between YV21, and JPEG formats. */ #include "JpegStub.h" #include namespace android { /* Encapsulates a converter between YV12, and JPEG formats. */ class NV21JpegCompressor { public: /* Constructs JpegCompressor instance. */ NV21JpegCompressor(); /* Destructs JpegCompressor instance. */ ~NV21JpegCompressor(); /**************************************************************************** * Public API ***************************************************************************/ public: /* Compresses raw NV21 image into a JPEG. * The compressed image will be saved in mStream member of this class. Use * getCompressedSize method to obtain buffer size of the compressed image, * and getCompressedImage to copy out the compressed image. * Param: * image - Raw NV21 image. * width, height - Image dimensions. * quality - JPEG quality. * Return: * NO_ERROR on success, or an appropriate error status. * */ status_t compressRawImage(const void* image, int width, int height, int quality); /* Get size of the compressed JPEG buffer. * This method must be called only after a successful completion of * compressRawImage call. * Return: * Size of the compressed JPEG buffer. */ size_t getCompressedSize(); /* Copies out compressed JPEG buffer. * This method must be called only after a successful completion of * compressRawImage call. * Param: * buff - Buffer where to copy the JPEG. Must be large enough to contain the * entire image. */ void getCompressedImage(void* buff); /**************************************************************************** * Class data ***************************************************************************/ protected: /* Strides for Y (the first element), and UV (the second one) panes. */ int mStrides[2]; private: // library handle to dlopen static void* mDl; JpegStub mStub; }; }; /* namespace android */ #endif /* HW_EMULATOR_CAMERA_JPEG_COMPRESSOR_H */ anbox-0.0~git20191115/android/camera/JpegStub.cpp000066400000000000000000000044411356361734700213270ustar00rootroot00000000000000/* * Copyright (C) 2013 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_JPEGStub" #include #include #include #include "JpegStub.h" extern "C" void JpegStub_init(JpegStub* stub, int* strides) { stub->mInternalEncoder = (void*) new Yuv420SpToJpegEncoder(strides); stub->mInternalStream = (void*)new SkDynamicMemoryWStream(); } extern "C" void JpegStub_cleanup(JpegStub* stub) { delete((Yuv420SpToJpegEncoder*)stub->mInternalEncoder); delete((SkDynamicMemoryWStream*)stub->mInternalStream); } extern "C" int JpegStub_compress(JpegStub* stub, const void* image, int width, int height, int quality) { void* pY = const_cast(image); int offsets[2]; offsets[0] = 0; offsets[1] = width * height; Yuv420SpToJpegEncoder* encoder = (Yuv420SpToJpegEncoder*)stub->mInternalEncoder; SkDynamicMemoryWStream* stream = (SkDynamicMemoryWStream*)stub->mInternalStream; if (encoder->encode(stream, pY, width, height, offsets, quality)) { ALOGV("%s: Compressed JPEG: %d[%dx%d] -> %zu bytes", __FUNCTION__, (width * height * 12) / 8, width, height, stream->getOffset()); return 0; } else { ALOGE("%s: JPEG compression failed", __FUNCTION__); return errno ? errno: EINVAL; } } extern "C" void JpegStub_getCompressedImage(JpegStub* stub, void* buff) { SkDynamicMemoryWStream* stream = (SkDynamicMemoryWStream*)stub->mInternalStream; stream->copyTo(buff); } extern "C" size_t JpegStub_getCompressedSize(JpegStub* stub) { SkDynamicMemoryWStream* stream = (SkDynamicMemoryWStream*)stub->mInternalStream; return stream->getOffset(); } anbox-0.0~git20191115/android/camera/JpegStub.h000066400000000000000000000020731356361734700207730ustar00rootroot00000000000000/* * Copyright (C) 2013 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef JPEGSTUB_H_ #define JPEGSTUB_H_ extern "C" { struct JpegStub { void* mInternalEncoder; void* mInternalStream; }; void JpegStub_init(JpegStub* stub, int* strides); void JpegStub_cleanup(JpegStub* stub); int JpegStub_compress(JpegStub* stub, const void* image, int width, int height, int quality); void JpegStub_getCompressedImage(JpegStub* stub, void* buff); size_t JpegStub_getCompressedSize(JpegStub* stub); }; #endif // JPEGSTUB_H_ anbox-0.0~git20191115/android/camera/PreviewWindow.cpp000077500000000000000000000160741356361734700224250ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * Contains implementation of a class PreviewWindow that encapsulates * functionality of a preview window set via set_preview_window camera HAL API. */ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_Preview" #include #include #include #include "EmulatedCameraDevice.h" #include "PreviewWindow.h" namespace android { PreviewWindow::PreviewWindow() : mPreviewWindow(NULL), mLastPreviewed(0), mPreviewFrameWidth(0), mPreviewFrameHeight(0), mPreviewEnabled(false) { } PreviewWindow::~PreviewWindow() { } /**************************************************************************** * Camera API ***************************************************************************/ status_t PreviewWindow::setPreviewWindow(struct preview_stream_ops* window, int preview_fps) { ALOGV("%s: current: %p -> new: %p", __FUNCTION__, mPreviewWindow, window); status_t res = NO_ERROR; Mutex::Autolock locker(&mObjectLock); /* Reset preview info. */ mPreviewFrameWidth = mPreviewFrameHeight = 0; mPreviewAfter = 0; mLastPreviewed = 0; if (window != NULL) { /* The CPU will write each frame to the preview window buffer. * Note that we delay setting preview window buffer geometry until * frames start to come in. */ res = window->set_usage(window, GRALLOC_USAGE_SW_WRITE_OFTEN); if (res == NO_ERROR) { /* Set preview frequency. */ mPreviewAfter = 1000000 / preview_fps; } else { window = NULL; res = -res; // set_usage returns a negative errno. ALOGE("%s: Error setting preview window usage %d -> %s", __FUNCTION__, res, strerror(res)); } } mPreviewWindow = window; return res; } status_t PreviewWindow::startPreview() { ALOGV("%s", __FUNCTION__); Mutex::Autolock locker(&mObjectLock); mPreviewEnabled = true; return NO_ERROR; } void PreviewWindow::stopPreview() { ALOGV("%s", __FUNCTION__); Mutex::Autolock locker(&mObjectLock); mPreviewEnabled = false; } /**************************************************************************** * Public API ***************************************************************************/ void PreviewWindow::onNextFrameAvailable(const void* frame, nsecs_t timestamp, EmulatedCameraDevice* camera_dev) { int res; Mutex::Autolock locker(&mObjectLock); if (!isPreviewEnabled() || mPreviewWindow == NULL || !isPreviewTime()) { return; } /* Make sure that preview window dimensions are OK with the camera device */ if (adjustPreviewDimensions(camera_dev)) { /* Need to set / adjust buffer geometry for the preview window. * Note that in the emulator preview window uses only RGB for pixel * formats. */ ALOGV("%s: Adjusting preview windows %p geometry to %dx%d", __FUNCTION__, mPreviewWindow, mPreviewFrameWidth, mPreviewFrameHeight); res = mPreviewWindow->set_buffers_geometry(mPreviewWindow, mPreviewFrameWidth, mPreviewFrameHeight, HAL_PIXEL_FORMAT_RGBA_8888); if (res != NO_ERROR) { ALOGE("%s: Error in set_buffers_geometry %d -> %s", __FUNCTION__, -res, strerror(-res)); return; } } /* * Push new frame to the preview window. */ /* Dequeue preview window buffer for the frame. */ buffer_handle_t* buffer = NULL; int stride = 0; res = mPreviewWindow->dequeue_buffer(mPreviewWindow, &buffer, &stride); if (res != NO_ERROR || buffer == NULL) { ALOGE("%s: Unable to dequeue preview window buffer: %d -> %s", __FUNCTION__, -res, strerror(-res)); return; } /* Let the preview window to lock the buffer. */ res = mPreviewWindow->lock_buffer(mPreviewWindow, buffer); if (res != NO_ERROR) { ALOGE("%s: Unable to lock preview window buffer: %d -> %s", __FUNCTION__, -res, strerror(-res)); mPreviewWindow->cancel_buffer(mPreviewWindow, buffer); return; } /* Now let the graphics framework to lock the buffer, and provide * us with the framebuffer data address. */ void* img = NULL; const Rect rect(mPreviewFrameWidth, mPreviewFrameHeight); GraphicBufferMapper& grbuffer_mapper(GraphicBufferMapper::get()); res = grbuffer_mapper.lock(*buffer, GRALLOC_USAGE_SW_WRITE_OFTEN, rect, &img); if (res != NO_ERROR) { ALOGE("%s: grbuffer_mapper.lock failure: %d -> %s", __FUNCTION__, res, strerror(res)); mPreviewWindow->cancel_buffer(mPreviewWindow, buffer); return; } /* Frames come in in YV12/NV12/NV21 format. Since preview window doesn't * supports those formats, we need to obtain the frame in RGB565. */ res = camera_dev->getCurrentPreviewFrame(img); if (res == NO_ERROR) { /* Show it. */ mPreviewWindow->set_timestamp(mPreviewWindow, timestamp); mPreviewWindow->enqueue_buffer(mPreviewWindow, buffer); } else { ALOGE("%s: Unable to obtain preview frame: %d", __FUNCTION__, res); mPreviewWindow->cancel_buffer(mPreviewWindow, buffer); } grbuffer_mapper.unlock(*buffer); } /*************************************************************************** * Private API **************************************************************************/ bool PreviewWindow::adjustPreviewDimensions(EmulatedCameraDevice* camera_dev) { /* Match the cached frame dimensions against the actual ones. */ if (mPreviewFrameWidth == camera_dev->getFrameWidth() && mPreviewFrameHeight == camera_dev->getFrameHeight()) { /* They match. */ return false; } /* They don't match: adjust the cache. */ mPreviewFrameWidth = camera_dev->getFrameWidth(); mPreviewFrameHeight = camera_dev->getFrameHeight(); return true; } bool PreviewWindow::isPreviewTime() { timeval cur_time; gettimeofday(&cur_time, NULL); const uint64_t cur_mks = cur_time.tv_sec * 1000000LL + cur_time.tv_usec; if ((cur_mks - mLastPreviewed) >= mPreviewAfter) { mLastPreviewed = cur_mks; return true; } return false; } }; /* namespace android */ anbox-0.0~git20191115/android/camera/PreviewWindow.h000077500000000000000000000144641356361734700220730ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef HW_EMULATOR_CAMERA_PREVIEW_WINDOW_H #define HW_EMULATOR_CAMERA_PREVIEW_WINDOW_H /* * Contains declaration of a class PreviewWindow that encapsulates functionality * of a preview window set via set_preview_window camera HAL API. */ namespace android { class EmulatedCameraDevice; /* Encapsulates functionality of a preview window set via set_preview_window * camera HAL API. * * Objects of this class are contained in EmulatedCamera objects, and handle * relevant camera API callbacks. */ class PreviewWindow { public: /* Constructs PreviewWindow instance. */ PreviewWindow(); /* Destructs PreviewWindow instance. */ ~PreviewWindow(); /*************************************************************************** * Camera API **************************************************************************/ public: /* Actual handler for camera_device_ops_t::set_preview_window callback. * This method is called by the containing emulated camera object when it is * handing the camera_device_ops_t::set_preview_window callback. * Param: * window - Preview window to set. This parameter might be NULL, which * indicates preview window reset. * preview_fps - Preview's frame frequency. This parameter determins when * a frame received via onNextFrameAvailable call will be pushed to * the preview window. If 'window' parameter passed to this method is * NULL, this parameter is ignored. * Return: * NO_ERROR on success, or an appropriate error status. */ status_t setPreviewWindow(struct preview_stream_ops* window, int preview_fps); /* Starts the preview. * This method is called by the containing emulated camera object when it is * handing the camera_device_ops_t::start_preview callback. */ status_t startPreview(); /* Stops the preview. * This method is called by the containing emulated camera object when it is * handing the camera_device_ops_t::start_preview callback. */ void stopPreview(); /* Checks if preview is enabled. */ inline bool isPreviewEnabled() { return mPreviewEnabled; } /**************************************************************************** * Public API ***************************************************************************/ public: /* Next frame is available in the camera device. * This is a notification callback that is invoked by the camera device when * a new frame is available. * Note that most likely this method is called in context of a worker thread * that camera device has created for frame capturing. * Param: * frame - Captured frame, or NULL if camera device didn't pull the frame * yet. If NULL is passed in this parameter use GetCurrentFrame method * of the camera device class to obtain the next frame. Also note that * the size of the frame that is passed here (as well as the frame * returned from the GetCurrentFrame method) is defined by the current * frame settings (width + height + pixel format) for the camera device. * timestamp - Frame's timestamp. * camera_dev - Camera device instance that delivered the frame. */ void onNextFrameAvailable(const void* frame, nsecs_t timestamp, EmulatedCameraDevice* camera_dev); /*************************************************************************** * Private API **************************************************************************/ protected: /* Adjusts cached dimensions of the preview window frame according to the * frame dimensions used by the camera device. * * When preview is started, it's not known (hard to define) what are going * to be the dimensions of the frames that are going to be displayed. Plus, * it might be possible, that such dimensions can be changed on the fly. So, * in order to be always in sync with frame dimensions, this method is * called for each frame passed to onNextFrameAvailable method, in order to * properly adjust frame dimensions, used by the preview window. * Note that this method must be called while object is locked. * Param: * camera_dev - Camera device, prpviding frames displayed in the preview * window. * Return: * true if cached dimensions have been adjusted, or false if cached * dimensions match device's frame dimensions. */ bool adjustPreviewDimensions(EmulatedCameraDevice* camera_dev); /* Checks if it's the time to push new frame to the preview window. * Note that this method must be called while object is locked. */ bool isPreviewTime(); /*************************************************************************** * Data members **************************************************************************/ protected: /* Locks this instance for data changes. */ Mutex mObjectLock; /* Preview window instance. */ preview_stream_ops* mPreviewWindow; /* Timestamp (abs. microseconds) when last frame has been pushed to the * preview window. */ uint64_t mLastPreviewed; /* Preview frequency in microseconds. */ uint32_t mPreviewAfter; /* * Cached preview window frame dimensions. */ int mPreviewFrameWidth; int mPreviewFrameHeight; /* Preview status. */ bool mPreviewEnabled; }; }; /* namespace android */ #endif /* HW_EMULATOR_CAMERA_PREVIEW_WINDOW_H */ anbox-0.0~git20191115/android/camera/QemuClient.cpp000077500000000000000000000430651356361734700216620ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * Contains implementation of classes that encapsulate connection to camera * services in the emulator via qemu pipe. */ #define LOG_NDEBUG 1 #define LOG_TAG "EmulatedCamera_QemuClient" #include #include "EmulatedCamera.h" #include "QemuClient.h" #define LOG_QUERIES 0 #if LOG_QUERIES #define LOGQ(...) ALOGD(__VA_ARGS__) #else #define LOGQ(...) (void(0)) #endif // LOG_QUERIES namespace android { /**************************************************************************** * Qemu query ***************************************************************************/ QemuQuery::QemuQuery() : mQuery(mQueryPrealloc), mQueryDeliveryStatus(NO_ERROR), mReplyBuffer(NULL), mReplyData(NULL), mReplySize(0), mReplyDataSize(0), mReplyStatus(0) { *mQuery = '\0'; } QemuQuery::QemuQuery(const char* query_string) : mQuery(mQueryPrealloc), mQueryDeliveryStatus(NO_ERROR), mReplyBuffer(NULL), mReplyData(NULL), mReplySize(0), mReplyDataSize(0), mReplyStatus(0) { mQueryDeliveryStatus = QemuQuery::createQuery(query_string, NULL); } QemuQuery::QemuQuery(const char* query_name, const char* query_param) : mQuery(mQueryPrealloc), mQueryDeliveryStatus(NO_ERROR), mReplyBuffer(NULL), mReplyData(NULL), mReplySize(0), mReplyDataSize(0), mReplyStatus(0) { mQueryDeliveryStatus = QemuQuery::createQuery(query_name, query_param); } QemuQuery::~QemuQuery() { QemuQuery::resetQuery(); } status_t QemuQuery::createQuery(const char* name, const char* param) { /* Reset from the previous use. */ resetQuery(); /* Query name cannot be NULL or an empty string. */ if (name == NULL || *name == '\0') { ALOGE("%s: NULL or an empty string is passed as query name.", __FUNCTION__); mQueryDeliveryStatus = EINVAL; return EINVAL; } const size_t name_len = strlen(name); const size_t param_len = (param != NULL) ? strlen(param) : 0; const size_t required = strlen(name) + (param_len ? (param_len + 2) : 1); if (required > sizeof(mQueryPrealloc)) { /* Preallocated buffer was too small. Allocate a bigger query buffer. */ mQuery = new char[required]; if (mQuery == NULL) { ALOGE("%s: Unable to allocate %zu bytes for query buffer", __FUNCTION__, required); mQueryDeliveryStatus = ENOMEM; return ENOMEM; } } /* At this point mQuery buffer is big enough for the query. */ if (param_len) { sprintf(mQuery, "%s %s", name, param); } else { memcpy(mQuery, name, name_len + 1); } return NO_ERROR; } status_t QemuQuery::completeQuery(status_t status) { /* Save query completion status. */ mQueryDeliveryStatus = status; if (mQueryDeliveryStatus != NO_ERROR) { return mQueryDeliveryStatus; } /* Make sure reply buffer contains at least 'ok', or 'ko'. * Note that 'ok', or 'ko' prefixes are always 3 characters long: in case * there are more data in the reply, that data will be separated from 'ok'/'ko' * with a ':'. If there is no more data in the reply, the prefix will be * zero-terminated, and the terminator will be inculded in the reply. */ if (mReplyBuffer == NULL || mReplySize < 3) { ALOGE("%s: Invalid reply to the query", __FUNCTION__); mQueryDeliveryStatus = EINVAL; return EINVAL; } /* Lets see the reply status. */ if (!memcmp(mReplyBuffer, "ok", 2)) { mReplyStatus = 1; } else if (!memcmp(mReplyBuffer, "ko", 2)) { mReplyStatus = 0; } else { ALOGE("%s: Invalid query reply: '%s'", __FUNCTION__, mReplyBuffer); mQueryDeliveryStatus = EINVAL; return EINVAL; } /* Lets see if there are reply data that follow. */ if (mReplySize > 3) { /* There are extra data. Make sure they are separated from the status * with a ':' */ if (mReplyBuffer[2] != ':') { ALOGE("%s: Invalid query reply: '%s'", __FUNCTION__, mReplyBuffer); mQueryDeliveryStatus = EINVAL; return EINVAL; } mReplyData = mReplyBuffer + 3; mReplyDataSize = mReplySize - 3; } else { /* Make sure reply buffer containing just 'ok'/'ko' ends with * zero-terminator. */ if (mReplyBuffer[2] != '\0') { ALOGE("%s: Invalid query reply: '%s'", __FUNCTION__, mReplyBuffer); mQueryDeliveryStatus = EINVAL; return EINVAL; } } return NO_ERROR; } void QemuQuery::resetQuery() { if (mQuery != NULL && mQuery != mQueryPrealloc) { delete[] mQuery; } mQuery = mQueryPrealloc; mQueryDeliveryStatus = NO_ERROR; if (mReplyBuffer != NULL) { free(mReplyBuffer); mReplyBuffer = NULL; } mReplyData = NULL; mReplySize = mReplyDataSize = 0; mReplyStatus = 0; } /**************************************************************************** * Qemu client base ***************************************************************************/ /* Camera service name. */ const char QemuClient::mCameraServiceName[] = "camera"; QemuClient::QemuClient() : mPipeFD(-1) { } QemuClient::~QemuClient() { if (mPipeFD >= 0) { close(mPipeFD); } } /**************************************************************************** * Qemu client API ***************************************************************************/ status_t QemuClient::connectClient(const char* param) { ALOGV("%s: '%s'", __FUNCTION__, param ? param : ""); /* Make sure that client is not connected already. */ if (mPipeFD >= 0) { ALOGE("%s: Qemu client is already connected", __FUNCTION__); return EINVAL; } /* Select one of the two: 'factory', or 'emulated camera' service */ if (param == NULL || *param == '\0') { /* No parameters: connect to the factory service. */ char pipe_name[512]; snprintf(pipe_name, sizeof(pipe_name), "qemud:%s", mCameraServiceName); mPipeFD = qemu_pipe_open(pipe_name); } else { /* One extra char ':' that separates service name and parameters + six * characters for 'qemud:'. This is required by qemu pipe protocol. */ char* connection_str = new char[strlen(mCameraServiceName) + strlen(param) + 8]; sprintf(connection_str, "qemud:%s:%s", mCameraServiceName, param); mPipeFD = qemu_pipe_open(connection_str); delete[] connection_str; } if (mPipeFD < 0) { ALOGE("%s: Unable to connect to the camera service '%s': %s", __FUNCTION__, param ? param : "Factory", strerror(errno)); return errno ? errno : EINVAL; } return NO_ERROR; } void QemuClient::disconnectClient() { ALOGV("%s", __FUNCTION__); if (mPipeFD >= 0) { close(mPipeFD); mPipeFD = -1; } } status_t QemuClient::sendMessage(const void* data, size_t data_size) { if (mPipeFD < 0) { ALOGE("%s: Qemu client is not connected", __FUNCTION__); return EINVAL; } /* Note that we don't use here qemud_client_send, since with qemu pipes we * don't need to provide payload size prior to payload when we're writing to * the pipe. So, we can use simple write, and qemu pipe will take care of the * rest, calling the receiving end with the number of bytes transferred. */ const size_t written = qemud_fd_write(mPipeFD, data, data_size); if (written == data_size) { return NO_ERROR; } else { ALOGE("%s: Error sending data via qemu pipe: '%s'", __FUNCTION__, strerror(errno)); return errno ? errno : EIO; } } status_t QemuClient::receiveMessage(void** data, size_t* data_size) { *data = NULL; *data_size = 0; if (mPipeFD < 0) { ALOGE("%s: Qemu client is not connected", __FUNCTION__); return EINVAL; } /* The way the service replies to a query, it sends payload size first, and * then it sends the payload itself. Note that payload size is sent as a * string, containing 8 characters representing a hexadecimal payload size * value. Note also, that the string doesn't contain zero-terminator. */ size_t payload_size; char payload_size_str[9]; int rd_res = qemud_fd_read(mPipeFD, payload_size_str, 8); if (rd_res != 8) { ALOGE("%s: Unable to obtain payload size: %s", __FUNCTION__, strerror(errno)); return errno ? errno : EIO; } /* Convert payload size. */ errno = 0; payload_size_str[8] = '\0'; payload_size = strtol(payload_size_str, NULL, 16); if (errno) { ALOGE("%s: Invalid payload size '%s'", __FUNCTION__, payload_size_str); return EIO; } /* Allocate payload data buffer, and read the payload there. */ *data = malloc(payload_size); if (*data == NULL) { ALOGE("%s: Unable to allocate %zu bytes payload buffer", __FUNCTION__, payload_size); return ENOMEM; } rd_res = qemud_fd_read(mPipeFD, *data, payload_size); if (static_cast(rd_res) == payload_size) { *data_size = payload_size; return NO_ERROR; } else { ALOGE("%s: Read size %d doesnt match expected payload size %zu: %s", __FUNCTION__, rd_res, payload_size, strerror(errno)); free(*data); *data = NULL; return errno ? errno : EIO; } } status_t QemuClient::doQuery(QemuQuery* query) { /* Make sure that query has been successfuly constructed. */ if (query->mQueryDeliveryStatus != NO_ERROR) { ALOGE("%s: Query is invalid", __FUNCTION__); return query->mQueryDeliveryStatus; } LOGQ("Send query '%s'", query->mQuery); /* Send the query. */ status_t res = sendMessage(query->mQuery, strlen(query->mQuery) + 1); if (res == NO_ERROR) { /* Read the response. */ res = receiveMessage(reinterpret_cast(&query->mReplyBuffer), &query->mReplySize); if (res == NO_ERROR) { LOGQ("Response to query '%s': Status = '%.2s', %d bytes in response", query->mQuery, query->mReplyBuffer, query->mReplySize); } else { ALOGE("%s Response to query '%s' has failed: %s", __FUNCTION__, query->mQuery, strerror(res)); } } else { ALOGE("%s: Send query '%s' failed: %s", __FUNCTION__, query->mQuery, strerror(res)); } /* Complete the query, and return its completion handling status. */ const status_t res1 = query->completeQuery(res); ALOGE_IF(res1 != NO_ERROR && res1 != res, "%s: Error %d in query '%s' completion", __FUNCTION__, res1, query->mQuery); return res1; } /**************************************************************************** * Qemu client for the 'factory' service. ***************************************************************************/ /* * Factory service queries. */ /* Queries list of cameras connected to the host. */ const char FactoryQemuClient::mQueryList[] = "list"; FactoryQemuClient::FactoryQemuClient() : QemuClient() { } FactoryQemuClient::~FactoryQemuClient() { } status_t FactoryQemuClient::listCameras(char** list) { ALOGV("%s", __FUNCTION__); QemuQuery query(mQueryList); if (doQuery(&query) || !query.isQuerySucceeded()) { ALOGE("%s: List cameras query failed: %s", __FUNCTION__, query.mReplyData ? query.mReplyData : "No error message"); return query.getCompletionStatus(); } /* Make sure there is a list returned. */ if (query.mReplyDataSize == 0) { ALOGE("%s: No camera list is returned.", __FUNCTION__); return EINVAL; } /* Copy the list over. */ *list = (char*)malloc(query.mReplyDataSize); if (*list != NULL) { memcpy(*list, query.mReplyData, query.mReplyDataSize); ALOGD("Emulated camera list: %s", *list); return NO_ERROR; } else { ALOGE("%s: Unable to allocate %zu bytes", __FUNCTION__, query.mReplyDataSize); return ENOMEM; } } /**************************************************************************** * Qemu client for an 'emulated camera' service. ***************************************************************************/ /* * Emulated camera queries */ /* Connect to the camera device. */ const char CameraQemuClient::mQueryConnect[] = "connect"; /* Disconect from the camera device. */ const char CameraQemuClient::mQueryDisconnect[] = "disconnect"; /* Start capturing video from the camera device. */ const char CameraQemuClient::mQueryStart[] = "start"; /* Stop capturing video from the camera device. */ const char CameraQemuClient::mQueryStop[] = "stop"; /* Get next video frame from the camera device. */ const char CameraQemuClient::mQueryFrame[] = "frame"; CameraQemuClient::CameraQemuClient() : QemuClient() { } CameraQemuClient::~CameraQemuClient() { } status_t CameraQemuClient::queryConnect() { ALOGV("%s", __FUNCTION__); QemuQuery query(mQueryConnect); doQuery(&query); const status_t res = query.getCompletionStatus(); ALOGE_IF(res != NO_ERROR, "%s: Query failed: %s", __FUNCTION__, query.mReplyData ? query.mReplyData : "No error message"); return res; } status_t CameraQemuClient::queryDisconnect() { ALOGV("%s", __FUNCTION__); QemuQuery query(mQueryDisconnect); doQuery(&query); const status_t res = query.getCompletionStatus(); ALOGE_IF(res != NO_ERROR, "%s: Query failed: %s", __FUNCTION__, query.mReplyData ? query.mReplyData : "No error message"); return res; } status_t CameraQemuClient::queryStart(uint32_t pixel_format, int width, int height) { ALOGV("%s", __FUNCTION__); char query_str[256]; snprintf(query_str, sizeof(query_str), "%s dim=%dx%d pix=%d", mQueryStart, width, height, pixel_format); QemuQuery query(query_str); doQuery(&query); const status_t res = query.getCompletionStatus(); ALOGE_IF(res != NO_ERROR, "%s: Query failed: %s", __FUNCTION__, query.mReplyData ? query.mReplyData : "No error message"); return res; } status_t CameraQemuClient::queryStop() { ALOGV("%s", __FUNCTION__); QemuQuery query(mQueryStop); doQuery(&query); const status_t res = query.getCompletionStatus(); ALOGE_IF(res != NO_ERROR, "%s: Query failed: %s", __FUNCTION__, query.mReplyData ? query.mReplyData : "No error message"); return res; } status_t CameraQemuClient::queryFrame(void* vframe, void* pframe, size_t vframe_size, size_t pframe_size, float r_scale, float g_scale, float b_scale, float exposure_comp) { ALOGV("%s", __FUNCTION__); char query_str[256]; snprintf(query_str, sizeof(query_str), "%s video=%zu preview=%zu whiteb=%g,%g,%g expcomp=%g", mQueryFrame, (vframe && vframe_size) ? vframe_size : 0, (pframe && pframe_size) ? pframe_size : 0, r_scale, g_scale, b_scale, exposure_comp); QemuQuery query(query_str); doQuery(&query); const status_t res = query.getCompletionStatus(); if( res != NO_ERROR) { ALOGE("%s: Query failed: %s", __FUNCTION__, query.mReplyData ? query.mReplyData : "No error message"); return res; } /* Copy requested frames. */ size_t cur_offset = 0; const uint8_t* frame = reinterpret_cast(query.mReplyData); /* Video frame is always first. */ if (vframe != NULL && vframe_size != 0) { /* Make sure that video frame is in. */ if ((query.mReplyDataSize - cur_offset) >= vframe_size) { memcpy(vframe, frame, vframe_size); cur_offset += vframe_size; } else { ALOGE("%s: Reply %zu bytes is to small to contain %zu bytes video frame", __FUNCTION__, query.mReplyDataSize - cur_offset, vframe_size); return EINVAL; } } if (pframe != NULL && pframe_size != 0) { /* Make sure that preview frame is in. */ if ((query.mReplyDataSize - cur_offset) >= pframe_size) { memcpy(pframe, frame + cur_offset, pframe_size); cur_offset += pframe_size; } else { ALOGE("%s: Reply %zu bytes is to small to contain %zu bytes preview frame", __FUNCTION__, query.mReplyDataSize - cur_offset, pframe_size); return EINVAL; } } return NO_ERROR; } }; /* namespace android */ anbox-0.0~git20191115/android/camera/QemuClient.h000077500000000000000000000424121356361734700213220ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef HW_EMULATOR_CAMERA_QEMU_CLIENT_H #define HW_EMULATOR_CAMERA_QEMU_CLIENT_H /* * Contains declaration of classes that encapsulate connection to camera services * in the emulator via qemu pipe. */ #include namespace android { /**************************************************************************** * Qemu query ***************************************************************************/ /* Encapsulates a query to the emulator. * Guest exchanges data with the emulator via queries sent over the qemu pipe. * The queries as well as replies to the queries are all strings (except for the * 'frame' query where reply is a framebuffer). * Each query is formatted as such: * * "[ ]", * * where is a string representing query name, and are * optional parameters for the query. If parameters are present, they must be * separated from the query name with a single space, and they must be formatted * as such: * * "= = ... =" * * I.e.: * - Every parameter must have a name, and a value. * - Name and value must be separated with '='. * - No spaces are allowed around '=' separating name and value. * - Parameters must be separated with a single space character. * - No '=' character is allowed in name and in value. * * There are certain restrictions on strings used in the query: * - Spaces are allowed only as separators. * - '=' are allowed only to divide parameter names from parameter values. * * Emulator replies to each query in two chunks: * - 8 bytes encoding the payload size as a string containing hexadecimal * representation of the payload size value. This is done in order to simplify * dealing with different endianness on the host, and on the guest. * - Payload, whose size is defined by the first chunk. * * Every payload always begins with two characters, encoding the result of the * query: * - 'ok' Encoding the success * - 'ko' Encoding a failure. * After that payload may have optional data. If payload has more data following * the query result, there is a ':' character separating them. If payload carries * only the result, it always ends with a zero-terminator. So, payload 'ok'/'ko' * prefix is always 3 bytes long: it either includes a zero-terminator, if there * is no data, or a ':' separator. */ class QemuQuery { public: /* Constructs an uninitialized QemuQuery instance. */ QemuQuery(); /* Constructs and initializes QemuQuery instance for a query. * Param: * query_string - Query string. This constructor can also be used to * construct a query that doesn't have parameters. In this case query * name can be passed as a parameter here. */ explicit QemuQuery(const char* query_string); /* Constructs and initializes QemuQuery instance for a query with parameters. * Param: * query_name - Query name. * query_param - Query parameters. Can be NULL. */ QemuQuery(const char* query_name, const char* query_param); /* Destructs QemuQuery instance. */ ~QemuQuery(); /**************************************************************************** * Public API ***************************************************************************/ /* Creates new query. * Note: this method will reset this instance prior to creating a new query * in order to discard possible "leftovers" from the previous query. * Param: * query_name - Query name. * query_param - Query parameters. Can be NULL. * Return: * NO_ERROR on success, or an appropriate error status. */ status_t createQuery(const char* name, const char* param); /* Completes the query after a reply from the emulator. * This method will parse the reply buffer, and calculate the final query * status, which depends not only on the transport success / failure, but * also on 'ok' / 'ko' in the reply buffer. * Param: * status - Query delivery status. This status doesn't necessarily reflects * the final query status (which is defined by 'ok'/'ko' prefix in the * reply buffer). This status simply states whether or not the query has * been sent, and a reply has been received successfuly. However, if * this status indicates a failure, it means that the entire query has * failed. * Return: * NO_ERROR on success, or an appropriate error status on failure. Note that * status returned here just signals whether or not the method has succeeded. * Use isQuerySucceeded() / getCompletionStatus() methods of this class to * check the final query status. */ status_t completeQuery(status_t status); /* Resets the query from a previous use. */ void resetQuery(); /* Checks if query has succeeded. * Note that this method must be called after completeQuery() method of this * class has been executed. */ inline bool isQuerySucceeded() const { return mQueryDeliveryStatus == NO_ERROR && mReplyStatus != 0; } /* Gets final completion status of the query. * Note that this method must be called after completeQuery() method of this * class has been executed. * Return: * NO_ERROR if query has succeeded, or an appropriate error status on query * failure. */ inline status_t getCompletionStatus() const { if (mQueryDeliveryStatus == NO_ERROR) { if (mReplyStatus) { return NO_ERROR; } else { return EINVAL; } } else { return mQueryDeliveryStatus; } } /**************************************************************************** * Public data memebers ***************************************************************************/ public: /* Query string. */ char* mQuery; /* Query delivery status. */ status_t mQueryDeliveryStatus; /* Reply buffer */ char* mReplyBuffer; /* Reply data (past 'ok'/'ko'). If NULL, there were no data in reply. */ char* mReplyData; /* Reply buffer size. */ size_t mReplySize; /* Reply data size. */ size_t mReplyDataSize; /* Reply status: 1 - ok, 0 - ko. */ int mReplyStatus; /**************************************************************************** * Private data memebers ***************************************************************************/ protected: /* Preallocated buffer for small queries. */ char mQueryPrealloc[256]; }; /**************************************************************************** * Qemu client base ***************************************************************************/ /* Encapsulates a connection to the 'camera' service in the emulator via qemu * pipe. */ class QemuClient { public: /* Constructs QemuClient instance. */ QemuClient(); /* Destructs QemuClient instance. */ virtual ~QemuClient(); /**************************************************************************** * Qemu client API ***************************************************************************/ public: /* Connects to the 'camera' service in the emulator via qemu pipe. * Param: * param - Parameters to pass to the camera service. There are two types of * camera services implemented by the emulator. The first one is a * 'camera factory' type of service that provides list of cameras * connected to the host. Another one is an 'emulated camera' type of * service that provides interface to a camera connected to the host. At * the connection time emulator makes distinction between the two by * looking at connection parameters: no parameters means connection to * the 'factory' service, while connection with parameters means * connection to an 'emulated camera' service, where camera is identified * by one of the connection parameters. So, passing NULL, or an empty * string to this method will establish a connection with the 'factory' * service, while not empty string passed here will establish connection * with an 'emulated camera' service. Parameters defining the emulated * camera must be formatted as such: * * "name= [inp_channel=]", * * where 'device name' is a required parameter defining name of the * camera device, and 'input channel' is an optional parameter (positive * integer), defining the input channel to use on the camera device. * Note that device name passed here must have been previously obtained * from the factory service using 'list' query. * Return: * NO_ERROR on success, or an appropriate error status. */ virtual status_t connectClient(const char* param); /* Disconnects from the service. */ virtual void disconnectClient(); /* Sends data to the service. * Param: * data, data_size - Data to send. * Return: * NO_ERROR on success, or an appropriate error status on failure. */ virtual status_t sendMessage(const void* data, size_t data_size); /* Receives data from the service. * This method assumes that data to receive will come in two chunks: 8 * characters encoding the payload size in hexadecimal string, followed by * the paylod (if any). * This method will allocate data buffer where to receive the response. * Param: * data - Upon success contains address of the allocated data buffer with * the data received from the service. The caller is responsible for * freeing allocated data buffer. * data_size - Upon success contains size of the data received from the * service. * Return: * NO_ERROR on success, or an appropriate error status on failure. */ virtual status_t receiveMessage(void** data, size_t* data_size); /* Sends a query, and receives a response from the service. * Param: * query - Query to send to the service. When this method returns, the query * is completed, and all its relevant data members are properly initialized. * Return: * NO_ERROR on success, or an appropriate error status on failure. Note that * status returned here is not the final query status. Use isQuerySucceeded(), * or getCompletionStatus() method on the query object to see if it has * succeeded. However, if this method returns a failure, it means that the * query has failed, and there is no guarantee that its data members are * properly initialized (except for the 'mQueryDeliveryStatus', which is * always in the proper state). */ virtual status_t doQuery(QemuQuery* query); /**************************************************************************** * Data members ***************************************************************************/ protected: /* Qemu pipe handle. */ int mPipeFD; private: /* Camera service name. */ static const char mCameraServiceName[]; }; /**************************************************************************** * Qemu client for the 'factory' service. ***************************************************************************/ /* Encapsulates QemuClient for the 'factory' service. */ class FactoryQemuClient : public QemuClient { public: /* Constructs FactoryQemuClient instance. */ FactoryQemuClient(); /* Destructs FactoryQemuClient instance. */ ~FactoryQemuClient(); /**************************************************************************** * Public API ***************************************************************************/ public: /* Lists camera devices connected to the host. * Param: * list - Upon success contains a list of cameras connected to the host. The * list returned here is represented as a string, containing multiple * lines separated with '\n', where each line represents a camera. Each * camera line is formatted as such: * * "name= channel= pix= framedims=\n" * * Where: * - 'name' is the name of the camera device attached to the host. This * name must be used for subsequent connection to the 'emulated camera' * service for that camera. * - 'channel' - input channel number (positive int) to use to communicate * with the camera. * - 'pix' - pixel format (a "fourcc" uint), chosen for the video frames * by the camera service. * - 'framedims' contains a list of frame dimensions supported by the * camera for the chosen pixel format. Each etry in the list is in form * 'x', where 'width' and 'height' are numeric values * for width and height of a supported frame dimension. Entries in * this list are separated with ',' with no spaces between the entries. * Return: * NO_ERROR on success, or an appropriate error status on failure. */ status_t listCameras(char** list); /**************************************************************************** * Names of the queries available for the emulated camera factory. ***************************************************************************/ private: /* List cameras connected to the host. */ static const char mQueryList[]; }; /**************************************************************************** * Qemu client for an 'emulated camera' service. ***************************************************************************/ /* Encapsulates QemuClient for an 'emulated camera' service. */ class CameraQemuClient : public QemuClient { public: /* Constructs CameraQemuClient instance. */ CameraQemuClient(); /* Destructs CameraQemuClient instance. */ ~CameraQemuClient(); /**************************************************************************** * Public API ***************************************************************************/ public: /* Queries camera connection. * Return: * NO_ERROR on success, or an appropriate error status on failure. */ status_t queryConnect(); /* Queries camera disconnection. * Return: * NO_ERROR on success, or an appropriate error status on failure. */ status_t queryDisconnect(); /* Queries camera to start capturing video. * Param: * pixel_format - Pixel format that is used by the client to push video * frames to the camera framework. * width, height - Frame dimensions, requested by the framework. * Return: * NO_ERROR on success, or an appropriate error status on failure. */ status_t queryStart(uint32_t pixel_format, int width, int height); /* Queries camera to stop capturing video. * Return: * NO_ERROR on success, or an appropriate error status on failure. */ status_t queryStop(); /* Queries camera for the next video frame. * Param: * vframe, vframe_size - Define buffer, allocated to receive a video frame. * Any of these parameters can be 0, indicating that the caller is * interested only in preview frame. * pframe, pframe_size - Define buffer, allocated to receive a preview frame. * Any of these parameters can be 0, indicating that the caller is * interested only in video frame. * r_scale, g_scale, b_scale - White balance scale. * exposure_comp - Expsoure compensation. * Return: * NO_ERROR on success, or an appropriate error status on failure. */ status_t queryFrame(void* vframe, void* pframe, size_t vframe_size, size_t pframe_size, float r_scale, float g_scale, float b_scale, float exposure_comp); /**************************************************************************** * Names of the queries available for the emulated camera. ***************************************************************************/ private: /* Connect to the camera. */ static const char mQueryConnect[]; /* Disconnect from the camera. */ static const char mQueryDisconnect[]; /* Start video capturing. */ static const char mQueryStart[]; /* Stop video capturing. */ static const char mQueryStop[]; /* Query frame(s). */ static const char mQueryFrame[]; }; }; /* namespace android */ #endif /* HW_EMULATOR_CAMERA_QEMU_CLIENT_H */ anbox-0.0~git20191115/android/camera/fake-pipeline2/000077500000000000000000000000001356361734700216705ustar00rootroot00000000000000anbox-0.0~git20191115/android/camera/fake-pipeline2/Base.h000066400000000000000000000032651356361734700227210ustar00rootroot00000000000000/* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * This file includes various basic structures that are needed by multiple parts * of the fake camera 2 implementation. */ #ifndef HW_EMULATOR_CAMERA2_BASE_H #define HW_EMULATOR_CAMERA2_BASE_H #include #include #include namespace android { /* Internal structure for passing buffers across threads */ struct StreamBuffer { // Positive numbers are output streams // Negative numbers are input reprocess streams // Zero is an auxillary buffer int streamId; uint32_t width, height; uint32_t format; uint32_t dataSpace; uint32_t stride; buffer_handle_t *buffer; uint8_t *img; }; typedef Vector Buffers; struct Stream { const camera2_stream_ops_t *ops; uint32_t width, height; int32_t format; uint32_t stride; }; struct ReprocessStream { const camera2_stream_in_ops_t *ops; uint32_t width, height; int32_t format; uint32_t stride; // -1 if the reprocessing stream is independent int32_t sourceStreamId; }; } // namespace android; #endif anbox-0.0~git20191115/android/camera/fake-pipeline2/JpegCompressor.cpp000066400000000000000000000167411356361734700253470ustar00rootroot00000000000000/* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ //#define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera2_JpegCompressor" #include #include #include "JpegCompressor.h" #include "../EmulatedFakeCamera2.h" #include "../EmulatedFakeCamera3.h" namespace android { JpegCompressor::JpegCompressor(): Thread(false), mIsBusy(false), mSynchronous(false), mBuffers(NULL), mListener(NULL) { } JpegCompressor::~JpegCompressor() { Mutex::Autolock lock(mMutex); } status_t JpegCompressor::start(Buffers *buffers, JpegListener *listener) { if (listener == NULL) { ALOGE("%s: NULL listener not allowed!", __FUNCTION__); return BAD_VALUE; } Mutex::Autolock lock(mMutex); { Mutex::Autolock busyLock(mBusyMutex); if (mIsBusy) { ALOGE("%s: Already processing a buffer!", __FUNCTION__); return INVALID_OPERATION; } mIsBusy = true; mSynchronous = false; mBuffers = buffers; mListener = listener; } status_t res; res = run("EmulatedFakeCamera2::JpegCompressor"); if (res != OK) { ALOGE("%s: Unable to start up compression thread: %s (%d)", __FUNCTION__, strerror(-res), res); delete mBuffers; } return res; } status_t JpegCompressor::compressSynchronous(Buffers *buffers) { status_t res; Mutex::Autolock lock(mMutex); { Mutex::Autolock busyLock(mBusyMutex); if (mIsBusy) { ALOGE("%s: Already processing a buffer!", __FUNCTION__); return INVALID_OPERATION; } mIsBusy = true; mSynchronous = true; mBuffers = buffers; } res = compress(); cleanUp(); return res; } status_t JpegCompressor::cancel() { requestExitAndWait(); return OK; } status_t JpegCompressor::readyToRun() { return OK; } bool JpegCompressor::threadLoop() { status_t res; ALOGV("%s: Starting compression thread", __FUNCTION__); res = compress(); mListener->onJpegDone(mJpegBuffer, res == OK); cleanUp(); return false; } status_t JpegCompressor::compress() { // Find source and target buffers. Assumes only one buffer matches // each condition! bool foundJpeg = false, mFoundAux = false; for (size_t i = 0; i < mBuffers->size(); i++) { const StreamBuffer &b = (*mBuffers)[i]; if (b.format == HAL_PIXEL_FORMAT_BLOB) { mJpegBuffer = b; mFoundJpeg = true; } else if (b.streamId <= 0) { mAuxBuffer = b; mFoundAux = true; } if (mFoundJpeg && mFoundAux) break; } if (!mFoundJpeg || !mFoundAux) { ALOGE("%s: Unable to find buffers for JPEG source/destination", __FUNCTION__); return BAD_VALUE; } // Set up error management mJpegErrorInfo = NULL; JpegError error; error.parent = this; mCInfo.err = jpeg_std_error(&error); mCInfo.err->error_exit = jpegErrorHandler; jpeg_create_compress(&mCInfo); if (checkError("Error initializing compression")) return NO_INIT; // Route compressed data straight to output stream buffer JpegDestination jpegDestMgr; jpegDestMgr.parent = this; jpegDestMgr.init_destination = jpegInitDestination; jpegDestMgr.empty_output_buffer = jpegEmptyOutputBuffer; jpegDestMgr.term_destination = jpegTermDestination; mCInfo.dest = &jpegDestMgr; // Set up compression parameters mCInfo.image_width = mAuxBuffer.width; mCInfo.image_height = mAuxBuffer.height; mCInfo.input_components = 3; mCInfo.in_color_space = JCS_RGB; jpeg_set_defaults(&mCInfo); if (checkError("Error configuring defaults")) return NO_INIT; // Do compression jpeg_start_compress(&mCInfo, TRUE); if (checkError("Error starting compression")) return NO_INIT; size_t rowStride = mAuxBuffer.stride * 3; const size_t kChunkSize = 32; while (mCInfo.next_scanline < mCInfo.image_height) { JSAMPROW chunk[kChunkSize]; for (size_t i = 0 ; i < kChunkSize; i++) { chunk[i] = (JSAMPROW) (mAuxBuffer.img + (i + mCInfo.next_scanline) * rowStride); } jpeg_write_scanlines(&mCInfo, chunk, kChunkSize); if (checkError("Error while compressing")) return NO_INIT; if (exitPending()) { ALOGV("%s: Cancel called, exiting early", __FUNCTION__); return TIMED_OUT; } } jpeg_finish_compress(&mCInfo); if (checkError("Error while finishing compression")) return NO_INIT; // All done return OK; } bool JpegCompressor::isBusy() { Mutex::Autolock busyLock(mBusyMutex); return mIsBusy; } bool JpegCompressor::isStreamInUse(uint32_t id) { Mutex::Autolock lock(mBusyMutex); if (mBuffers && mIsBusy) { for (size_t i = 0; i < mBuffers->size(); i++) { if ( (*mBuffers)[i].streamId == (int)id ) return true; } } return false; } bool JpegCompressor::waitForDone(nsecs_t timeout) { Mutex::Autolock lock(mBusyMutex); status_t res = OK; if (mIsBusy) { res = mDone.waitRelative(mBusyMutex, timeout); } return (res == OK); } bool JpegCompressor::checkError(const char *msg) { if (mJpegErrorInfo) { char errBuffer[JMSG_LENGTH_MAX]; mJpegErrorInfo->err->format_message(mJpegErrorInfo, errBuffer); ALOGE("%s: %s: %s", __FUNCTION__, msg, errBuffer); mJpegErrorInfo = NULL; return true; } return false; } void JpegCompressor::cleanUp() { status_t res; jpeg_destroy_compress(&mCInfo); Mutex::Autolock lock(mBusyMutex); if (mFoundAux) { if (mAuxBuffer.streamId == 0) { delete[] mAuxBuffer.img; } else if (!mSynchronous) { mListener->onJpegInputDone(mAuxBuffer); } } if (!mSynchronous) { delete mBuffers; } mBuffers = NULL; mIsBusy = false; mDone.signal(); } void JpegCompressor::jpegErrorHandler(j_common_ptr cinfo) { JpegError *error = static_cast(cinfo->err); error->parent->mJpegErrorInfo = cinfo; } void JpegCompressor::jpegInitDestination(j_compress_ptr cinfo) { JpegDestination *dest= static_cast(cinfo->dest); ALOGV("%s: Setting destination to %p, size %zu", __FUNCTION__, dest->parent->mJpegBuffer.img, kMaxJpegSize); dest->next_output_byte = (JOCTET*)(dest->parent->mJpegBuffer.img); dest->free_in_buffer = kMaxJpegSize; } boolean JpegCompressor::jpegEmptyOutputBuffer(j_compress_ptr cinfo) { ALOGE("%s: JPEG destination buffer overflow!", __FUNCTION__); return true; } void JpegCompressor::jpegTermDestination(j_compress_ptr cinfo) { ALOGV("%s: Done writing JPEG data. %zu bytes left in buffer", __FUNCTION__, cinfo->dest->free_in_buffer); } JpegCompressor::JpegListener::~JpegListener() { } } // namespace android anbox-0.0~git20191115/android/camera/fake-pipeline2/JpegCompressor.h000066400000000000000000000060331356361734700250050ustar00rootroot00000000000000/* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * This class simulates a hardware JPEG compressor. It receives image buffers * in RGBA_8888 format, processes them in a worker thread, and then pushes them * out to their destination stream. */ #ifndef HW_EMULATOR_CAMERA2_JPEG_H #define HW_EMULATOR_CAMERA2_JPEG_H #include "utils/Thread.h" #include "utils/Mutex.h" #include "utils/Timers.h" #include "Base.h" #include extern "C" { #include } namespace android { class JpegCompressor: private Thread, public virtual RefBase { public: JpegCompressor(); ~JpegCompressor(); struct JpegListener { // Called when JPEG compression has finished, or encountered an error virtual void onJpegDone(const StreamBuffer &jpegBuffer, bool success) = 0; // Called when the input buffer for JPEG is not needed any more, // if the buffer came from the framework. virtual void onJpegInputDone(const StreamBuffer &inputBuffer) = 0; virtual ~JpegListener(); }; // Start compressing COMPRESSED format buffers; JpegCompressor takes // ownership of the Buffers vector. status_t start(Buffers *buffers, JpegListener *listener); // Compress and block until buffer is complete. status_t compressSynchronous(Buffers *buffers); status_t cancel(); bool isBusy(); bool isStreamInUse(uint32_t id); bool waitForDone(nsecs_t timeout); // TODO: Measure this static const size_t kMaxJpegSize = 300000; private: Mutex mBusyMutex; bool mIsBusy; Condition mDone; bool mSynchronous; Mutex mMutex; Buffers *mBuffers; JpegListener *mListener; StreamBuffer mJpegBuffer, mAuxBuffer; bool mFoundJpeg, mFoundAux; jpeg_compress_struct mCInfo; struct JpegError : public jpeg_error_mgr { JpegCompressor *parent; }; j_common_ptr mJpegErrorInfo; struct JpegDestination : public jpeg_destination_mgr { JpegCompressor *parent; }; static void jpegErrorHandler(j_common_ptr cinfo); static void jpegInitDestination(j_compress_ptr cinfo); static boolean jpegEmptyOutputBuffer(j_compress_ptr cinfo); static void jpegTermDestination(j_compress_ptr cinfo); bool checkError(const char *msg); status_t compress(); void cleanUp(); /** * Inherited Thread virtual overrides */ private: virtual status_t readyToRun(); virtual bool threadLoop(); }; } // namespace android #endif anbox-0.0~git20191115/android/camera/fake-pipeline2/Scene.cpp000066400000000000000000000376201356361734700234410ustar00rootroot00000000000000/* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ //#define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_Scene" #include #include #include #include "Scene.h" // TODO: This should probably be done host-side in OpenGL for speed and better // quality namespace android { // Define single-letter shortcuts for scene definition, for directly indexing // mCurrentColors #define G (Scene::GRASS * Scene::NUM_CHANNELS) #define S (Scene::GRASS_SHADOW * Scene::NUM_CHANNELS) #define H (Scene::HILL * Scene::NUM_CHANNELS) #define W (Scene::WALL * Scene::NUM_CHANNELS) #define R (Scene::ROOF * Scene::NUM_CHANNELS) #define D (Scene::DOOR * Scene::NUM_CHANNELS) #define C (Scene::CHIMNEY * Scene::NUM_CHANNELS) #define I (Scene::WINDOW * Scene::NUM_CHANNELS) #define U (Scene::SUN * Scene::NUM_CHANNELS) #define K (Scene::SKY * Scene::NUM_CHANNELS) #define M (Scene::MOON * Scene::NUM_CHANNELS) const int Scene::kSceneWidth = 20; const int Scene::kSceneHeight = 20; const uint8_t Scene::kScene[Scene::kSceneWidth * Scene::kSceneHeight] = { // 5 10 15 20 K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K, K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K, K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K, K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K, K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K, // 5 K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K, K,K,K,K,K,K,K,K,H,H,H,H,H,H,H,H,H,H,H,H, K,K,K,K,K,K,K,K,H,H,H,H,H,H,H,C,C,H,H,H, K,K,K,K,K,K,H,H,H,H,H,H,H,H,H,C,C,H,H,H, H,K,K,K,K,K,H,R,R,R,R,R,R,R,R,R,R,R,R,H, // 10 H,K,K,K,K,H,H,R,R,R,R,R,R,R,R,R,R,R,R,H, H,H,H,K,K,H,H,R,R,R,R,R,R,R,R,R,R,R,R,H, H,H,H,K,K,H,H,H,W,W,W,W,W,W,W,W,W,W,H,H, S,S,S,G,G,S,S,S,W,W,W,W,W,W,W,W,W,W,S,S, S,G,G,G,G,S,S,S,W,I,I,W,D,D,W,I,I,W,S,S, // 15 G,G,G,G,G,G,S,S,W,I,I,W,D,D,W,I,I,W,S,S, G,G,G,G,G,G,G,G,W,W,W,W,D,D,W,W,W,W,G,G, G,G,G,G,G,G,G,G,W,W,W,W,D,D,W,W,W,W,G,G, G,G,G,G,G,G,G,G,S,S,S,S,S,S,S,S,S,S,G,G, G,G,G,G,G,G,G,G,S,S,S,S,S,S,S,S,S,S,G,G, // 20 // 5 10 15 20 }; #undef G #undef S #undef H #undef W #undef R #undef D #undef C #undef I #undef U #undef K #undef M Scene::Scene( int sensorWidthPx, int sensorHeightPx, float sensorSensitivity): mSensorWidth(sensorWidthPx), mSensorHeight(sensorHeightPx), mHour(12), mExposureDuration(0.033f), mSensorSensitivity(sensorSensitivity) { // Map scene to sensor pixels if (mSensorWidth > mSensorHeight) { mMapDiv = (mSensorWidth / (kSceneWidth + 1) ) + 1; } else { mMapDiv = (mSensorHeight / (kSceneHeight + 1) ) + 1; } mOffsetX = (kSceneWidth * mMapDiv - mSensorWidth) / 2; mOffsetY = (kSceneHeight * mMapDiv - mSensorHeight) / 2; // Assume that sensor filters are sRGB primaries to start mFilterR[0] = 3.2406f; mFilterR[1] = -1.5372f; mFilterR[2] = -0.4986f; mFilterGr[0] = -0.9689f; mFilterGr[1] = 1.8758f; mFilterGr[2] = 0.0415f; mFilterGb[0] = -0.9689f; mFilterGb[1] = 1.8758f; mFilterGb[2] = 0.0415f; mFilterB[0] = 0.0557f; mFilterB[1] = -0.2040f; mFilterB[2] = 1.0570f; } Scene::~Scene() { } void Scene::setColorFilterXYZ( float rX, float rY, float rZ, float grX, float grY, float grZ, float gbX, float gbY, float gbZ, float bX, float bY, float bZ) { mFilterR[0] = rX; mFilterR[1] = rY; mFilterR[2] = rZ; mFilterGr[0] = grX; mFilterGr[1] = grY; mFilterGr[2] = grZ; mFilterGb[0] = gbX; mFilterGb[1] = gbY; mFilterGb[2] = gbZ; mFilterB[0] = bX; mFilterB[1] = bY; mFilterB[2] = bZ; } void Scene::setHour(int hour) { ALOGV("Hour set to: %d", hour); mHour = hour % 24; } int Scene::getHour() { return mHour; } void Scene::setExposureDuration(float seconds) { mExposureDuration = seconds; } void Scene::calculateScene(nsecs_t time) { // Calculate time fractions for interpolation int timeIdx = mHour / kTimeStep; int nextTimeIdx = (timeIdx + 1) % (24 / kTimeStep); const nsecs_t kOneHourInNsec = 1e9 * 60 * 60; nsecs_t timeSinceIdx = (mHour - timeIdx * kTimeStep) * kOneHourInNsec + time; float timeFrac = timeSinceIdx / (float)(kOneHourInNsec * kTimeStep); // Determine overall sunlight levels float sunLux = kSunlight[timeIdx] * (1 - timeFrac) + kSunlight[nextTimeIdx] * timeFrac; ALOGV("Sun lux: %f", sunLux); float sunShadeLux = sunLux * (kDaylightShadeIllum / kDirectSunIllum); // Determine sun/shade illumination chromaticity float currentSunXY[2]; float currentShadeXY[2]; const float *prevSunXY, *nextSunXY; const float *prevShadeXY, *nextShadeXY; if (kSunlight[timeIdx] == kSunsetIllum || kSunlight[timeIdx] == kTwilightIllum) { prevSunXY = kSunsetXY; prevShadeXY = kSunsetXY; } else { prevSunXY = kDirectSunlightXY; prevShadeXY = kDaylightXY; } if (kSunlight[nextTimeIdx] == kSunsetIllum || kSunlight[nextTimeIdx] == kTwilightIllum) { nextSunXY = kSunsetXY; nextShadeXY = kSunsetXY; } else { nextSunXY = kDirectSunlightXY; nextShadeXY = kDaylightXY; } currentSunXY[0] = prevSunXY[0] * (1 - timeFrac) + nextSunXY[0] * timeFrac; currentSunXY[1] = prevSunXY[1] * (1 - timeFrac) + nextSunXY[1] * timeFrac; currentShadeXY[0] = prevShadeXY[0] * (1 - timeFrac) + nextShadeXY[0] * timeFrac; currentShadeXY[1] = prevShadeXY[1] * (1 - timeFrac) + nextShadeXY[1] * timeFrac; ALOGV("Sun XY: %f, %f, Shade XY: %f, %f", currentSunXY[0], currentSunXY[1], currentShadeXY[0], currentShadeXY[1]); // Converting for xyY to XYZ: // X = Y / y * x // Y = Y // Z = Y / y * (1 - x - y); float sunXYZ[3] = { sunLux / currentSunXY[1] * currentSunXY[0], sunLux, sunLux / currentSunXY[1] * (1 - currentSunXY[0] - currentSunXY[1]) }; float sunShadeXYZ[3] = { sunShadeLux / currentShadeXY[1] * currentShadeXY[0], sunShadeLux, sunShadeLux / currentShadeXY[1] * (1 - currentShadeXY[0] - currentShadeXY[1]) }; ALOGV("Sun XYZ: %f, %f, %f", sunXYZ[0], sunXYZ[1], sunXYZ[2]); ALOGV("Sun shade XYZ: %f, %f, %f", sunShadeXYZ[0], sunShadeXYZ[1], sunShadeXYZ[2]); // Determine moonlight levels float moonLux = kMoonlight[timeIdx] * (1 - timeFrac) + kMoonlight[nextTimeIdx] * timeFrac; float moonShadeLux = moonLux * (kDaylightShadeIllum / kDirectSunIllum); float moonXYZ[3] = { moonLux / kMoonlightXY[1] * kMoonlightXY[0], moonLux, moonLux / kMoonlightXY[1] * (1 - kMoonlightXY[0] - kMoonlightXY[1]) }; float moonShadeXYZ[3] = { moonShadeLux / kMoonlightXY[1] * kMoonlightXY[0], moonShadeLux, moonShadeLux / kMoonlightXY[1] * (1 - kMoonlightXY[0] - kMoonlightXY[1]) }; // Determine starlight level const float kClearNightXYZ[3] = { kClearNightIllum / kMoonlightXY[1] * kMoonlightXY[0], kClearNightIllum, kClearNightIllum / kMoonlightXY[1] * (1 - kMoonlightXY[0] - kMoonlightXY[1]) }; // Calculate direct and shaded light float directIllumXYZ[3] = { sunXYZ[0] + moonXYZ[0] + kClearNightXYZ[0], sunXYZ[1] + moonXYZ[1] + kClearNightXYZ[1], sunXYZ[2] + moonXYZ[2] + kClearNightXYZ[2], }; float shadeIllumXYZ[3] = { kClearNightXYZ[0], kClearNightXYZ[1], kClearNightXYZ[2] }; shadeIllumXYZ[0] += (mHour < kSunOverhead) ? sunXYZ[0] : sunShadeXYZ[0]; shadeIllumXYZ[1] += (mHour < kSunOverhead) ? sunXYZ[1] : sunShadeXYZ[1]; shadeIllumXYZ[2] += (mHour < kSunOverhead) ? sunXYZ[2] : sunShadeXYZ[2]; // Moon up period covers 23->0 transition, shift for simplicity int adjHour = (mHour + 12) % 24; int adjMoonOverhead = (kMoonOverhead + 12 ) % 24; shadeIllumXYZ[0] += (adjHour < adjMoonOverhead) ? moonXYZ[0] : moonShadeXYZ[0]; shadeIllumXYZ[1] += (adjHour < adjMoonOverhead) ? moonXYZ[1] : moonShadeXYZ[1]; shadeIllumXYZ[2] += (adjHour < adjMoonOverhead) ? moonXYZ[2] : moonShadeXYZ[2]; ALOGV("Direct XYZ: %f, %f, %f", directIllumXYZ[0],directIllumXYZ[1],directIllumXYZ[2]); ALOGV("Shade XYZ: %f, %f, %f", shadeIllumXYZ[0], shadeIllumXYZ[1], shadeIllumXYZ[2]); for (int i = 0; i < NUM_MATERIALS; i++) { // Converting for xyY to XYZ: // X = Y / y * x // Y = Y // Z = Y / y * (1 - x - y); float matXYZ[3] = { kMaterials_xyY[i][2] / kMaterials_xyY[i][1] * kMaterials_xyY[i][0], kMaterials_xyY[i][2], kMaterials_xyY[i][2] / kMaterials_xyY[i][1] * (1 - kMaterials_xyY[i][0] - kMaterials_xyY[i][1]) }; if (kMaterialsFlags[i] == 0 || kMaterialsFlags[i] & kSky) { matXYZ[0] *= directIllumXYZ[0]; matXYZ[1] *= directIllumXYZ[1]; matXYZ[2] *= directIllumXYZ[2]; } else if (kMaterialsFlags[i] & kShadowed) { matXYZ[0] *= shadeIllumXYZ[0]; matXYZ[1] *= shadeIllumXYZ[1]; matXYZ[2] *= shadeIllumXYZ[2]; } // else if (kMaterialsFlags[i] * kSelfLit), do nothing ALOGV("Mat %d XYZ: %f, %f, %f", i, matXYZ[0], matXYZ[1], matXYZ[2]); float luxToElectrons = mSensorSensitivity * mExposureDuration / (kAperture * kAperture); mCurrentColors[i*NUM_CHANNELS + 0] = (mFilterR[0] * matXYZ[0] + mFilterR[1] * matXYZ[1] + mFilterR[2] * matXYZ[2]) * luxToElectrons; mCurrentColors[i*NUM_CHANNELS + 1] = (mFilterGr[0] * matXYZ[0] + mFilterGr[1] * matXYZ[1] + mFilterGr[2] * matXYZ[2]) * luxToElectrons; mCurrentColors[i*NUM_CHANNELS + 2] = (mFilterGb[0] * matXYZ[0] + mFilterGb[1] * matXYZ[1] + mFilterGb[2] * matXYZ[2]) * luxToElectrons; mCurrentColors[i*NUM_CHANNELS + 3] = (mFilterB[0] * matXYZ[0] + mFilterB[1] * matXYZ[1] + mFilterB[2] * matXYZ[2]) * luxToElectrons; ALOGV("Color %d RGGB: %d, %d, %d, %d", i, mCurrentColors[i*NUM_CHANNELS + 0], mCurrentColors[i*NUM_CHANNELS + 1], mCurrentColors[i*NUM_CHANNELS + 2], mCurrentColors[i*NUM_CHANNELS + 3]); } // Shake viewpoint; horizontal and vertical sinusoids at roughly // human handshake frequencies mHandshakeX = ( kFreq1Magnitude * std::sin(kHorizShakeFreq1 * timeSinceIdx) + kFreq2Magnitude * std::sin(kHorizShakeFreq2 * timeSinceIdx) ) * mMapDiv * kShakeFraction; mHandshakeY = ( kFreq1Magnitude * std::sin(kVertShakeFreq1 * timeSinceIdx) + kFreq2Magnitude * std::sin(kVertShakeFreq2 * timeSinceIdx) ) * mMapDiv * kShakeFraction; // Set starting pixel setReadoutPixel(0,0); } void Scene::setReadoutPixel(int x, int y) { mCurrentX = x; mCurrentY = y; mSubX = (x + mOffsetX + mHandshakeX) % mMapDiv; mSubY = (y + mOffsetY + mHandshakeY) % mMapDiv; mSceneX = (x + mOffsetX + mHandshakeX) / mMapDiv; mSceneY = (y + mOffsetY + mHandshakeY) / mMapDiv; mSceneIdx = mSceneY * kSceneWidth + mSceneX; mCurrentSceneMaterial = &(mCurrentColors[kScene[mSceneIdx]]); } const uint32_t* Scene::getPixelElectrons() { const uint32_t *pixel = mCurrentSceneMaterial; mCurrentX++; mSubX++; if (mCurrentX >= mSensorWidth) { mCurrentX = 0; mCurrentY++; if (mCurrentY >= mSensorHeight) mCurrentY = 0; setReadoutPixel(mCurrentX, mCurrentY); } else if (mSubX > mMapDiv) { mSceneIdx++; mSceneX++; mCurrentSceneMaterial = &(mCurrentColors[kScene[mSceneIdx]]); mSubX = 0; } return pixel; } // Handshake model constants. // Frequencies measured in a nanosecond timebase const float Scene::kHorizShakeFreq1 = 2 * M_PI * 2 / 1e9; // 2 Hz const float Scene::kHorizShakeFreq2 = 2 * M_PI * 13 / 1e9; // 13 Hz const float Scene::kVertShakeFreq1 = 2 * M_PI * 3 / 1e9; // 3 Hz const float Scene::kVertShakeFreq2 = 2 * M_PI * 11 / 1e9; // 1 Hz const float Scene::kFreq1Magnitude = 5; const float Scene::kFreq2Magnitude = 1; const float Scene::kShakeFraction = 0.03; // As a fraction of a scene tile // RGB->YUV, Jpeg standard const float Scene::kRgb2Yuv[12] = { 0.299f, 0.587f, 0.114f, 0.f, -0.16874f, -0.33126f, 0.5f, -128.f, 0.5f, -0.41869f, -0.08131f, -128.f, }; // Aperture of imaging lens const float Scene::kAperture = 2.8; // Sun illumination levels through the day const float Scene::kSunlight[24/kTimeStep] = { 0, // 00:00 0, 0, kTwilightIllum, // 06:00 kDirectSunIllum, kDirectSunIllum, kDirectSunIllum, // 12:00 kDirectSunIllum, kDirectSunIllum, kSunsetIllum, // 18:00 kTwilightIllum, 0 }; // Moon illumination levels through the day const float Scene::kMoonlight[24/kTimeStep] = { kFullMoonIllum, // 00:00 kFullMoonIllum, 0, 0, // 06:00 0, 0, 0, // 12:00 0, 0, 0, // 18:00 0, kFullMoonIllum }; const int Scene::kSunOverhead = 12; const int Scene::kMoonOverhead = 0; // Used for sun illumination levels const float Scene::kDirectSunIllum = 100000; const float Scene::kSunsetIllum = 400; const float Scene::kTwilightIllum = 4; // Used for moon illumination levels const float Scene::kFullMoonIllum = 1; // Other illumination levels const float Scene::kDaylightShadeIllum = 20000; const float Scene::kClearNightIllum = 2e-3; const float Scene::kStarIllum = 2e-6; const float Scene::kLivingRoomIllum = 50; const float Scene::kIncandescentXY[2] = { 0.44757f, 0.40745f}; const float Scene::kDirectSunlightXY[2] = { 0.34842f, 0.35161f}; const float Scene::kDaylightXY[2] = { 0.31271f, 0.32902f}; const float Scene::kNoonSkyXY[2] = { 0.346f, 0.359f}; const float Scene::kMoonlightXY[2] = { 0.34842f, 0.35161f}; const float Scene::kSunsetXY[2] = { 0.527f, 0.413f}; const uint8_t Scene::kSelfLit = 0x01; const uint8_t Scene::kShadowed = 0x02; const uint8_t Scene::kSky = 0x04; // For non-self-lit materials, the Y component is normalized with 1=full // reflectance; for self-lit materials, it's the constant illuminance in lux. const float Scene::kMaterials_xyY[Scene::NUM_MATERIALS][3] = { { 0.3688f, 0.4501f, .1329f }, // GRASS { 0.3688f, 0.4501f, .1329f }, // GRASS_SHADOW { 0.3986f, 0.5002f, .4440f }, // HILL { 0.3262f, 0.5040f, .2297f }, // WALL { 0.4336f, 0.3787f, .1029f }, // ROOF { 0.3316f, 0.2544f, .0639f }, // DOOR { 0.3425f, 0.3577f, .0887f }, // CHIMNEY { kIncandescentXY[0], kIncandescentXY[1], kLivingRoomIllum }, // WINDOW { kDirectSunlightXY[0], kDirectSunlightXY[1], kDirectSunIllum }, // SUN { kNoonSkyXY[0], kNoonSkyXY[1], kDaylightShadeIllum / kDirectSunIllum }, // SKY { kMoonlightXY[0], kMoonlightXY[1], kFullMoonIllum } // MOON }; const uint8_t Scene::kMaterialsFlags[Scene::NUM_MATERIALS] = { 0, kShadowed, kShadowed, kShadowed, kShadowed, kShadowed, kShadowed, kSelfLit, kSelfLit, kSky, kSelfLit, }; } // namespace android anbox-0.0~git20191115/android/camera/fake-pipeline2/Scene.h000066400000000000000000000127611356361734700231050ustar00rootroot00000000000000/* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * The Scene class implements a simple physical simulation of a scene, using the * CIE 1931 colorspace to represent light in physical units (lux). * * It's fairly approximate, but does provide a scene with realistic widely * variable illumination levels and colors over time. * */ #ifndef HW_EMULATOR_CAMERA2_SCENE_H #define HW_EMULATOR_CAMERA2_SCENE_H #include "utils/Timers.h" namespace android { class Scene { public: Scene(int sensorWidthPx, int sensorHeightPx, float sensorSensitivity); ~Scene(); // Set the filter coefficients for the red, green, and blue filters on the // sensor. Used as an optimization to pre-calculate various illuminance // values. Two different green filters can be provided, to account for // possible cross-talk on a Bayer sensor. Must be called before // calculateScene. void setColorFilterXYZ( float rX, float rY, float rZ, float grX, float grY, float grZ, float gbX, float gbY, float gbZ, float bX, float bY, float bZ); // Set time of day (24-hour clock). This controls the general light levels // in the scene. Must be called before calculateScene void setHour(int hour); // Get current hour int getHour(); // Set the duration of exposure for determining luminous exposure. // Must be called before calculateScene void setExposureDuration(float seconds); // Calculate scene information for current hour and the time offset since // the hour. Must be called at least once before calling getLuminousExposure. // Resets pixel readout location to 0,0 void calculateScene(nsecs_t time); // Set sensor pixel readout location. void setReadoutPixel(int x, int y); // Get sensor response in physical units (electrons) for light hitting the // current readout pixel, after passing through color filters. The readout // pixel will be auto-incremented. The returned array can be indexed with // ColorChannels. const uint32_t* getPixelElectrons(); enum ColorChannels { R = 0, Gr, Gb, B, Y, Cb, Cr, NUM_CHANNELS }; private: // Sensor color filtering coefficients in XYZ float mFilterR[3]; float mFilterGr[3]; float mFilterGb[3]; float mFilterB[3]; int mOffsetX, mOffsetY; int mMapDiv; int mHandshakeX, mHandshakeY; int mSensorWidth; int mSensorHeight; int mCurrentX; int mCurrentY; int mSubX; int mSubY; int mSceneX; int mSceneY; int mSceneIdx; uint32_t *mCurrentSceneMaterial; int mHour; float mExposureDuration; float mSensorSensitivity; enum Materials { GRASS = 0, GRASS_SHADOW, HILL, WALL, ROOF, DOOR, CHIMNEY, WINDOW, SUN, SKY, MOON, NUM_MATERIALS }; uint32_t mCurrentColors[NUM_MATERIALS*NUM_CHANNELS]; /** * Constants for scene definition. These are various degrees of approximate. */ // Fake handshake parameters. Two shake frequencies per axis, plus magnitude // as a fraction of a scene tile, and relative magnitudes for the frequencies static const float kHorizShakeFreq1; static const float kHorizShakeFreq2; static const float kVertShakeFreq1; static const float kVertShakeFreq2; static const float kFreq1Magnitude; static const float kFreq2Magnitude; static const float kShakeFraction; // RGB->YUV conversion static const float kRgb2Yuv[12]; // Aperture of imaging lens static const float kAperture; // Sun, moon illuminance levels in 2-hour increments. These don't match any // real day anywhere. static const uint32_t kTimeStep = 2; static const float kSunlight[]; static const float kMoonlight[]; static const int kSunOverhead; static const int kMoonOverhead; // Illumination levels for various conditions, in lux static const float kDirectSunIllum; static const float kDaylightShadeIllum; static const float kSunsetIllum; static const float kTwilightIllum; static const float kFullMoonIllum; static const float kClearNightIllum; static const float kStarIllum; static const float kLivingRoomIllum; // Chromaticity of various illumination sources static const float kIncandescentXY[2]; static const float kDirectSunlightXY[2]; static const float kDaylightXY[2]; static const float kNoonSkyXY[2]; static const float kMoonlightXY[2]; static const float kSunsetXY[2]; static const uint8_t kSelfLit; static const uint8_t kShadowed; static const uint8_t kSky; static const float kMaterials_xyY[NUM_MATERIALS][3]; static const uint8_t kMaterialsFlags[NUM_MATERIALS]; static const int kSceneWidth; static const int kSceneHeight; static const uint8_t kScene[]; }; } #endif // HW_EMULATOR_CAMERA2_SCENE_H anbox-0.0~git20191115/android/camera/fake-pipeline2/Sensor.cpp000066400000000000000000000525251356361734700236560ustar00rootroot00000000000000/* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ //#define LOG_NDEBUG 0 //#define LOG_NNDEBUG 0 #define LOG_TAG "EmulatedCamera2_Sensor" #ifdef LOG_NNDEBUG #define ALOGVV(...) ALOGV(__VA_ARGS__) #else #define ALOGVV(...) ((void)0) #endif #include #include "../EmulatedFakeCamera2.h" #include "Sensor.h" #include #include #include "system/camera_metadata.h" namespace android { const unsigned int Sensor::kResolution[2] = {640, 480}; const unsigned int Sensor::kActiveArray[4] = {0, 0, 640, 480}; //const nsecs_t Sensor::kExposureTimeRange[2] = // {1000L, 30000000000L} ; // 1 us - 30 sec //const nsecs_t Sensor::kFrameDurationRange[2] = // {33331760L, 30000000000L}; // ~1/30 s - 30 sec const nsecs_t Sensor::kExposureTimeRange[2] = {1000L, 300000000L} ; // 1 us - 0.3 sec const nsecs_t Sensor::kFrameDurationRange[2] = {33331760L, 300000000L}; // ~1/30 s - 0.3 sec const nsecs_t Sensor::kMinVerticalBlank = 10000L; const uint8_t Sensor::kColorFilterArrangement = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGGB; // Output image data characteristics const uint32_t Sensor::kMaxRawValue = 4000; const uint32_t Sensor::kBlackLevel = 1000; // Sensor sensitivity const float Sensor::kSaturationVoltage = 0.520f; const uint32_t Sensor::kSaturationElectrons = 2000; const float Sensor::kVoltsPerLuxSecond = 0.100f; const float Sensor::kElectronsPerLuxSecond = Sensor::kSaturationElectrons / Sensor::kSaturationVoltage * Sensor::kVoltsPerLuxSecond; const float Sensor::kBaseGainFactor = (float)Sensor::kMaxRawValue / Sensor::kSaturationElectrons; const float Sensor::kReadNoiseStddevBeforeGain = 1.177; // in electrons const float Sensor::kReadNoiseStddevAfterGain = 2.100; // in digital counts const float Sensor::kReadNoiseVarBeforeGain = Sensor::kReadNoiseStddevBeforeGain * Sensor::kReadNoiseStddevBeforeGain; const float Sensor::kReadNoiseVarAfterGain = Sensor::kReadNoiseStddevAfterGain * Sensor::kReadNoiseStddevAfterGain; // While each row has to read out, reset, and then expose, the (reset + // expose) sequence can be overlapped by other row readouts, so the final // minimum frame duration is purely a function of row readout time, at least // if there's a reasonable number of rows. const nsecs_t Sensor::kRowReadoutTime = Sensor::kFrameDurationRange[0] / Sensor::kResolution[1]; const int32_t Sensor::kSensitivityRange[2] = {100, 1600}; const uint32_t Sensor::kDefaultSensitivity = 100; /** A few utility functions for math, normal distributions */ // Take advantage of IEEE floating-point format to calculate an approximate // square root. Accurate to within +-3.6% float sqrtf_approx(float r) { // Modifier is based on IEEE floating-point representation; the // manipulations boil down to finding approximate log2, dividing by two, and // then inverting the log2. A bias is added to make the relative error // symmetric about the real answer. const int32_t modifier = 0x1FBB4000; int32_t r_i = *(int32_t*)(&r); r_i = (r_i >> 1) + modifier; return *(float*)(&r_i); } Sensor::Sensor(): Thread(false), mGotVSync(false), mExposureTime(kFrameDurationRange[0]-kMinVerticalBlank), mFrameDuration(kFrameDurationRange[0]), mGainFactor(kDefaultSensitivity), mNextBuffers(NULL), mFrameNumber(0), mCapturedBuffers(NULL), mListener(NULL), mScene(kResolution[0], kResolution[1], kElectronsPerLuxSecond) { } Sensor::~Sensor() { shutDown(); } status_t Sensor::startUp() { ALOGV("%s: E", __FUNCTION__); int res; mCapturedBuffers = NULL; res = run("EmulatedFakeCamera2::Sensor", ANDROID_PRIORITY_URGENT_DISPLAY); if (res != OK) { ALOGE("Unable to start up sensor capture thread: %d", res); } return res; } status_t Sensor::shutDown() { ALOGV("%s: E", __FUNCTION__); int res; res = requestExitAndWait(); if (res != OK) { ALOGE("Unable to shut down sensor capture thread: %d", res); } return res; } Scene &Sensor::getScene() { return mScene; } void Sensor::setExposureTime(uint64_t ns) { Mutex::Autolock lock(mControlMutex); ALOGVV("Exposure set to %f", ns/1000000.f); mExposureTime = ns; } void Sensor::setFrameDuration(uint64_t ns) { Mutex::Autolock lock(mControlMutex); ALOGVV("Frame duration set to %f", ns/1000000.f); mFrameDuration = ns; } void Sensor::setSensitivity(uint32_t gain) { Mutex::Autolock lock(mControlMutex); ALOGVV("Gain set to %d", gain); mGainFactor = gain; } void Sensor::setDestinationBuffers(Buffers *buffers) { Mutex::Autolock lock(mControlMutex); mNextBuffers = buffers; } void Sensor::setFrameNumber(uint32_t frameNumber) { Mutex::Autolock lock(mControlMutex); mFrameNumber = frameNumber; } bool Sensor::waitForVSync(nsecs_t reltime) { int res; Mutex::Autolock lock(mControlMutex); mGotVSync = false; res = mVSync.waitRelative(mControlMutex, reltime); if (res != OK && res != TIMED_OUT) { ALOGE("%s: Error waiting for VSync signal: %d", __FUNCTION__, res); return false; } return mGotVSync; } bool Sensor::waitForNewFrame(nsecs_t reltime, nsecs_t *captureTime) { Mutex::Autolock lock(mReadoutMutex); uint8_t *ret; if (mCapturedBuffers == NULL) { int res; res = mReadoutAvailable.waitRelative(mReadoutMutex, reltime); if (res == TIMED_OUT) { return false; } else if (res != OK || mCapturedBuffers == NULL) { ALOGE("Error waiting for sensor readout signal: %d", res); return false; } } else { mReadoutComplete.signal(); } *captureTime = mCaptureTime; mCapturedBuffers = NULL; return true; } Sensor::SensorListener::~SensorListener() { } void Sensor::setSensorListener(SensorListener *listener) { Mutex::Autolock lock(mControlMutex); mListener = listener; } status_t Sensor::readyToRun() { ALOGV("Starting up sensor thread"); mStartupTime = systemTime(); mNextCaptureTime = 0; mNextCapturedBuffers = NULL; return OK; } bool Sensor::threadLoop() { /** * Sensor capture operation main loop. * * Stages are out-of-order relative to a single frame's processing, but * in-order in time. */ /** * Stage 1: Read in latest control parameters */ uint64_t exposureDuration; uint64_t frameDuration; uint32_t gain; Buffers *nextBuffers; uint32_t frameNumber; SensorListener *listener = NULL; { Mutex::Autolock lock(mControlMutex); exposureDuration = mExposureTime; frameDuration = mFrameDuration; gain = mGainFactor; nextBuffers = mNextBuffers; frameNumber = mFrameNumber; listener = mListener; // Don't reuse a buffer set mNextBuffers = NULL; // Signal VSync for start of readout ALOGVV("Sensor VSync"); mGotVSync = true; mVSync.signal(); } /** * Stage 3: Read out latest captured image */ Buffers *capturedBuffers = NULL; nsecs_t captureTime = 0; nsecs_t startRealTime = systemTime(); // Stagefright cares about system time for timestamps, so base simulated // time on that. nsecs_t simulatedTime = startRealTime; nsecs_t frameEndRealTime = startRealTime + frameDuration; nsecs_t frameReadoutEndRealTime = startRealTime + kRowReadoutTime * kResolution[1]; if (mNextCapturedBuffers != NULL) { ALOGVV("Sensor starting readout"); // Pretend we're doing readout now; will signal once enough time has elapsed capturedBuffers = mNextCapturedBuffers; captureTime = mNextCaptureTime; } simulatedTime += kRowReadoutTime + kMinVerticalBlank; // TODO: Move this signal to another thread to simulate readout // time properly if (capturedBuffers != NULL) { ALOGVV("Sensor readout complete"); Mutex::Autolock lock(mReadoutMutex); if (mCapturedBuffers != NULL) { ALOGV("Waiting for readout thread to catch up!"); mReadoutComplete.wait(mReadoutMutex); } mCapturedBuffers = capturedBuffers; mCaptureTime = captureTime; mReadoutAvailable.signal(); capturedBuffers = NULL; } /** * Stage 2: Capture new image */ mNextCaptureTime = simulatedTime; mNextCapturedBuffers = nextBuffers; if (mNextCapturedBuffers != NULL) { if (listener != NULL) { listener->onSensorEvent(frameNumber, SensorListener::EXPOSURE_START, mNextCaptureTime); } ALOGVV("Starting next capture: Exposure: %f ms, gain: %d", (float)exposureDuration/1e6, gain); mScene.setExposureDuration((float)exposureDuration/1e9); mScene.calculateScene(mNextCaptureTime); // Might be adding more buffers, so size isn't constant for (size_t i = 0; i < mNextCapturedBuffers->size(); i++) { const StreamBuffer &b = (*mNextCapturedBuffers)[i]; ALOGVV("Sensor capturing buffer %d: stream %d," " %d x %d, format %x, stride %d, buf %p, img %p", i, b.streamId, b.width, b.height, b.format, b.stride, b.buffer, b.img); switch(b.format) { case HAL_PIXEL_FORMAT_RAW16: captureRaw(b.img, gain, b.stride); break; case HAL_PIXEL_FORMAT_RGB_888: captureRGB(b.img, gain, b.stride); break; case HAL_PIXEL_FORMAT_RGBA_8888: captureRGBA(b.img, gain, b.stride); break; case HAL_PIXEL_FORMAT_BLOB: if (b.dataSpace != HAL_DATASPACE_DEPTH) { // Add auxillary buffer of the right size // Assumes only one BLOB (JPEG) buffer in // mNextCapturedBuffers StreamBuffer bAux; bAux.streamId = 0; bAux.width = b.width; bAux.height = b.height; bAux.format = HAL_PIXEL_FORMAT_RGB_888; bAux.stride = b.width; bAux.buffer = NULL; // TODO: Reuse these bAux.img = new uint8_t[b.width * b.height * 3]; mNextCapturedBuffers->push_back(bAux); } else { captureDepthCloud(b.img); } break; case HAL_PIXEL_FORMAT_YCrCb_420_SP: captureNV21(b.img, gain, b.stride); break; case HAL_PIXEL_FORMAT_YV12: // TODO: ALOGE("%s: Format %x is TODO", __FUNCTION__, b.format); break; case HAL_PIXEL_FORMAT_Y16: captureDepth(b.img, gain, b.stride); break; default: ALOGE("%s: Unknown format %x, no output", __FUNCTION__, b.format); break; } } } ALOGVV("Sensor vertical blanking interval"); nsecs_t workDoneRealTime = systemTime(); const nsecs_t timeAccuracy = 2e6; // 2 ms of imprecision is ok if (workDoneRealTime < frameEndRealTime - timeAccuracy) { timespec t; t.tv_sec = (frameEndRealTime - workDoneRealTime) / 1000000000L; t.tv_nsec = (frameEndRealTime - workDoneRealTime) % 1000000000L; int ret; do { ret = nanosleep(&t, &t); } while (ret != 0); } nsecs_t endRealTime = systemTime(); ALOGVV("Frame cycle took %d ms, target %d ms", (int)((endRealTime - startRealTime)/1000000), (int)(frameDuration / 1000000)); return true; }; void Sensor::captureRaw(uint8_t *img, uint32_t gain, uint32_t stride) { float totalGain = gain/100.0 * kBaseGainFactor; float noiseVarGain = totalGain * totalGain; float readNoiseVar = kReadNoiseVarBeforeGain * noiseVarGain + kReadNoiseVarAfterGain; int bayerSelect[4] = {Scene::R, Scene::Gr, Scene::Gb, Scene::B}; // RGGB mScene.setReadoutPixel(0,0); for (unsigned int y = 0; y < kResolution[1]; y++ ) { int *bayerRow = bayerSelect + (y & 0x1) * 2; uint16_t *px = (uint16_t*)img + y * stride; for (unsigned int x = 0; x < kResolution[0]; x++) { uint32_t electronCount; electronCount = mScene.getPixelElectrons()[bayerRow[x & 0x1]]; // TODO: Better pixel saturation curve? electronCount = (electronCount < kSaturationElectrons) ? electronCount : kSaturationElectrons; // TODO: Better A/D saturation curve? uint16_t rawCount = electronCount * totalGain; rawCount = (rawCount < kMaxRawValue) ? rawCount : kMaxRawValue; // Calculate noise value // TODO: Use more-correct Gaussian instead of uniform noise float photonNoiseVar = electronCount * noiseVarGain; float noiseStddev = sqrtf_approx(readNoiseVar + photonNoiseVar); // Scaled to roughly match gaussian/uniform noise stddev float noiseSample = std::rand() * (2.5 / (1.0 + RAND_MAX)) - 1.25; rawCount += kBlackLevel; rawCount += noiseStddev * noiseSample; *px++ = rawCount; } // TODO: Handle this better //simulatedTime += kRowReadoutTime; } ALOGVV("Raw sensor image captured"); } void Sensor::captureRGBA(uint8_t *img, uint32_t gain, uint32_t stride) { float totalGain = gain/100.0 * kBaseGainFactor; // In fixed-point math, calculate total scaling from electrons to 8bpp int scale64x = 64 * totalGain * 255 / kMaxRawValue; uint32_t inc = kResolution[0] / stride; for (unsigned int y = 0, outY = 0; y < kResolution[1]; y+=inc, outY++ ) { uint8_t *px = img + outY * stride * 4; mScene.setReadoutPixel(0, y); for (unsigned int x = 0; x < kResolution[0]; x+=inc) { uint32_t rCount, gCount, bCount; // TODO: Perfect demosaicing is a cheat const uint32_t *pixel = mScene.getPixelElectrons(); rCount = pixel[Scene::R] * scale64x; gCount = pixel[Scene::Gr] * scale64x; bCount = pixel[Scene::B] * scale64x; *px++ = rCount < 255*64 ? rCount / 64 : 255; *px++ = gCount < 255*64 ? gCount / 64 : 255; *px++ = bCount < 255*64 ? bCount / 64 : 255; *px++ = 255; for (unsigned int j = 1; j < inc; j++) mScene.getPixelElectrons(); } // TODO: Handle this better //simulatedTime += kRowReadoutTime; } ALOGVV("RGBA sensor image captured"); } void Sensor::captureRGB(uint8_t *img, uint32_t gain, uint32_t stride) { float totalGain = gain/100.0 * kBaseGainFactor; // In fixed-point math, calculate total scaling from electrons to 8bpp int scale64x = 64 * totalGain * 255 / kMaxRawValue; uint32_t inc = kResolution[0] / stride; for (unsigned int y = 0, outY = 0; y < kResolution[1]; y += inc, outY++ ) { mScene.setReadoutPixel(0, y); uint8_t *px = img + outY * stride * 3; for (unsigned int x = 0; x < kResolution[0]; x += inc) { uint32_t rCount, gCount, bCount; // TODO: Perfect demosaicing is a cheat const uint32_t *pixel = mScene.getPixelElectrons(); rCount = pixel[Scene::R] * scale64x; gCount = pixel[Scene::Gr] * scale64x; bCount = pixel[Scene::B] * scale64x; *px++ = rCount < 255*64 ? rCount / 64 : 255; *px++ = gCount < 255*64 ? gCount / 64 : 255; *px++ = bCount < 255*64 ? bCount / 64 : 255; for (unsigned int j = 1; j < inc; j++) mScene.getPixelElectrons(); } // TODO: Handle this better //simulatedTime += kRowReadoutTime; } ALOGVV("RGB sensor image captured"); } void Sensor::captureNV21(uint8_t *img, uint32_t gain, uint32_t stride) { float totalGain = gain/100.0 * kBaseGainFactor; // Using fixed-point math with 6 bits of fractional precision. // In fixed-point math, calculate total scaling from electrons to 8bpp const int scale64x = 64 * totalGain * 255 / kMaxRawValue; // In fixed-point math, saturation point of sensor after gain const int saturationPoint = 64 * 255; // Fixed-point coefficients for RGB-YUV transform // Based on JFIF RGB->YUV transform. // Cb/Cr offset scaled by 64x twice since they're applied post-multiply const int rgbToY[] = {19, 37, 7}; const int rgbToCb[] = {-10,-21, 32, 524288}; const int rgbToCr[] = {32,-26, -5, 524288}; // Scale back to 8bpp non-fixed-point const int scaleOut = 64; const int scaleOutSq = scaleOut * scaleOut; // after multiplies uint32_t inc = kResolution[0] / stride; uint32_t outH = kResolution[1] / inc; for (unsigned int y = 0, outY = 0; y < kResolution[1]; y+=inc, outY++) { uint8_t *pxY = img + outY * stride; uint8_t *pxVU = img + (outH + outY / 2) * stride; mScene.setReadoutPixel(0,y); for (unsigned int outX = 0; outX < stride; outX++) { int32_t rCount, gCount, bCount; // TODO: Perfect demosaicing is a cheat const uint32_t *pixel = mScene.getPixelElectrons(); rCount = pixel[Scene::R] * scale64x; rCount = rCount < saturationPoint ? rCount : saturationPoint; gCount = pixel[Scene::Gr] * scale64x; gCount = gCount < saturationPoint ? gCount : saturationPoint; bCount = pixel[Scene::B] * scale64x; bCount = bCount < saturationPoint ? bCount : saturationPoint; *pxY++ = (rgbToY[0] * rCount + rgbToY[1] * gCount + rgbToY[2] * bCount) / scaleOutSq; if (outY % 2 == 0 && outX % 2 == 0) { *pxVU++ = (rgbToCr[0] * rCount + rgbToCr[1] * gCount + rgbToCr[2] * bCount + rgbToCr[3]) / scaleOutSq; *pxVU++ = (rgbToCb[0] * rCount + rgbToCb[1] * gCount + rgbToCb[2] * bCount + rgbToCb[3]) / scaleOutSq; } for (unsigned int j = 1; j < inc; j++) mScene.getPixelElectrons(); } } ALOGVV("NV21 sensor image captured"); } void Sensor::captureDepth(uint8_t *img, uint32_t gain, uint32_t stride) { float totalGain = gain/100.0 * kBaseGainFactor; // In fixed-point math, calculate scaling factor to 13bpp millimeters int scale64x = 64 * totalGain * 8191 / kMaxRawValue; uint32_t inc = kResolution[0] / stride; for (unsigned int y = 0, outY = 0; y < kResolution[1]; y += inc, outY++ ) { mScene.setReadoutPixel(0, y); uint16_t *px = ((uint16_t*)img) + outY * stride; for (unsigned int x = 0; x < kResolution[0]; x += inc) { uint32_t depthCount; // TODO: Make up real depth scene instead of using green channel // as depth const uint32_t *pixel = mScene.getPixelElectrons(); depthCount = pixel[Scene::Gr] * scale64x; *px++ = depthCount < 8191*64 ? depthCount / 64 : 0; for (unsigned int j = 1; j < inc; j++) mScene.getPixelElectrons(); } // TODO: Handle this better //simulatedTime += kRowReadoutTime; } ALOGVV("Depth sensor image captured"); } void Sensor::captureDepthCloud(uint8_t *img) { android_depth_points *cloud = reinterpret_cast(img); cloud->num_points = 16; // TODO: Create point cloud values that match RGB scene const int FLOATS_PER_POINT = 4; const float JITTER_STDDEV = 0.1f; for (size_t y = 0, i = 0; y < 4; y++) { for (size_t x = 0; x < 4; x++, i++) { float randSampleX = std::rand() * (2.5f / (1.0f + RAND_MAX)) - 1.25f; randSampleX *= JITTER_STDDEV; float randSampleY = std::rand() * (2.5f / (1.0f + RAND_MAX)) - 1.25f; randSampleY *= JITTER_STDDEV; float randSampleZ = std::rand() * (2.5f / (1.0f + RAND_MAX)) - 1.25f; randSampleZ *= JITTER_STDDEV; cloud->xyzc_points[i * FLOATS_PER_POINT + 0] = x - 1.5f + randSampleX; cloud->xyzc_points[i * FLOATS_PER_POINT + 1] = y - 1.5f + randSampleY; cloud->xyzc_points[i * FLOATS_PER_POINT + 2] = 3.f + randSampleZ; cloud->xyzc_points[i * FLOATS_PER_POINT + 3] = 0.8f; } } ALOGVV("Depth point cloud captured"); } } // namespace android anbox-0.0~git20191115/android/camera/fake-pipeline2/Sensor.h000066400000000000000000000212061356361734700233130ustar00rootroot00000000000000/* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * This class is a simple simulation of a typical CMOS cellphone imager chip, * which outputs 12-bit Bayer-mosaic raw images. * * Unlike most real image sensors, this one's native color space is linear sRGB. * * The sensor is abstracted as operating as a pipeline 3 stages deep; * conceptually, each frame to be captured goes through these three stages. The * processing step for the sensor is marked off by vertical sync signals, which * indicate the start of readout of the oldest frame. The interval between * processing steps depends on the frame duration of the frame currently being * captured. The stages are 1) configure, 2) capture, and 3) readout. During * configuration, the sensor's registers for settings such as exposure time, * frame duration, and gain are set for the next frame to be captured. In stage * 2, the image data for the frame is actually captured by the sensor. Finally, * in stage 3, the just-captured data is read out and sent to the rest of the * system. * * The sensor is assumed to be rolling-shutter, so low-numbered rows of the * sensor are exposed earlier in time than larger-numbered rows, with the time * offset between each row being equal to the row readout time. * * The characteristics of this sensor don't correspond to any actual sensor, * but are not far off typical sensors. * * Example timing diagram, with three frames: * Frame 0-1: Frame duration 50 ms, exposure time 20 ms. * Frame 2: Frame duration 75 ms, exposure time 65 ms. * Legend: * C = update sensor registers for frame * v = row in reset (vertical blanking interval) * E = row capturing image data * R = row being read out * | = vertical sync signal *time(ms)| 0 55 105 155 230 270 * Frame 0| :configure : capture : readout : : : * Row # | ..|CCCC______|_________|_________| : : * 0 | :\ \vvvvvEEEER \ : : * 500 | : \ \vvvvvEEEER \ : : * 1000 | : \ \vvvvvEEEER \ : : * 1500 | : \ \vvvvvEEEER \ : : * 2000 | : \__________\vvvvvEEEER_________\ : : * Frame 1| : configure capture readout : : * Row # | : |CCCC_____|_________|______________| : * 0 | : :\ \vvvvvEEEER \ : * 500 | : : \ \vvvvvEEEER \ : * 1000 | : : \ \vvvvvEEEER \ : * 1500 | : : \ \vvvvvEEEER \ : * 2000 | : : \_________\vvvvvEEEER______________\ : * Frame 2| : : configure capture readout: * Row # | : : |CCCC_____|______________|_______|... * 0 | : : :\ \vEEEEEEEEEEEEER \ * 500 | : : : \ \vEEEEEEEEEEEEER \ * 1000 | : : : \ \vEEEEEEEEEEEEER \ * 1500 | : : : \ \vEEEEEEEEEEEEER \ * 2000 | : : : \_________\vEEEEEEEEEEEEER_______\ */ #ifndef HW_EMULATOR_CAMERA2_SENSOR_H #define HW_EMULATOR_CAMERA2_SENSOR_H #include "utils/Thread.h" #include "utils/Mutex.h" #include "utils/Timers.h" #include "Scene.h" #include "Base.h" namespace android { class EmulatedFakeCamera2; class Sensor: private Thread, public virtual RefBase { public: Sensor(); ~Sensor(); /* * Power control */ status_t startUp(); status_t shutDown(); /* * Access to scene */ Scene &getScene(); /* * Controls that can be updated every frame */ void setExposureTime(uint64_t ns); void setFrameDuration(uint64_t ns); void setSensitivity(uint32_t gain); // Buffer must be at least stride*height*2 bytes in size void setDestinationBuffers(Buffers *buffers); // To simplify tracking sensor's current frame void setFrameNumber(uint32_t frameNumber); /* * Controls that cause reconfiguration delay */ void setBinning(int horizontalFactor, int verticalFactor); /* * Synchronizing with sensor operation (vertical sync) */ // Wait until the sensor outputs its next vertical sync signal, meaning it // is starting readout of its latest frame of data. Returns true if vertical // sync is signaled, false if the wait timed out. bool waitForVSync(nsecs_t reltime); // Wait until a new frame has been read out, and then return the time // capture started. May return immediately if a new frame has been pushed // since the last wait for a new frame. Returns true if new frame is // returned, false if timed out. bool waitForNewFrame(nsecs_t reltime, nsecs_t *captureTime); /* * Interrupt event servicing from the sensor. Only triggers for sensor * cycles that have valid buffers to write to. */ struct SensorListener { enum Event { EXPOSURE_START, // Start of exposure }; virtual void onSensorEvent(uint32_t frameNumber, Event e, nsecs_t timestamp) = 0; virtual ~SensorListener(); }; void setSensorListener(SensorListener *listener); /** * Static sensor characteristics */ static const unsigned int kResolution[2]; static const unsigned int kActiveArray[4]; static const nsecs_t kExposureTimeRange[2]; static const nsecs_t kFrameDurationRange[2]; static const nsecs_t kMinVerticalBlank; static const uint8_t kColorFilterArrangement; // Output image data characteristics static const uint32_t kMaxRawValue; static const uint32_t kBlackLevel; // Sensor sensitivity, approximate static const float kSaturationVoltage; static const uint32_t kSaturationElectrons; static const float kVoltsPerLuxSecond; static const float kElectronsPerLuxSecond; static const float kBaseGainFactor; static const float kReadNoiseStddevBeforeGain; // In electrons static const float kReadNoiseStddevAfterGain; // In raw digital units static const float kReadNoiseVarBeforeGain; static const float kReadNoiseVarAfterGain; // While each row has to read out, reset, and then expose, the (reset + // expose) sequence can be overlapped by other row readouts, so the final // minimum frame duration is purely a function of row readout time, at least // if there's a reasonable number of rows. static const nsecs_t kRowReadoutTime; static const int32_t kSensitivityRange[2]; static const uint32_t kDefaultSensitivity; private: Mutex mControlMutex; // Lock before accessing control parameters // Start of control parameters Condition mVSync; bool mGotVSync; uint64_t mExposureTime; uint64_t mFrameDuration; uint32_t mGainFactor; Buffers *mNextBuffers; uint32_t mFrameNumber; // End of control parameters Mutex mReadoutMutex; // Lock before accessing readout variables // Start of readout variables Condition mReadoutAvailable; Condition mReadoutComplete; Buffers *mCapturedBuffers; nsecs_t mCaptureTime; SensorListener *mListener; // End of readout variables // Time of sensor startup, used for simulation zero-time point nsecs_t mStartupTime; /** * Inherited Thread virtual overrides, and members only used by the * processing thread */ private: virtual status_t readyToRun(); virtual bool threadLoop(); nsecs_t mNextCaptureTime; Buffers *mNextCapturedBuffers; Scene mScene; void captureRaw(uint8_t *img, uint32_t gain, uint32_t stride); void captureRGBA(uint8_t *img, uint32_t gain, uint32_t stride); void captureRGB(uint8_t *img, uint32_t gain, uint32_t stride); void captureNV21(uint8_t *img, uint32_t gain, uint32_t stride); void captureDepth(uint8_t *img, uint32_t gain, uint32_t stride); void captureDepthCloud(uint8_t *img); }; } #endif // HW_EMULATOR_CAMERA2_SENSOR_H anbox-0.0~git20191115/android/data/000077500000000000000000000000001356361734700165565ustar00rootroot00000000000000anbox-0.0~git20191115/android/data/etc/000077500000000000000000000000001356361734700173315ustar00rootroot00000000000000anbox-0.0~git20191115/android/data/etc/apns-conf.xml000066400000000000000000000146571356361734700217540ustar00rootroot00000000000000 anbox-0.0~git20191115/android/fingerprint/000077500000000000000000000000001356361734700201745ustar00rootroot00000000000000anbox-0.0~git20191115/android/fingerprint/Android.mk000066400000000000000000000017661356361734700221170ustar00rootroot00000000000000# Copyright (C) 2013 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) LOCAL_MODULE := fingerprint.goldfish LOCAL_MODULE_RELATIVE_PATH := hw LOCAL_SRC_FILES := fingerprint.c LOCAL_SHARED_LIBRARIES := liblog include $(BUILD_SHARED_LIBRARY) include $(CLEAR_VARS) LOCAL_MODULE := fingerprint.ranchu LOCAL_MODULE_RELATIVE_PATH := hw LOCAL_SRC_FILES := fingerprint.c LOCAL_SHARED_LIBRARIES := liblog include $(BUILD_SHARED_LIBRARY) anbox-0.0~git20191115/android/fingerprint/fingerprint.c000066400000000000000000000737221356361734700227020ustar00rootroot00000000000000/* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * This is a very basic implementation of fingerprint to allow testing on the emulator. It * is *not* meant to be the final implementation on real devices. For example, it does *not* * implement all of the required features, such as secure template storage and recognition * inside a Trusted Execution Environment (TEE). However, this file is a reasonable starting * point as developers add fingerprint support to their platform. See inline comments and * recommendations for details. * * Please see the Android Compatibility Definition Document (CDD) for a full list of requirements * and suggestions. */ #define LOG_TAG "FingerprintHal" #include #include #include #include #include #include #include #include #include #include #define FINGERPRINT_LISTEN_SERVICE_NAME "fingerprintlisten" #define FINGERPRINT_FILENAME "emufp.bin" #define AUTHENTICATOR_ID_FILENAME "emuauthid.bin" #define MAX_COMM_CHARS 128 #define MAX_COMM_ERRORS 8 // Typical devices will allow up to 5 fingerprints per user to maintain performance of // t < 500ms for recognition. This is the total number of fingerprints we'll store. #define MAX_NUM_FINGERS 20 #define MAX_FID_VALUE 0x7FFFFFFF // Arbitrary limit /** * Most devices will have an internal state machine resembling this. There are 3 basic states, as * shown below. When device is not authenticating or enrolling, it is expected to be in * the idle state. * * Note that this is completely independent of device wake state. If the hardware device was in * the "scan" state when the device drops into power collapse, it should resume scanning when power * is restored. This is to facilitate rapid touch-to-unlock from keyguard. */ typedef enum worker_state_t { STATE_IDLE = 0, STATE_ENROLL, STATE_SCAN, STATE_EXIT } worker_state_t; typedef struct worker_thread_t { pthread_t thread; worker_state_t state; uint64_t secureid[MAX_NUM_FINGERS]; uint64_t fingerid[MAX_NUM_FINGERS]; char fp_filename[PATH_MAX]; char authid_filename[PATH_MAX]; } worker_thread_t; typedef struct qemu_fingerprint_device_t { fingerprint_device_t device; // "inheritance" worker_thread_t listener; uint64_t op_id; uint64_t challenge; uint64_t user_id; uint64_t group_id; uint64_t secure_user_id; uint64_t authenticator_id; int qchanfd; pthread_mutex_t lock; } qemu_fingerprint_device_t; /******************************************************************************/ static FILE* openForWrite(const char* filename); static void saveFingerprint(worker_thread_t* listener, int idx) { ALOGD("----------------> %s -----------------> idx %d", __FUNCTION__, idx); // Save fingerprints to file FILE* fp = openForWrite(listener->fp_filename); if (fp == NULL) { ALOGE("Could not open fingerprints storage at %s; " "fingerprints won't be saved", listener->fp_filename); perror("Failed to open file"); return; } ALOGD("Write fingerprint[%d] (0x%" PRIx64 ",0x%" PRIx64 ")", idx, listener->secureid[idx], listener->fingerid[idx]); if (fseek(fp, (idx) * sizeof(uint64_t), SEEK_SET) < 0) { ALOGE("Failed while seeking for fingerprint[%d] in emulator storage", idx); fclose(fp); return; } int ns = fwrite(&listener->secureid[idx], sizeof(uint64_t), 1, fp); if (fseek(fp, (MAX_NUM_FINGERS + idx) * sizeof(uint64_t), SEEK_SET) < 0) { ALOGE("Failed while seeking for fingerprint[%d] in emulator storage", idx); fclose(fp); return; } int nf = fwrite(&listener->fingerid[idx], sizeof(uint64_t), 1, fp); if (ns != 1 || ns !=1) ALOGW("Corrupt emulator fingerprints storage; could not save " "fingerprints"); fclose(fp); return; } static FILE* openForWrite(const char* filename) { if (!filename) return NULL; FILE* fp = fopen(filename, "r+"); // write but don't truncate if (fp == NULL) { fp = fopen(filename, "w"); if (fp) { uint64_t zero = 0; int i = 0; for (i = 0; i < 2*MAX_NUM_FINGERS; ++i) { fwrite(&zero, sizeof(uint64_t), 1, fp); } //the last one is for authenticator id fwrite(&zero, sizeof(uint64_t), 1, fp); } } return fp; } static void saveAuthenticatorId(const char* filename, uint64_t authenid) { ALOGD("----------------> %s ----------------->", __FUNCTION__); FILE* fp = openForWrite(filename); if (!fp) { ALOGE("Failed to open emulator storage file to save authenticator id"); return; } rewind(fp); int na = fwrite(&authenid, sizeof(authenid), 1, fp); if (na != 1) { ALOGE("Failed while writing authenticator id in emulator storage"); } ALOGD("Save authenticator id (0x%" PRIx64 ")", authenid); fclose(fp); } static void loadAuthenticatorId(const char* authid_filename, uint64_t* pauthenid) { ALOGD("----------------> %s ----------------->", __FUNCTION__); FILE* fp = fopen(authid_filename, "r"); if (fp == NULL) { ALOGE("Could not load authenticator id from storage at %s; " "it has not yet been created.", authid_filename); perror("Failed to open/create file"); return; } rewind(fp); int na = fread(pauthenid, sizeof(*pauthenid), 1, fp); if (na != 1) ALOGW("Corrupt emulator authenticator id storage (read %d)", na); ALOGD("Read authenticator id (0x%" PRIx64 ")", *pauthenid); fclose(fp); return; } static void loadFingerprints(worker_thread_t* listener) { ALOGD("----------------> %s ----------------->", __FUNCTION__); FILE* fp = fopen(listener->fp_filename, "r"); if (fp == NULL) { ALOGE("Could not load fingerprints from storage at %s; " "it has not yet been created.", listener->fp_filename); perror("Failed to open/create file"); return; } int ns = fread(listener->secureid, MAX_NUM_FINGERS * sizeof(uint64_t), 1, fp); int nf = fread(listener->fingerid, MAX_NUM_FINGERS * sizeof(uint64_t), 1, fp); if (ns != 1 || nf != 1) ALOGW("Corrupt emulator fingerprints storage (read %d+%db)", ns, nf); int i = 0; for (i = 0; i < MAX_NUM_FINGERS; i++) ALOGD("Read fingerprint %d (0x%" PRIx64 ",0x%" PRIx64 ")", i, listener->secureid[i], listener->fingerid[i]); fclose(fp); return; } /******************************************************************************/ static uint64_t get_64bit_rand() { // This should use a cryptographically-secure random number generator like arc4random(). // It should be generated inside of the TEE where possible. Here we just use something // very simple. ALOGD("----------------> %s ----------------->", __FUNCTION__); uint64_t r = (((uint64_t)rand()) << 32) | ((uint64_t)rand()); return r != 0 ? r : 1; } static uint64_t fingerprint_get_auth_id(struct fingerprint_device* device) { // This should return the authentication_id generated when the fingerprint template database // was created. Though this isn't expected to be secret, it is reasonable to expect it to be // cryptographically generated to avoid replay attacks. qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)device; ALOGD("----------------> %s ----------------->", __FUNCTION__); uint64_t authenticator_id = 0; pthread_mutex_lock(&qdev->lock); authenticator_id = qdev->authenticator_id; pthread_mutex_unlock(&qdev->lock); ALOGD("----------------> %s auth id %" PRIx64 "----------------->", __FUNCTION__, authenticator_id); return authenticator_id; } static int fingerprint_set_active_group(struct fingerprint_device *device, uint32_t gid, const char *path) { ALOGD("----------------> %s -----------------> path %s", __FUNCTION__, path); qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)device; pthread_mutex_lock(&qdev->lock); qdev->group_id = gid; snprintf(qdev->listener.fp_filename, sizeof(qdev->listener.fp_filename), "%s/%s", path, FINGERPRINT_FILENAME); snprintf(qdev->listener.authid_filename, sizeof(qdev->listener.authid_filename), "%s/%s", path, AUTHENTICATOR_ID_FILENAME); uint64_t authenticator_id = 0; loadFingerprints(&qdev->listener); loadAuthenticatorId(qdev->listener.authid_filename, &authenticator_id); if (authenticator_id == 0) { // firs time, create an authenticator id authenticator_id = get_64bit_rand(); // save it to disk saveAuthenticatorId(qdev->listener.authid_filename, authenticator_id); } qdev->authenticator_id = authenticator_id; pthread_mutex_unlock(&qdev->lock); return 0; } /** * If fingerprints are enrolled, then this function is expected to put the sensor into a * "scanning" state where it's actively scanning and recognizing fingerprint features. * Actual authentication must happen in TEE and should be monitored in a separate thread * since this function is expected to return immediately. */ static int fingerprint_authenticate(struct fingerprint_device *device, uint64_t operation_id, __unused uint32_t gid) { qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)device; pthread_mutex_lock(&qdev->lock); qdev->op_id = operation_id; qdev->listener.state = STATE_SCAN; pthread_mutex_unlock(&qdev->lock); return 0; } /** * This is expected to put the sensor into an "enroll" state where it's actively scanning and * working towards a finished fingerprint database entry. Authentication must happen in * a separate thread since this function is expected to return immediately. * * Note: This method should always generate a new random authenticator_id. * * Note: As with fingerprint_authenticate(), this would run in TEE on a real device. */ static int fingerprint_enroll(struct fingerprint_device *device, const hw_auth_token_t *hat, uint32_t __unused gid, uint32_t __unused timeout_sec) { ALOGD("fingerprint_enroll"); qemu_fingerprint_device_t* dev = (qemu_fingerprint_device_t*)device; if (!hat) { ALOGW("%s: null auth token", __func__); return -EPROTONOSUPPORT; } if (hat->challenge == dev->challenge) { // The secure_user_id retrieved from the auth token should be stored // with the enrolled fingerprint template and returned in the auth result // for a successful authentication with that finger. dev->secure_user_id = hat->user_id; } else { ALOGW("%s: invalid auth token", __func__); } if (hat->version != HW_AUTH_TOKEN_VERSION) { return -EPROTONOSUPPORT; } if (hat->challenge != dev->challenge && !(hat->authenticator_type & HW_AUTH_FINGERPRINT)) { return -EPERM; } dev->user_id = hat->user_id; pthread_mutex_lock(&dev->lock); dev->listener.state = STATE_ENROLL; pthread_mutex_unlock(&dev->lock); // fingerprint id, authenticator id, and secure_user_id // will be stored by worked thread return 0; } /** * The pre-enrollment step is simply to get an authentication token that can be wrapped and * verified at a later step. The primary purpose is to return a token that protects against * spoofing and replay attacks. It is passed to password authentication where it is wrapped and * propagated to the enroll step. */ static uint64_t fingerprint_pre_enroll(struct fingerprint_device *device) { ALOGD("----------------> %s ----------------->", __FUNCTION__); uint64_t challenge = 0; qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)device; // The challenge will typically be a cryptographically-secure key // coming from the TEE so it can be verified at a later step. For now we just generate a // random value. challenge = get_64bit_rand(); pthread_mutex_lock(&qdev->lock); qdev->challenge = challenge; pthread_mutex_unlock(&qdev->lock); return challenge; } static int fingerprint_post_enroll(struct fingerprint_device* device) { ALOGD("----------------> %s ----------------->", __FUNCTION__); qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)device; pthread_mutex_lock(&qdev->lock); qdev->challenge = 0; pthread_mutex_unlock(&qdev->lock); return 0; } /** * Cancel is called by the framework to cancel an outstanding event. This should *not* be called * by the driver since it will cause the framework to stop listening for fingerprints. */ static int fingerprint_cancel(struct fingerprint_device *device) { ALOGD("----------------> %s ----------------->", __FUNCTION__); qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)device; pthread_mutex_lock(&qdev->lock); qdev->listener.state = STATE_IDLE; pthread_mutex_unlock(&qdev->lock); fingerprint_msg_t msg = {0, {0}}; msg.type = FINGERPRINT_ERROR; msg.data.error = FINGERPRINT_ERROR_CANCELED; qdev->device.notify(&msg); return 0; } static int fingerprint_enumerate(struct fingerprint_device *device) { ALOGD("----------------> %s ----------------->", __FUNCTION__); if (device == NULL) { ALOGE("Cannot enumerate saved fingerprints with uninitialized params"); return -1; } qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)device; int template_count = 0; for (int i = 0; i < MAX_NUM_FINGERS; i++) { if (qdev->listener.secureid[i] != 0 || qdev->listener.fingerid[i] != 0) { ALOGD("ENUM: Fingerprint [%d] = 0x%" PRIx64 ",%" PRIx64, i, qdev->listener.secureid[i], qdev->listener.fingerid[i]); template_count++; } } fingerprint_msg_t message = {0, {0}}; message.type = FINGERPRINT_TEMPLATE_ENUMERATING; message.data.enumerated.finger.gid = qdev->group_id; for (int i = 0; i < MAX_NUM_FINGERS; i++) { if (qdev->listener.secureid[i] != 0 || qdev->listener.fingerid[i] != 0) { template_count--; message.data.enumerated.remaining_templates = template_count; message.data.enumerated.finger.fid = qdev->listener.fingerid[i]; qdev->device.notify(&message); } } return 0; } static int fingerprint_remove(struct fingerprint_device *device, uint32_t __unused gid, uint32_t fid) { int idx = 0; fingerprint_msg_t msg = {0, {0}}; ALOGD("----------------> %s -----------------> fid %d", __FUNCTION__, fid); if (device == NULL) { ALOGE("Can't remove fingerprint (gid=%d, fid=%d); " "device not initialized properly", gid, fid); return -1; } qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)device; if (fid == 0) { // Delete all fingerprints // I'll do this one at a time, so I am not // holding the mutext during the notification bool listIsEmpty; do { pthread_mutex_lock(&qdev->lock); listIsEmpty = true; // Haven't seen a valid entry yet for (idx = 0; idx < MAX_NUM_FINGERS; idx++) { uint32_t theFid = qdev->listener.fingerid[idx]; if (theFid != 0) { // Delete this entry qdev->listener.secureid[idx] = 0; qdev->listener.fingerid[idx] = 0; saveFingerprint(&qdev->listener, idx); // Send a notification that we deleted this one pthread_mutex_unlock(&qdev->lock); msg.type = FINGERPRINT_TEMPLATE_REMOVED; msg.data.removed.finger.fid = theFid; device->notify(&msg); // Because we released the mutex, the list // may have changed. Restart the 'for' loop // after reacquiring the mutex. listIsEmpty = false; break; } } // end for (idx < MAX_NUM_FINGERS) } while (!listIsEmpty); msg.type = FINGERPRINT_TEMPLATE_REMOVED; msg.data.removed.finger.fid = 0; device->notify(&msg); qdev->listener.state = STATE_IDLE; pthread_mutex_unlock(&qdev->lock); } else { // Delete one fingerprint // Look for this finger ID in our table. pthread_mutex_lock(&qdev->lock); for (idx = 0; idx < MAX_NUM_FINGERS; idx++) { if (qdev->listener.fingerid[idx] == fid && qdev->listener.secureid[idx] != 0) { // Found it! break; } } if (idx >= MAX_NUM_FINGERS) { qdev->listener.state = STATE_IDLE; pthread_mutex_unlock(&qdev->lock); ALOGE("Fingerprint ID %d not found", fid); return FINGERPRINT_ERROR; } qdev->listener.secureid[idx] = 0; qdev->listener.fingerid[idx] = 0; saveFingerprint(&qdev->listener, idx); qdev->listener.state = STATE_IDLE; pthread_mutex_unlock(&qdev->lock); msg.type = FINGERPRINT_TEMPLATE_REMOVED; msg.data.removed.finger.fid = fid; device->notify(&msg); } return 0; } static int set_notify_callback(struct fingerprint_device *device, fingerprint_notify_t notify) { ALOGD("----------------> %s ----------------->", __FUNCTION__); if (device == NULL || notify == NULL) { ALOGE("Failed to set notify callback @ %p for fingerprint device %p", device, notify); return -1; } qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)device; pthread_mutex_lock(&qdev->lock); qdev->listener.state = STATE_IDLE; device->notify = notify; pthread_mutex_unlock(&qdev->lock); ALOGD("fingerprint callback notification set"); return 0; } static bool is_valid_fid(qemu_fingerprint_device_t* qdev, uint64_t fid) { int idx = 0; if (0 == fid) { return false; } for (idx = 0; idx < MAX_NUM_FINGERS; idx++) { if (qdev->listener.fingerid[idx] == fid) { return true; } } return false; } static void send_scan_notice(qemu_fingerprint_device_t* qdev, int fid) { ALOGD("----------------> %s ----------------->", __FUNCTION__); // acquired message fingerprint_msg_t acqu_msg = {0, {0}}; acqu_msg.type = FINGERPRINT_ACQUIRED; acqu_msg.data.acquired.acquired_info = FINGERPRINT_ACQUIRED_GOOD; // authenticated message fingerprint_msg_t auth_msg = {0, {0}}; auth_msg.type = FINGERPRINT_AUTHENTICATED; auth_msg.data.authenticated.finger.fid = is_valid_fid(qdev, fid) ? fid : 0; auth_msg.data.authenticated.finger.gid = 0; // unused auth_msg.data.authenticated.hat.version = HW_AUTH_TOKEN_VERSION; auth_msg.data.authenticated.hat.authenticator_type = htobe32(HW_AUTH_FINGERPRINT); auth_msg.data.authenticated.hat.challenge = qdev->op_id; auth_msg.data.authenticated.hat.authenticator_id = qdev->authenticator_id; auth_msg.data.authenticated.hat.user_id = qdev->secure_user_id; struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); auth_msg.data.authenticated.hat.timestamp = htobe64((uint64_t)ts.tv_sec * 1000 + ts.tv_nsec / 1000000); // pthread_mutex_lock(&qdev->lock); qdev->device.notify(&acqu_msg); qdev->device.notify(&auth_msg); // pthread_mutex_unlock(&qdev->lock); return; } static void send_enroll_notice(qemu_fingerprint_device_t* qdev, int fid) { ALOGD("----------------> %s -----------------> fid %d", __FUNCTION__, fid); if (fid == 0) { ALOGD("Fingerprint ID is zero (invalid)"); return; } if (qdev->secure_user_id == 0) { ALOGD("Secure user ID is zero (invalid)"); return; } // Find an available entry in the table pthread_mutex_lock(&qdev->lock); int idx = 0; for (idx = 0; idx < MAX_NUM_FINGERS; idx++) { if (qdev->listener.secureid[idx] == 0 || qdev->listener.fingerid[idx] == 0) { // This entry is available break; } } if (idx >= MAX_NUM_FINGERS) { qdev->listener.state = STATE_SCAN; pthread_mutex_unlock(&qdev->lock); ALOGD("Fingerprint ID table is full"); return; } qdev->listener.secureid[idx] = qdev->secure_user_id; qdev->listener.fingerid[idx] = fid; saveFingerprint(&qdev->listener, idx); qdev->listener.state = STATE_SCAN; pthread_mutex_unlock(&qdev->lock); // LOCKED notification? fingerprint_msg_t msg = {0, {0}}; msg.type = FINGERPRINT_TEMPLATE_ENROLLING; msg.data.enroll.finger.fid = fid; msg.data.enroll.samples_remaining = 0; qdev->device.notify(&msg); return; } static worker_state_t getListenerState(qemu_fingerprint_device_t* dev) { ALOGV("----------------> %s ----------------->", __FUNCTION__); worker_state_t state = STATE_IDLE; pthread_mutex_lock(&dev->lock); state = dev->listener.state; pthread_mutex_unlock(&dev->lock); return state; } /** * This a very simple event loop for the fingerprint sensor. For a given state (enroll, scan), * this would receive events from the sensor and forward them to fingerprintd using the * notify() method. * * In this simple example, we open a qemu channel (a pipe) where the developer can inject events to * exercise the API and test application code. * * The scanner should remain in the scanning state until either an error occurs or the operation * completes. * * Recoverable errors such as EINTR should be handled locally; they should not * be propagated unless there's something the user can do about it (e.g. "clean sensor"). Such * messages should go through the onAcquired() interface. * * If an unrecoverable error occurs, an acquired message (e.g. ACQUIRED_PARTIAL) should be sent, * followed by an error message (e.g. FINGERPRINT_ERROR_UNABLE_TO_PROCESS). * * Note that this event loop would typically run in TEE since it must interact with the sensor * hardware and handle raw fingerprint data and encrypted templates. It is expected that * this code monitors the TEE for resulting events, such as enrollment and authentication status. * Here we just have a very simple event loop that monitors a qemu channel for pseudo events. */ static void* listenerFunction(void* data) { ALOGD("----------------> %s ----------------->", __FUNCTION__); qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)data; pthread_mutex_lock(&qdev->lock); qdev->qchanfd = qemud_channel_open(FINGERPRINT_LISTEN_SERVICE_NAME); if (qdev->qchanfd < 0) { ALOGE("listener cannot open fingerprint listener service exit"); pthread_mutex_unlock(&qdev->lock); return NULL; } qdev->listener.state = STATE_IDLE; pthread_mutex_unlock(&qdev->lock); const char* cmd = "listen"; if (qemud_channel_send(qdev->qchanfd, cmd, strlen(cmd)) < 0) { ALOGE("cannot write fingerprint 'listen' to host"); goto done_quiet; } int comm_errors = 0; struct pollfd pfd = { .fd = qdev->qchanfd, .events = POLLIN, }; while (1) { int size = 0; int fid = 0; char buffer[MAX_COMM_CHARS] = {0}; bool disconnected = false; while (1) { if (getListenerState(qdev) == STATE_EXIT) { ALOGD("Received request to exit listener thread"); goto done; } // Reset revents before poll() (just to be safe) pfd.revents = 0; // Poll qemud channel for 5 seconds // TODO: Eliminate the timeout so that polling can be interrupted // instantly. One possible solution is to follow the example of // android::Looper ($AOSP/system/core/include/utils/Looper.h and // $AOSP/system/core/libutils/Looper.cpp), which makes use of an // additional file descriptor ("wake event fd"). int nfds = poll(&pfd, 1, 5000); if (nfds < 0) { ALOGE("Could not poll qemud channel: %s", strerror(errno)); goto done; } if (!nfds) { // poll() timed out - try again continue; } // assert(nfds == 1) if (pfd.revents & POLLIN) { // Input data being available doesn't rule out a disconnection disconnected = pfd.revents & (POLLERR | POLLHUP); break; // Exit inner while loop } else { // Some event(s) other than "input data available" occurred, // i.e. POLLERR or POLLHUP, indicating a disconnection ALOGW("Lost connection to qemud channel"); goto done; } } // Shouldn't block since we were just notified of a POLLIN event if ((size = qemud_channel_recv(qdev->qchanfd, buffer, sizeof(buffer) - 1)) > 0) { buffer[size] = '\0'; if (sscanf(buffer, "on:%d", &fid) == 1) { if (fid > 0 && fid <= MAX_FID_VALUE) { switch (qdev->listener.state) { case STATE_ENROLL: send_enroll_notice(qdev, fid); break; case STATE_SCAN: send_scan_notice(qdev, fid); break; default: ALOGE("fingerprint event listener at unexpected " "state 0%x", qdev->listener.state); } } else { ALOGE("fingerprintid %d not in valid range [%d, %d] and " "will be " "ignored", fid, 1, MAX_FID_VALUE); continue; } } else if (strncmp("off", buffer, 3) == 0) { // TODO: Nothing to do here ? Looks valid ALOGD("fingerprint ID %d off", fid); } else { ALOGE("Invalid command '%s' to fingerprint listener", buffer); } if (disconnected) { ALOGW("Connection to qemud channel has been lost"); break; } } else { ALOGE("fingerprint listener receive failure"); if (comm_errors > MAX_COMM_ERRORS) break; } } done: ALOGD("Listener exit with %d receive errors", comm_errors); done_quiet: close(qdev->qchanfd); return NULL; } static int fingerprint_close(hw_device_t* device) { ALOGD("----------------> %s ----------------->", __FUNCTION__); if (device == NULL) { ALOGE("fingerprint hw device is NULL"); return -1; } qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)device; pthread_mutex_lock(&qdev->lock); // Ask listener thread to exit qdev->listener.state = STATE_EXIT; pthread_mutex_unlock(&qdev->lock); pthread_join(qdev->listener.thread, NULL); pthread_mutex_destroy(&qdev->lock); free(qdev); return 0; } static int fingerprint_open(const hw_module_t* module, const char __unused *id, hw_device_t** device) { ALOGD("----------------> %s ----------------->", __FUNCTION__); if (device == NULL) { ALOGE("NULL device on open"); return -EINVAL; } qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)calloc( 1, sizeof(qemu_fingerprint_device_t)); if (qdev == NULL) { ALOGE("Insufficient memory for virtual fingerprint device"); return -ENOMEM; } qdev->device.common.tag = HARDWARE_DEVICE_TAG; qdev->device.common.version = HARDWARE_MODULE_API_VERSION(2, 1); qdev->device.common.module = (struct hw_module_t*)module; qdev->device.common.close = fingerprint_close; qdev->device.pre_enroll = fingerprint_pre_enroll; qdev->device.enroll = fingerprint_enroll; qdev->device.post_enroll = fingerprint_post_enroll; qdev->device.get_authenticator_id = fingerprint_get_auth_id; qdev->device.set_active_group = fingerprint_set_active_group; qdev->device.authenticate = fingerprint_authenticate; qdev->device.cancel = fingerprint_cancel; qdev->device.enumerate = fingerprint_enumerate; qdev->device.remove = fingerprint_remove; qdev->device.set_notify = set_notify_callback; qdev->device.notify = NULL; // init and create listener thread pthread_mutex_init(&qdev->lock, NULL); if (pthread_create(&qdev->listener.thread, NULL, listenerFunction, qdev) != 0) return -1; // "Inheritance" / casting *device = &qdev->device.common; return 0; } static struct hw_module_methods_t fingerprint_module_methods = { .open = fingerprint_open, }; fingerprint_module_t HAL_MODULE_INFO_SYM = { .common = { .tag = HARDWARE_MODULE_TAG, .module_api_version = FINGERPRINT_MODULE_API_VERSION_2_1, .hal_api_version = HARDWARE_HAL_API_VERSION, .id = FINGERPRINT_HARDWARE_MODULE_ID, .name = "Emulator Fingerprint HAL", .author = "The Android Open Source Project", .methods = &fingerprint_module_methods, }, }; anbox-0.0~git20191115/android/fstab.goldfish000066400000000000000000000000261356361734700204630ustar00rootroot00000000000000# Android fstab file. anbox-0.0~git20191115/android/gps/000077500000000000000000000000001356361734700164365ustar00rootroot00000000000000anbox-0.0~git20191115/android/gps/Android.mk000066400000000000000000000026401356361734700203510ustar00rootroot00000000000000# Copyright (C) 2010 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # We're moving the emulator-specific platform libs to # development.git/tools/emulator/. The following test is to ensure # smooth builds even if the tree contains both versions. # LOCAL_PATH := $(call my-dir) # HAL module implemenation stored in # hw/..so include $(CLEAR_VARS) LOCAL_MODULE_RELATIVE_PATH := hw LOCAL_CFLAGS += -DQEMU_HARDWARE LOCAL_SHARED_LIBRARIES := liblog libcutils libhardware LOCAL_SRC_FILES := gps_qemu.c ifeq ($(TARGET_PRODUCT),vbox_x86) LOCAL_MODULE := gps.vbox_x86 else LOCAL_MODULE := gps.goldfish endif include $(BUILD_SHARED_LIBRARY) include $(CLEAR_VARS) LOCAL_MODULE_RELATIVE_PATH := hw LOCAL_CFLAGS += -DQEMU_HARDWARE LOCAL_SHARED_LIBRARIES := liblog libcutils libhardware LOCAL_SRC_FILES := gps_qemu.c LOCAL_MODULE := gps.ranchu include $(BUILD_SHARED_LIBRARY) anbox-0.0~git20191115/android/gps/gps_qemu.c000066400000000000000000000603041356361734700204250ustar00rootroot00000000000000/* * Copyright (C) 2010 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* this implements a GPS hardware library for the Android emulator. * the following code should be built as a shared library that will be * placed into /system/lib/hw/gps.goldfish.so * * it will be loaded by the code in hardware/libhardware/hardware.c * which is itself called from android_location_GpsLocationProvider.cpp */ #include #include #include #include #include #include #define LOG_TAG "gps_qemu" #include #include #include #include /* the name of the qemud-controlled socket */ #define QEMU_CHANNEL_NAME "gps" #define GPS_DEBUG 0 #if GPS_DEBUG # define D(...) ALOGD(__VA_ARGS__) #else # define D(...) ((void)0) #endif /*****************************************************************/ /*****************************************************************/ /***** *****/ /***** N M E A T O K E N I Z E R *****/ /***** *****/ /*****************************************************************/ /*****************************************************************/ typedef struct { const char* p; const char* end; } Token; #define MAX_NMEA_TOKENS 16 typedef struct { int count; Token tokens[ MAX_NMEA_TOKENS ]; } NmeaTokenizer; static int nmea_tokenizer_init( NmeaTokenizer* t, const char* p, const char* end ) { int count = 0; char* q; // the initial '$' is optional if (p < end && p[0] == '$') p += 1; // remove trailing newline if (end > p && end[-1] == '\n') { end -= 1; if (end > p && end[-1] == '\r') end -= 1; } // get rid of checksum at the end of the sentecne if (end >= p+3 && end[-3] == '*') { end -= 3; } while (p < end) { const char* q = p; q = memchr(p, ',', end-p); if (q == NULL) q = end; if (count < MAX_NMEA_TOKENS) { t->tokens[count].p = p; t->tokens[count].end = q; count += 1; } if (q < end) q += 1; p = q; } t->count = count; return count; } static Token nmea_tokenizer_get( NmeaTokenizer* t, int index ) { Token tok; static const char* dummy = ""; if (index < 0 || index >= t->count) { tok.p = tok.end = dummy; } else tok = t->tokens[index]; return tok; } static int str2int( const char* p, const char* end ) { int result = 0; int len = end - p; for ( ; len > 0; len--, p++ ) { int c; if (p >= end) goto Fail; c = *p - '0'; if ((unsigned)c >= 10) goto Fail; result = result*10 + c; } return result; Fail: return -1; } static double str2float( const char* p, const char* end ) { int result = 0; int len = end - p; char temp[16]; if (len >= (int)sizeof(temp)) return 0.; memcpy( temp, p, len ); temp[len] = 0; return strtod( temp, NULL ); } /*****************************************************************/ /*****************************************************************/ /***** *****/ /***** N M E A P A R S E R *****/ /***** *****/ /*****************************************************************/ /*****************************************************************/ #define NMEA_MAX_SIZE 83 typedef struct { int pos; int overflow; int utc_year; int utc_mon; int utc_day; int utc_diff; GpsLocation fix; gps_location_callback callback; char in[ NMEA_MAX_SIZE+1 ]; } NmeaReader; static void nmea_reader_update_utc_diff( NmeaReader* r ) { time_t now = time(NULL); struct tm tm_local; struct tm tm_utc; long time_local, time_utc; gmtime_r( &now, &tm_utc ); localtime_r( &now, &tm_local ); time_local = tm_local.tm_sec + 60*(tm_local.tm_min + 60*(tm_local.tm_hour + 24*(tm_local.tm_yday + 365*tm_local.tm_year))); time_utc = tm_utc.tm_sec + 60*(tm_utc.tm_min + 60*(tm_utc.tm_hour + 24*(tm_utc.tm_yday + 365*tm_utc.tm_year))); r->utc_diff = time_utc - time_local; } static void nmea_reader_init( NmeaReader* r ) { memset( r, 0, sizeof(*r) ); r->pos = 0; r->overflow = 0; r->utc_year = -1; r->utc_mon = -1; r->utc_day = -1; r->callback = NULL; r->fix.size = sizeof(r->fix); nmea_reader_update_utc_diff( r ); } static void nmea_reader_set_callback( NmeaReader* r, gps_location_callback cb ) { r->callback = cb; if (cb != NULL && r->fix.flags != 0) { D("%s: sending latest fix to new callback", __FUNCTION__); r->callback( &r->fix ); r->fix.flags = 0; } } static int nmea_reader_update_time( NmeaReader* r, Token tok ) { int hour, minute; double seconds; struct tm tm; time_t fix_time; if (tok.p + 6 > tok.end) return -1; if (r->utc_year < 0) { // no date yet, get current one time_t now = time(NULL); gmtime_r( &now, &tm ); r->utc_year = tm.tm_year + 1900; r->utc_mon = tm.tm_mon + 1; r->utc_day = tm.tm_mday; } hour = str2int(tok.p, tok.p+2); minute = str2int(tok.p+2, tok.p+4); seconds = str2float(tok.p+4, tok.end); tm.tm_hour = hour; tm.tm_min = minute; tm.tm_sec = (int) seconds; tm.tm_year = r->utc_year - 1900; tm.tm_mon = r->utc_mon - 1; tm.tm_mday = r->utc_day; tm.tm_isdst = -1; fix_time = mktime( &tm ) + r->utc_diff; r->fix.timestamp = (long long)fix_time * 1000; return 0; } static int nmea_reader_update_date( NmeaReader* r, Token date, Token time ) { Token tok = date; int day, mon, year; if (tok.p + 6 != tok.end) { D("date not properly formatted: '%.*s'", tok.end-tok.p, tok.p); return -1; } day = str2int(tok.p, tok.p+2); mon = str2int(tok.p+2, tok.p+4); year = str2int(tok.p+4, tok.p+6) + 2000; if ((day|mon|year) < 0) { D("date not properly formatted: '%.*s'", tok.end-tok.p, tok.p); return -1; } r->utc_year = year; r->utc_mon = mon; r->utc_day = day; return nmea_reader_update_time( r, time ); } static double convert_from_hhmm( Token tok ) { double val = str2float(tok.p, tok.end); int degrees = (int)(floor(val) / 100); double minutes = val - degrees*100.; double dcoord = degrees + minutes / 60.0; return dcoord; } static int nmea_reader_update_latlong( NmeaReader* r, Token latitude, char latitudeHemi, Token longitude, char longitudeHemi ) { double lat, lon; Token tok; tok = latitude; if (tok.p + 6 > tok.end) { D("latitude is too short: '%.*s'", tok.end-tok.p, tok.p); return -1; } lat = convert_from_hhmm(tok); if (latitudeHemi == 'S') lat = -lat; tok = longitude; if (tok.p + 6 > tok.end) { D("longitude is too short: '%.*s'", tok.end-tok.p, tok.p); return -1; } lon = convert_from_hhmm(tok); if (longitudeHemi == 'W') lon = -lon; r->fix.flags |= GPS_LOCATION_HAS_LAT_LONG; r->fix.latitude = lat; r->fix.longitude = lon; return 0; } static int nmea_reader_update_altitude( NmeaReader* r, Token altitude, Token units ) { double alt; Token tok = altitude; if (tok.p >= tok.end) return -1; r->fix.flags |= GPS_LOCATION_HAS_ALTITUDE; r->fix.altitude = str2float(tok.p, tok.end); return 0; } static int nmea_reader_update_bearing( NmeaReader* r, Token bearing ) { double alt; Token tok = bearing; if (tok.p >= tok.end) return -1; r->fix.flags |= GPS_LOCATION_HAS_BEARING; r->fix.bearing = str2float(tok.p, tok.end); return 0; } static int nmea_reader_update_speed( NmeaReader* r, Token speed ) { double alt; Token tok = speed; if (tok.p >= tok.end) return -1; r->fix.flags |= GPS_LOCATION_HAS_SPEED; r->fix.speed = str2float(tok.p, tok.end); return 0; } static int nmea_reader_update_accuracy( NmeaReader* r ) { // Always return 20m accuracy. // Possibly parse it from the NMEA sentence in the future. r->fix.flags |= GPS_LOCATION_HAS_ACCURACY; r->fix.accuracy = 20; return 0; } static void nmea_reader_parse( NmeaReader* r ) { /* we received a complete sentence, now parse it to generate * a new GPS fix... */ NmeaTokenizer tzer[1]; Token tok; D("Received: '%.*s'", r->pos, r->in); if (r->pos < 9) { D("Too short. discarded."); return; } nmea_tokenizer_init(tzer, r->in, r->in + r->pos); #if GPS_DEBUG { int n; D("Found %d tokens", tzer->count); for (n = 0; n < tzer->count; n++) { Token tok = nmea_tokenizer_get(tzer,n); D("%2d: '%.*s'", n, tok.end-tok.p, tok.p); } } #endif tok = nmea_tokenizer_get(tzer, 0); if (tok.p + 5 > tok.end) { D("sentence id '%.*s' too short, ignored.", tok.end-tok.p, tok.p); return; } // ignore first two characters. tok.p += 2; if ( !memcmp(tok.p, "GGA", 3) ) { // GPS fix Token tok_time = nmea_tokenizer_get(tzer,1); Token tok_latitude = nmea_tokenizer_get(tzer,2); Token tok_latitudeHemi = nmea_tokenizer_get(tzer,3); Token tok_longitude = nmea_tokenizer_get(tzer,4); Token tok_longitudeHemi = nmea_tokenizer_get(tzer,5); Token tok_altitude = nmea_tokenizer_get(tzer,9); Token tok_altitudeUnits = nmea_tokenizer_get(tzer,10); nmea_reader_update_time(r, tok_time); nmea_reader_update_latlong(r, tok_latitude, tok_latitudeHemi.p[0], tok_longitude, tok_longitudeHemi.p[0]); nmea_reader_update_altitude(r, tok_altitude, tok_altitudeUnits); } else if ( !memcmp(tok.p, "GSA", 3) ) { // do something ? } else if ( !memcmp(tok.p, "RMC", 3) ) { Token tok_time = nmea_tokenizer_get(tzer,1); Token tok_fixStatus = nmea_tokenizer_get(tzer,2); Token tok_latitude = nmea_tokenizer_get(tzer,3); Token tok_latitudeHemi = nmea_tokenizer_get(tzer,4); Token tok_longitude = nmea_tokenizer_get(tzer,5); Token tok_longitudeHemi = nmea_tokenizer_get(tzer,6); Token tok_speed = nmea_tokenizer_get(tzer,7); Token tok_bearing = nmea_tokenizer_get(tzer,8); Token tok_date = nmea_tokenizer_get(tzer,9); D("in RMC, fixStatus=%c", tok_fixStatus.p[0]); if (tok_fixStatus.p[0] == 'A') { nmea_reader_update_date( r, tok_date, tok_time ); nmea_reader_update_latlong( r, tok_latitude, tok_latitudeHemi.p[0], tok_longitude, tok_longitudeHemi.p[0] ); nmea_reader_update_bearing( r, tok_bearing ); nmea_reader_update_speed ( r, tok_speed ); } } else { tok.p -= 2; D("unknown sentence '%.*s", tok.end-tok.p, tok.p); } // Always update accuracy nmea_reader_update_accuracy( r ); if (r->fix.flags != 0) { #if GPS_DEBUG char temp[256]; char* p = temp; char* end = p + sizeof(temp); struct tm utc; p += snprintf( p, end-p, "sending fix" ); if (r->fix.flags & GPS_LOCATION_HAS_LAT_LONG) { p += snprintf(p, end-p, " lat=%g lon=%g", r->fix.latitude, r->fix.longitude); } if (r->fix.flags & GPS_LOCATION_HAS_ALTITUDE) { p += snprintf(p, end-p, " altitude=%g", r->fix.altitude); } if (r->fix.flags & GPS_LOCATION_HAS_SPEED) { p += snprintf(p, end-p, " speed=%g", r->fix.speed); } if (r->fix.flags & GPS_LOCATION_HAS_BEARING) { p += snprintf(p, end-p, " bearing=%g", r->fix.bearing); } if (r->fix.flags & GPS_LOCATION_HAS_ACCURACY) { p += snprintf(p,end-p, " accuracy=%g", r->fix.accuracy); } gmtime_r( (time_t*) &r->fix.timestamp, &utc ); p += snprintf(p, end-p, " time=%s", asctime( &utc ) ); D(temp); #endif if (r->callback) { r->callback( &r->fix ); r->fix.flags = 0; } else { D("no callback, keeping data until needed !"); } } } static void nmea_reader_addc( NmeaReader* r, int c ) { if (r->overflow) { r->overflow = (c != '\n'); return; } if (r->pos >= (int) sizeof(r->in)-1 ) { r->overflow = 1; r->pos = 0; return; } r->in[r->pos] = (char)c; r->pos += 1; if (c == '\n') { nmea_reader_parse( r ); r->pos = 0; } } /*****************************************************************/ /*****************************************************************/ /***** *****/ /***** C O N N E C T I O N S T A T E *****/ /***** *****/ /*****************************************************************/ /*****************************************************************/ /* commands sent to the gps thread */ enum { CMD_QUIT = 0, CMD_START = 1, CMD_STOP = 2 }; /* this is the state of our connection to the qemu_gpsd daemon */ typedef struct { int init; int fd; GpsCallbacks callbacks; pthread_t thread; int control[2]; } GpsState; static GpsState _gps_state[1]; static void gps_state_done( GpsState* s ) { // tell the thread to quit, and wait for it char cmd = CMD_QUIT; void* dummy; write( s->control[0], &cmd, 1 ); pthread_join(s->thread, &dummy); // close the control socket pair close( s->control[0] ); s->control[0] = -1; close( s->control[1] ); s->control[1] = -1; // close connection to the QEMU GPS daemon close( s->fd ); s->fd = -1; s->init = 0; } static void gps_state_start( GpsState* s ) { char cmd = CMD_START; int ret; do { ret=write( s->control[0], &cmd, 1 ); } while (ret < 0 && errno == EINTR); if (ret != 1) D("%s: could not send CMD_START command: ret=%d: %s", __FUNCTION__, ret, strerror(errno)); } static void gps_state_stop( GpsState* s ) { char cmd = CMD_STOP; int ret; do { ret=write( s->control[0], &cmd, 1 ); } while (ret < 0 && errno == EINTR); if (ret != 1) D("%s: could not send CMD_STOP command: ret=%d: %s", __FUNCTION__, ret, strerror(errno)); } static int epoll_register( int epoll_fd, int fd ) { struct epoll_event ev; int ret, flags; /* important: make the fd non-blocking */ flags = fcntl(fd, F_GETFL); fcntl(fd, F_SETFL, flags | O_NONBLOCK); ev.events = EPOLLIN; ev.data.fd = fd; do { ret = epoll_ctl( epoll_fd, EPOLL_CTL_ADD, fd, &ev ); } while (ret < 0 && errno == EINTR); return ret; } static int epoll_deregister( int epoll_fd, int fd ) { int ret; do { ret = epoll_ctl( epoll_fd, EPOLL_CTL_DEL, fd, NULL ); } while (ret < 0 && errno == EINTR); return ret; } /* this is the main thread, it waits for commands from gps_state_start/stop and, * when started, messages from the QEMU GPS daemon. these are simple NMEA sentences * that must be parsed to be converted into GPS fixes sent to the framework */ static void gps_state_thread( void* arg ) { GpsState* state = (GpsState*) arg; NmeaReader reader[1]; int epoll_fd = epoll_create(2); int started = 0; int gps_fd = state->fd; int control_fd = state->control[1]; nmea_reader_init( reader ); // register control file descriptors for polling epoll_register( epoll_fd, control_fd ); epoll_register( epoll_fd, gps_fd ); D("gps thread running"); // now loop for (;;) { struct epoll_event events[2]; int ne, nevents; nevents = epoll_wait( epoll_fd, events, 2, -1 ); if (nevents < 0) { if (errno != EINTR) ALOGE("epoll_wait() unexpected error: %s", strerror(errno)); continue; } D("gps thread received %d events", nevents); for (ne = 0; ne < nevents; ne++) { if ((events[ne].events & (EPOLLERR|EPOLLHUP)) != 0) { ALOGE("EPOLLERR or EPOLLHUP after epoll_wait() !?"); return; } if ((events[ne].events & EPOLLIN) != 0) { int fd = events[ne].data.fd; if (fd == control_fd) { char cmd = 255; int ret; D("gps control fd event"); do { ret = read( fd, &cmd, 1 ); } while (ret < 0 && errno == EINTR); if (cmd == CMD_QUIT) { D("gps thread quitting on demand"); return; } else if (cmd == CMD_START) { if (!started) { D("gps thread starting location_cb=%p", state->callbacks.location_cb); started = 1; nmea_reader_set_callback( reader, state->callbacks.location_cb ); } } else if (cmd == CMD_STOP) { if (started) { D("gps thread stopping"); started = 0; nmea_reader_set_callback( reader, NULL ); } } } else if (fd == gps_fd) { char buff[32]; D("gps fd event"); for (;;) { int nn, ret; ret = read( fd, buff, sizeof(buff) ); if (ret < 0) { if (errno == EINTR) continue; if (errno != EWOULDBLOCK) ALOGE("error while reading from gps daemon socket: %s:", strerror(errno)); break; } D("received %d bytes: %.*s", ret, ret, buff); for (nn = 0; nn < ret; nn++) nmea_reader_addc( reader, buff[nn] ); } D("gps fd event end"); } else { ALOGE("epoll_wait() returned unkown fd %d ?", fd); } } } } } static void gps_state_init( GpsState* state, GpsCallbacks* callbacks ) { state->init = 1; state->control[0] = -1; state->control[1] = -1; state->fd = -1; state->fd = qemud_channel_open(QEMU_CHANNEL_NAME); if (state->fd < 0) { D("no gps emulation detected"); return; } D("gps emulation will read from '%s' qemud channel", QEMU_CHANNEL_NAME ); if ( socketpair( AF_LOCAL, SOCK_STREAM, 0, state->control ) < 0 ) { ALOGE("could not create thread control socket pair: %s", strerror(errno)); goto Fail; } state->thread = callbacks->create_thread_cb( "gps_state_thread", gps_state_thread, state ); if ( !state->thread ) { ALOGE("could not create gps thread: %s", strerror(errno)); goto Fail; } state->callbacks = *callbacks; D("gps state initialized"); return; Fail: gps_state_done( state ); } /*****************************************************************/ /*****************************************************************/ /***** *****/ /***** I N T E R F A C E *****/ /***** *****/ /*****************************************************************/ /*****************************************************************/ static int qemu_gps_init(GpsCallbacks* callbacks) { GpsState* s = _gps_state; if (!s->init) gps_state_init(s, callbacks); if (s->fd < 0) return -1; return 0; } static void qemu_gps_cleanup(void) { GpsState* s = _gps_state; if (s->init) gps_state_done(s); } static int qemu_gps_start() { GpsState* s = _gps_state; if (!s->init) { D("%s: called with uninitialized state !!", __FUNCTION__); return -1; } D("%s: called", __FUNCTION__); gps_state_start(s); return 0; } static int qemu_gps_stop() { GpsState* s = _gps_state; if (!s->init) { D("%s: called with uninitialized state !!", __FUNCTION__); return -1; } D("%s: called", __FUNCTION__); gps_state_stop(s); return 0; } static int qemu_gps_inject_time(GpsUtcTime time, int64_t timeReference, int uncertainty) { return 0; } static int qemu_gps_inject_location(double latitude, double longitude, float accuracy) { return 0; } static void qemu_gps_delete_aiding_data(GpsAidingData flags) { } static int qemu_gps_set_position_mode(GpsPositionMode mode, int fix_frequency) { // FIXME - support fix_frequency return 0; } static const void* qemu_gps_get_extension(const char* name) { // no extensions supported return NULL; } static const GpsInterface qemuGpsInterface = { sizeof(GpsInterface), qemu_gps_init, qemu_gps_start, qemu_gps_stop, qemu_gps_cleanup, qemu_gps_inject_time, qemu_gps_inject_location, qemu_gps_delete_aiding_data, qemu_gps_set_position_mode, qemu_gps_get_extension, }; const GpsInterface* gps__get_gps_interface(struct gps_device_t* dev) { return &qemuGpsInterface; } static int open_gps(const struct hw_module_t* module, char const* name, struct hw_device_t** device) { struct gps_device_t *dev = malloc(sizeof(struct gps_device_t)); memset(dev, 0, sizeof(*dev)); dev->common.tag = HARDWARE_DEVICE_TAG; dev->common.version = 0; dev->common.module = (struct hw_module_t*)module; // dev->common.close = (int (*)(struct hw_device_t*))close_lights; dev->get_gps_interface = gps__get_gps_interface; *device = (struct hw_device_t*)dev; return 0; } static struct hw_module_methods_t gps_module_methods = { .open = open_gps }; struct hw_module_t HAL_MODULE_INFO_SYM = { .tag = HARDWARE_MODULE_TAG, .version_major = 1, .version_minor = 0, .id = GPS_HARDWARE_MODULE_ID, .name = "Goldfish GPS Module", .author = "The Android Open Source Project", .methods = &gps_module_methods, }; anbox-0.0~git20191115/android/hwcomposer/000077500000000000000000000000001356361734700200335ustar00rootroot00000000000000anbox-0.0~git20191115/android/hwcomposer/hwcomposer.cpp000066400000000000000000000260001356361734700227230ustar00rootroot00000000000000/* * Copyright (C) 2016 Simon Fels * * This program is free software: you can redistribute it and/or modify it * under the terms of the GNU General Public License version 3, as published * by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranties of * MERCHANTABILITY, SATISFACTORY QUALITY, 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, see . * */ #include #include #include #include #include #include #define LOG_NDEBUG 1 #include #include "HostConnection.h" #include "gralloc_cb.h" #define DEFINE_HOST_CONNECTION() \ HostConnection *hostCon = HostConnection::get(); \ renderControl_encoder_context_t *rcEnc = (hostCon ? hostCon->rcEncoder() : NULL) #define DEFINE_AND_VALIDATE_HOST_CONNECTION() \ HostConnection *hostCon = HostConnection::get(); \ if (!hostCon) { \ ALOGE("hwcomposer.anbox: Failed to get host connection\n"); \ return -EIO; \ } \ renderControl_encoder_context_t *rcEnc = hostCon->rcEncoder(); \ if (!rcEnc) { \ ALOGE("hwcomposer.anbox: Failed to get renderControl encoder context\n"); \ return -EIO; \ } struct HwcContext { hwc_composer_device_1_t device; // These 3 variables could be reduced to first_overlay only, however it makes // the conditions in the code more complicated. In order to keep things as // simple as possible, there are 3 major ways to display a frame. // 1. Show only the framebuffer. // 2. Show the framebuffer with some overlays above it. // 3. Show all overlays and hide the framebuffer. // // Since the framebuffer has no alpha channel and is opaque, it can only ever // be the rearmost layer that we end up putting on screen, otherwise it will // cover up all layers behind it, since its display frame is the whole window. // // Without framebuffer_visible, the condition of whether to display the // frambuffer becomes more complex and possibly if (numHwLayers == 0 || // hwLayers[0]->compositionType != HWC_OVERLAY) but that might not be correct. // // The range [first_overlay, first_overlay+num_overlay) is a natural way to // structure the loop and prevents requiring state and iterating through all // the non-OVERLAY layers in hwc_set. bool framebuffer_visible; size_t first_overlay; size_t num_overlays; }; static void dump_layer(hwc_layer_1_t const* l) { ALOGD("\tname='%s', type=%d, flags=%08x, handle=%p, tr=%02x, blend=%04x, {%d,%d,%d,%d}, {%d,%d,%d,%d}", l->name, l->compositionType, l->flags, l->handle, l->transform, l->blending, l->sourceCrop.left, l->sourceCrop.top, l->sourceCrop.right, l->sourceCrop.bottom, l->displayFrame.left, l->displayFrame.top, l->displayFrame.right, l->displayFrame.bottom); } static int hwc_prepare(hwc_composer_device_1_t* dev, size_t numDisplays, hwc_display_contents_1_t** displays) { auto context = reinterpret_cast(dev); if (displays == NULL || displays[0] == NULL) return -EINVAL; // Anbox only supports the primary display. if (displays[0]->flags & HWC_GEOMETRY_CHANGED) { const size_t& num_hw_layers = displays[0]->numHwLayers; size_t i = 1; bool visible = (num_hw_layers == 1); // Iterate backwards and skip the first (end) layer, which is the // framebuffer target layer. According to the SurfaceFlinger folks, the // actual location of this layer is up to the HWC implementation to // decide, but is in the well know last slot of the list. This does not // imply that the framebuffer target layer must be topmost. for (; i < num_hw_layers; i++) { hwc_layer_1_t* layer = &displays[0]->hwLayers[num_hw_layers - 1 - i]; #if 0 dump_layer(layer); #endif if (layer->flags & HWC_SKIP_LAYER) { // All layers below and including this one will be drawn into the // framebuffer. Stop marking further layers as HWC_OVERLAY. visible = true; break; } switch (layer->compositionType) { case HWC_OVERLAY: case HWC_FRAMEBUFFER: layer->compositionType = HWC_OVERLAY; break; case HWC_BACKGROUND: break; default: ALOGE("hwcomposor: Invalid compositionType %d", layer->compositionType); break; } } context->first_overlay = num_hw_layers - i; context->num_overlays = i - 1; context->framebuffer_visible = visible; } return 0; } /* * We're using "implicit" synchronization, so make sure we aren't passing any * sync object descriptors around. */ static void check_sync_fds(size_t numDisplays, hwc_display_contents_1_t** displays) { unsigned int i, j; for (i = 0; i < numDisplays; i++) { hwc_display_contents_1_t* list = displays[i]; if (list->retireFenceFd >= 0) { ALOGW("retireFenceFd[%u] was %d", i, list->retireFenceFd); list->retireFenceFd = -1; } for (j = 0; j < list->numHwLayers; j++) { hwc_layer_1_t* layer = &list->hwLayers[j]; if (layer->acquireFenceFd >= 0) { ALOGW("acquireFenceFd[%u][%u] was %d, closing", i, j, layer->acquireFenceFd); close(layer->acquireFenceFd); layer->acquireFenceFd = -1; } if (layer->releaseFenceFd >= 0) { ALOGW("releaseFenceFd[%u][%u] was %d", i, j, layer->releaseFenceFd); layer->releaseFenceFd = -1; } } } } static int hwc_set(hwc_composer_device_1_t* dev, size_t numDisplays, hwc_display_contents_1_t** displays) { auto context = reinterpret_cast(dev); if (displays == NULL || displays[0] == NULL) return -EFAULT; DEFINE_AND_VALIDATE_HOST_CONNECTION(); for (size_t i = 0 ; i < displays[0]->numHwLayers ; i++) { const auto layer = &displays[0]->hwLayers[i]; if (layer->flags & HWC_SKIP_LAYER || layer->flags & HWC_IS_CURSOR_LAYER) continue; #if 0 dump_layer(layer); #endif // FIXME this is just dirty ... but layer->handle is a const native_handle_t and canBePosted // can't be called with a const. auto cb = const_cast(reinterpret_cast(layer->handle)); if (!cb_handle_t::validate(cb)) { ALOGE("Buffer handle is invalid\n"); return -EINVAL; } rcEnc->rcPostLayer(rcEnc, layer->name, cb->hostHandle, layer->planeAlpha / 255, layer->sourceCrop.left, layer->sourceCrop.top, layer->sourceCrop.right, layer->sourceCrop.bottom, layer->displayFrame.left, layer->displayFrame.top, layer->displayFrame.right, layer->displayFrame.bottom); hostCon->flush(); } rcEnc->rcPostAllLayersDone(rcEnc); check_sync_fds(numDisplays, displays); return 0; } static int hwc_event_control(hwc_composer_device_1* dev, int disp, int event, int enabled) { return -EFAULT; } static void hwc_register_procs(hwc_composer_device_1* dev, hwc_procs_t const* procs) { } static int hwc_blank(hwc_composer_device_1* dev, int disp, int blank) { return 0; } static int hwc_query(hwc_composer_device_1* dev, int what, int* value) { return 0; } static int hwc_device_close(hw_device_t* dev) { auto context = reinterpret_cast(dev); delete context; return 0; } static int hwc_get_display_configs(hwc_composer_device_1* dev, int disp, uint32_t* configs, size_t* numConfigs) { if (disp != 0) { return -EINVAL; } if (*numConfigs > 0) { // Config[0] will be passed in to getDisplayAttributes as the disp // parameter. The ARC display supports only 1 configuration. configs[0] = 0; *numConfigs = 1; } return 0; } static int hwc_get_display_attributes(hwc_composer_device_1* dev, int disp, uint32_t config, const uint32_t* attributes, int32_t* values) { if (disp != 0 || config != 0) { return -EINVAL; } DEFINE_AND_VALIDATE_HOST_CONNECTION(); while (*attributes != HWC_DISPLAY_NO_ATTRIBUTE) { switch (*attributes) { case HWC_DISPLAY_VSYNC_PERIOD: *values = rcEnc->rcGetDisplayVsyncPeriod(rcEnc, disp); break; case HWC_DISPLAY_WIDTH: *values = rcEnc->rcGetDisplayWidth(rcEnc, disp); break; case HWC_DISPLAY_HEIGHT: *values = rcEnc->rcGetDisplayHeight(rcEnc, disp); break; case HWC_DISPLAY_DPI_X: *values = 1000 * rcEnc->rcGetDisplayDpiX(rcEnc, disp); break; case HWC_DISPLAY_DPI_Y: *values = 1000 * rcEnc->rcGetDisplayDpiY(rcEnc, disp); break; default: ALOGE("Unknown attribute value 0x%02x", *attributes); } ++attributes; ++values; } return 0; } static int hwc_device_open(const hw_module_t* module, const char* name, hw_device_t** device) { ALOGD("%s", __PRETTY_FUNCTION__); if (strcmp(name, HWC_HARDWARE_COMPOSER) != 0) return -EINVAL; auto dev = new HwcContext; dev->device.common.tag = HARDWARE_DEVICE_TAG; dev->device.common.version = HWC_DEVICE_API_VERSION_1_0; dev->device.common.module = const_cast(module); dev->device.common.close = hwc_device_close; dev->device.prepare = hwc_prepare; dev->device.set = hwc_set; dev->device.eventControl = hwc_event_control; dev->device.blank = hwc_blank; dev->device.query = hwc_query; dev->device.getDisplayConfigs = hwc_get_display_configs; dev->device.getDisplayAttributes = hwc_get_display_attributes; dev->device.registerProcs = hwc_register_procs; dev->device.dump = nullptr; *device = &dev->device.common; return 0; } static hw_module_methods_t hwc_module_methods = { .open = hwc_device_open }; hwc_module_t HAL_MODULE_INFO_SYM = { .common = { .tag = HARDWARE_MODULE_TAG, .version_major = 1, .version_minor = 0, .id = HWC_HARDWARE_MODULE_ID, .name = "Hardware Composer Module", .author = "Anbox Developers", .methods = &hwc_module_methods, } }; anbox-0.0~git20191115/android/init.goldfish.rc000066400000000000000000000055651356361734700207470ustar00rootroot00000000000000 on early-init mount debugfs debugfs /sys/kernel/debug on init on boot setprop ARGH ARGH setprop net.eth0.gw 10.0.2.2 setprop net.eth0.dns1 10.0.2.3 setprop net.dns1 10.0.2.3 setprop net.gprs.local-ip 10.0.2.15 setprop ro.radio.use-ppp no setprop ro.build.product generic setprop ro.product.device generic # fake some battery state setprop status.battery.state Slow setprop status.battery.level 5 setprop status.battery.level_raw 50 setprop status.battery.level_scale 9 # set up the GPU caching setprop ro.hwui.texture_cache_size 72 setprop ro.hwui.layer_cache_size 48 setprop ro.hwui.r_buffer_cache_size 8 setprop ro.hwui.path_cache_size 32 setprop ro.hwui.gradient_cache_size 1 setprop ro.hwui.drop_shadow_cache_size 6 setprop ro.hwui.texture_cache_flushrate 0.4 setprop ro.hwui.text_small_cache_width 1024 setprop ro.hwui.text_small_cache_height 1024 setprop ro.hwui.text_large_cache_width 2048 setprop ro.hwui.text_large_cache_height 1024 # disable some daemons the emulator doesn't want stop dund stop akmd # start essential services start qemud start goldfish-logcat start goldfish-setup setprop ro.setupwizard.mode EMULATOR # enable Google-specific location features, # like NetworkLocationProvider and LocationCollector setprop ro.com.google.locationfeatures 1 # For the emulator, which bypasses Setup Wizard, you can specify # account info for the device via these two properties. Google # Login Service will insert these accounts into the database when # it is created (ie, after a data wipe). # # setprop ro.config.hosted_account username@hosteddomain.org:password # setprop ro.config.google_account username@gmail.com:password # # You MUST have a Google account on the device, and you MAY # additionally have a hosted account. No other configuration is # supported, and arbitrary breakage may result if you specify # something else. on fs mount_all /fstab.goldfish service goldfish-setup /system/etc/init.goldfish.sh user root group root oneshot # The qemu-props program is used to set various system # properties on boot. It must be run early during the boot # process to avoid race conditions with other daemons that # might read them (e.g. surface flinger), so define it in # class 'core' # service qemu-props /system/bin/qemu-props class core user root group root oneshot service qemud /system/bin/qemud socket qemud stream 666 oneshot # -Q is a special logcat option that forces the # program to check wether it runs on the emulator # if it does, it redirects its output to the device # named by the androidboot.console kernel option # if not, is simply exits immediately service goldfish-logcat /system/bin/logcat console oneshot service fingerprintd /system/bin/fingerprintd class late_start user system anbox-0.0~git20191115/android/init.goldfish.sh000077500000000000000000000033331356361734700207470ustar00rootroot00000000000000#!/system/bin/sh # Setup networking when boot starts ifconfig eth0 10.0.2.15 netmask 255.255.255.0 up route add default gw 10.0.2.2 dev eth0 # ro.kernel.android.qemud is normally set when we # want the RIL (radio interface layer) to talk to # the emulated modem through qemud. # # However, this will be undefined in two cases: # # - When we want the RIL to talk directly to a guest # serial device that is connected to a host serial # device by the emulator. # # - We don't want to use the RIL but the VM-based # modem emulation that runs inside the guest system # instead. # # The following detects the latter case and sets up the # system for it. # qemud=`getprop ro.kernel.android.qemud` case "$qemud" in "") radio_ril=`getprop ro.kernel.android.ril` case "$radio_ril" in "") # no need for the radio interface daemon # telephony is entirely emulated in Java setprop ro.radio.noril yes stop ril-daemon ;; esac ;; esac # Setup additionnal DNS servers if needed num_dns=`getprop ro.kernel.ndns` case "$num_dns" in 2) setprop net.eth0.dns2 10.0.2.4 ;; 3) setprop net.eth0.dns2 10.0.2.4 setprop net.eth0.dns3 10.0.2.5 ;; 4) setprop net.eth0.dns2 10.0.2.4 setprop net.eth0.dns3 10.0.2.5 setprop net.eth0.dns4 10.0.2.6 ;; esac # disable boot animation for a faster boot sequence when needed boot_anim=`getprop ro.kernel.android.bootanim` case "$boot_anim" in 0) setprop debug.sf.nobootanimation 1 ;; esac # set up the second interface (for inter-emulator connections) # if required my_ip=`getprop net.shared_net_ip` case "$my_ip" in "") ;; *) ifconfig eth1 "$my_ip" netmask 255.255.255.0 up ;; esac anbox-0.0~git20191115/android/lights/000077500000000000000000000000001356361734700171375ustar00rootroot00000000000000anbox-0.0~git20191115/android/lights/Android.mk000066400000000000000000000017261356361734700210560ustar00rootroot00000000000000# Copyright (C) 2011 The Android Open Source Project. # # Original code licensed under the Apache License, Version 2.0 (the "License"); # you may not use this software except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. LOCAL_PATH := $(call my-dir) # HAL module implemenation, not prelinked and stored in # hw/..so include $(CLEAR_VARS) LOCAL_MODULE_RELATIVE_PATH := hw LOCAL_SHARED_LIBRARIES := liblog libcutils LOCAL_SRC_FILES := lights_qemu.c LOCAL_MODULE := lights.goldfish LOCAL_CFLAGS += -DLIGHT_BACKLIGHT include $(BUILD_SHARED_LIBRARY) anbox-0.0~git20191115/android/lights/lights_qemu.c000066400000000000000000000134501356361734700216270ustar00rootroot00000000000000/* Copyright (C) 2011 The Android Open Source Project * * Original code licensed under the Apache License, Version 2.0 (the "License"); * you may not use this software except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * * This implements a lights hardware library for the Android emulator. * the following code should be built as a shared library that will be * placed into /system/lib/hw/lights.goldfish.so * * It will be loaded by the code in hardware/libhardware/hardware.c * which is itself called from * ./frameworks/base/services/jni/com_android_server_HardwareService.cpp */ #ifdef LOG_TAG #undef LOG_TAG #define LOG_TAG "Lights" #endif /* we connect with the emulator through the "hw-control" qemud service */ #define LIGHTS_SERVICE_NAME "hw-control" #include #include #include #include #include #include #include #include #include #include #include /* Set to 1 to enable debug messages to the log */ #define DEBUG 0 #if DEBUG # define D(...) ALOGD(__VA_ARGS__) #else # define D(...) do{}while(0) #endif #define E(...) ALOGE(__VA_ARGS__) /* Get brightness(0~255) from state. */ static int rgb_to_brightness( struct light_state_t const* state ) { int color = state->color & 0x00ffffff; return ((77 * ((color >> 16) & 0x00ff)) + (150 * ((color >> 8) & 0x00ff)) + (29 * (color & 0x00ff))) >> 8; } /* set backlight brightness by LIGHTS_SERVICE_NAME service. */ static int set_light_backlight( struct light_device_t* dev, struct light_state_t const* state ) { /* Get Lights service. */ int fd = qemud_channel_open( LIGHTS_SERVICE_NAME ); if (fd < 0) { E( "%s: no qemud connection", __FUNCTION__ ); return -1; } D( "%s: On/Off %d/%d flashMode %d brightnessMode %d" " RGB = 0x%08x", __func__, state->flashOnMS, state->flashOffMS, state->flashMode, state->brightnessMode, state->color ); int brightness = rgb_to_brightness( state ); char buffer[64]; snprintf( buffer, sizeof(buffer), "power:light:brightness:lcd_backlight:%d", brightness ); D( "%s: lcd_backlight command: %s", __FUNCTION__, buffer ); /* send backlight command to perform the backlight setting. */ if (qemud_channel_send( fd, buffer, -1 ) < 0) { E( "%s: could not query lcd_backlight: %s", __FUNCTION__, strerror(errno) ); close( fd ); return -1; } close( fd ); return 0; } static int set_light_buttons( struct light_device_t* dev, struct light_state_t const* state ) { /* @Waiting for later implementation. */ D( "%s: Not implemented.", __FUNCTION__ ); return 0; } static int set_light_battery( struct light_device_t* dev, struct light_state_t const* state ) { /* @Waiting for later implementation. */ D( "%s: Not implemented.", __FUNCTION__ ); return 0; } static int set_light_keyboard( struct light_device_t* dev, struct light_state_t const* state ) { /* @Waiting for later implementation. */ D( "%s: Not implemented.", __FUNCTION__ ); return 0; } static int set_light_notifications( struct light_device_t* dev, struct light_state_t const* state ) { /* @Waiting for later implementation. */ D( "%s: Not implemented.", __FUNCTION__ ); return 0; } static int set_light_attention( struct light_device_t* dev, struct light_state_t const* state ) { /* @Waiting for later implementation. */ D( "%s: Not implemented.", __FUNCTION__ ); return 0; } /** Close the lights device */ static int close_lights( struct light_device_t *dev ) { free( dev ); return 0; } /** * module methods */ /** Open a new instance of a lights device using name */ static int open_lights( const struct hw_module_t* module, char const *name, struct hw_device_t **device ) { void* set_light; if (0 == strcmp( LIGHT_ID_BACKLIGHT, name )) { set_light = set_light_backlight; } else if (0 == strcmp( LIGHT_ID_KEYBOARD, name )) { set_light = set_light_keyboard; } else if (0 == strcmp( LIGHT_ID_BUTTONS, name )) { set_light = set_light_buttons; } else if (0 == strcmp( LIGHT_ID_BATTERY, name )) { set_light = set_light_battery; } else if (0 == strcmp( LIGHT_ID_NOTIFICATIONS, name )) { set_light = set_light_notifications; } else if (0 == strcmp( LIGHT_ID_ATTENTION, name )) { set_light = set_light_attention; } else { D( "%s: %s light isn't supported yet.", __FUNCTION__, name ); return -EINVAL; } struct light_device_t *dev = malloc( sizeof(struct light_device_t) ); if (dev == NULL) { return -EINVAL; } memset( dev, 0, sizeof(*dev) ); dev->common.tag = HARDWARE_DEVICE_TAG; dev->common.version = 0; dev->common.module = (struct hw_module_t*)module; dev->common.close = (int (*)(struct hw_device_t*))close_lights; dev->set_light = set_light; *device = (struct hw_device_t*)dev; return 0; } static struct hw_module_methods_t lights_module_methods = { .open = open_lights, }; /* * The emulator lights Module */ struct hw_module_t HAL_MODULE_INFO_SYM = { .tag = HARDWARE_MODULE_TAG, .version_major = 1, .version_minor = 0, .id = LIGHTS_HARDWARE_MODULE_ID, .name = "Goldfish lights Module", .author = "The Android Open Source Project", .methods = &lights_module_methods, }; anbox-0.0~git20191115/android/media/000077500000000000000000000000001356361734700167245ustar00rootroot00000000000000anbox-0.0~git20191115/android/media/media_codecs.xml000066400000000000000000000065231356361734700220530ustar00rootroot00000000000000 anbox-0.0~git20191115/android/media/media_codecs_google_audio.xml000066400000000000000000000113361356361734700245660ustar00rootroot00000000000000 anbox-0.0~git20191115/android/media/media_codecs_google_telephony.xml000066400000000000000000000017151356361734700254740ustar00rootroot00000000000000 anbox-0.0~git20191115/android/media/media_codecs_google_tv.xml000066400000000000000000000023051356361734700241120ustar00rootroot00000000000000 anbox-0.0~git20191115/android/media/media_codecs_google_video.xml000066400000000000000000000144131356361734700245720ustar00rootroot00000000000000 anbox-0.0~git20191115/android/media/media_profiles.xml000066400000000000000000000317131356361734700224350ustar00rootroot00000000000000 ]> anbox-0.0~git20191115/android/opengl/000077500000000000000000000000001356361734700171315ustar00rootroot00000000000000anbox-0.0~git20191115/android/opengl/Android.mk000066400000000000000000000041631356361734700210460ustar00rootroot00000000000000# This is the top-level build file for the Android HW OpenGL ES emulation # in Android. # # You must define BUILD_EMULATOR_OPENGL to 'true' in your environment to # build the following files. # # Also define BUILD_EMULATOR_OPENGL_DRIVER to 'true' to build the gralloc # stuff as well. # ifeq (true,$(BUILD_EMULATOR_OPENGL)) # Top-level for all modules EMUGL_PATH := $(call my-dir) # Directory containing common headers used by several modules # This is always set to a module's LOCAL_C_INCLUDES # See the definition of emugl-begin-module in common.mk # EMUGL_COMMON_INCLUDES := $(EMUGL_PATH)/host/include/libOpenglRender # common cflags used by several modules # This is always set to a module's LOCAL_CFLAGS # See the definition of emugl-begin-module in common.mk # EMUGL_COMMON_CFLAGS := -DWITH_GLES2 # Uncomment the following line if you want to enable debug traces # in the GLES emulation libraries. # EMUGL_COMMON_CFLAGS += -DEMUGL_DEBUG=1 # Include common definitions used by all the modules included later # in this build file. This contains the definition of all useful # emugl-xxxx functions. # include $(EMUGL_PATH)/common.mk # IMPORTANT: ORDER IS CRUCIAL HERE # # For the import/export feature to work properly, you must include # modules below in correct order. That is, if module B depends on # module A, then it must be included after module A below. # # This ensures that anything exported by module A will be correctly # be imported by module B when it is declared. # # Note that the build system will complain if you try to import a # module that hasn't been declared yet anyway. # include $(EMUGL_PATH)/shared/OpenglCodecCommon/Android.mk # System static libraries include $(EMUGL_PATH)/system/GLESv1_enc/Android.mk include $(EMUGL_PATH)/system/GLESv2_enc/Android.mk include $(EMUGL_PATH)/system/renderControl_enc/Android.mk include $(EMUGL_PATH)/system/OpenglSystemCommon/Android.mk # System shared libraries include $(EMUGL_PATH)/system/GLESv1/Android.mk include $(EMUGL_PATH)/system/GLESv2/Android.mk include $(EMUGL_PATH)/system/gralloc/Android.mk include $(EMUGL_PATH)/system/egl/Android.mk endif # BUILD_EMULATOR_OPENGL == true anbox-0.0~git20191115/android/opengl/README000066400000000000000000000014521356361734700200130ustar00rootroot00000000000000This directory contains Android-side modules related to hardware OpenGL ES emulation. The host-side modules and documentation are in $ANDROID_BUILD_TOP/sdk/emulator/opengl. Note that this directory contains encoder sources that are auto-generated with the 'emugen' host tool (see sdk/emulator/opengl/host/tools/emugen). To regenerate them, run external/qemu/distrib/update-emugl-sources.sh, after building the emulator from sources, this will populate the content here with the appropriate updated source files. You should do this whenever you update one of the *.types, *.in and *.attrib files located under one of: $AOSP/sdk/emulator/opengl/libs/GLESv1_dec/ $AOSP/sdk/emulator/opengl/libs/GLESv2_dec/ $AOSP/sdk/emulator/opengl/libs/renderControl_dec/ or when the 'emugen' tool itself is modified. anbox-0.0~git20191115/android/opengl/common.mk000066400000000000000000000212321356361734700207520ustar00rootroot00000000000000# This top-level build file is included by all modules that implement # the hardware OpenGL ES emulation for Android. # # We use it to ensure that all sub-Makefiles are included in the right # order for various variable definitions and usage to happen in the correct # order. # # The following macros are used to start a new GLES emulation module. # # This will define LOCAL_MODULE as $1, plus a few other variables # needed by the build system (e.g. LOCAL_MODULE_TAGS, LOCAL_MODULE_CLASS...) # # NOTE: You still need to define LOCAL_PATH before this # # Usage example: # # $(call emugl-begin-static-library,) # LOCAL_SRC_FILES := .... # LOCAL_C_INCLUDES += .... # $(call emugl-end-module) # emugl-begin-static-library = $(call emugl-begin-module,$1,STATIC_LIBRARY) emugl-begin-shared-library = $(call emugl-begin-module,$1,SHARED_LIBRARY) # Internal list of all declared modules (used for sanity checking) _emugl_modules := _emugl_HOST_modules := # do not use directly, see functions above instead emugl-begin-module = \ $(eval include $(CLEAR_VARS)) \ $(eval LOCAL_MODULE := $1) \ $(eval LOCAL_MODULE_CLASS := $(patsubst HOST_%,%,$(patsubst %EXECUTABLE,%EXECUTABLES,$(patsubst %LIBRARY,%LIBRARIES,$2)))) \ $(eval LOCAL_IS_HOST_MODULE := $(if $3,true,))\ $(eval LOCAL_C_INCLUDES := $(EMUGL_COMMON_INCLUDES)) \ $(eval LOCAL_CFLAGS := $(EMUGL_COMMON_CFLAGS)) \ $(eval _EMUGL_INCLUDE_TYPE := $(BUILD_$2)) \ $(call _emugl-init-module,$1,$2,$3) # Used to end a module definition, see function definitions above emugl-end-module = \ $(eval include $(_EMUGL_INCLUDE_TYPE))\ $(eval _EMUGL_INCLUDE_TYPE :=) \ $(eval _emugl_$(_emugl_HOST)modules += $(_emugl_MODULE))\ $(if $(EMUGL_DEBUG),$(call emugl-dump-module)) # Managing module exports and imports. # # A module can 'import' another module, by calling emugl-import. This will # make the current LOCAL_MODULE inherit various definitions exported from # the imported module. # # Module exports are defined by calling emugl-export. Here is an example: # # $(call emugl-begin-static-library,foo) # LOCAL_SRC_FILES := foo.c # $(call emugl-export,C_INCLUDES,$(LOCAL_PATH)) # $(call emugl-export,SHARED_LIBRARIES,libcutils) # $(call emugl-end-module) # # $(call emugl-begin-shared-library,bar) # LOCAL_SRC_FILES := bar.cpp # $(call emugl-import,foo) # $(call emugl-end-module) # # Here, we define a static library named 'foo' which exports an include # path and a shared library requirement, and a shared library 'bar' which # imports it. # # What this means is that: # # - 'bar' will automatically inherit foo's LOCAL_PATH in its LOCAL_C_INCLUDES # - 'bar' will automatically inherit libcutils in its own LOCAL_SHARED_LIBRARIES # # Note that order of declaration matters. If 'foo' is defined after 'bar' in # the example above, nothing will work correctly because dependencies are # computed at import time. # # # IMPORTANT: Imports are transitive, i.e. when module A imports B, # it automatically imports anything imported by B too. # This is the list of recognized export types we support for now. EMUGL_EXPORT_TYPES := \ CFLAGS \ LDLIBS \ LDFLAGS \ C_INCLUDES \ SHARED_LIBRARIES \ STATIC_LIBRARIES \ ADDITIONAL_DEPENDENCIES # Initialize a module in our database # $1: Module name # $2: Module type # $3: "HOST" for a host module, empty for a target one. _emugl-init-module = \ $(eval _emugl_HOST := $(if $3,HOST_,))\ $(eval _emugl_MODULE := $(_emugl_HOST)$1)\ $(if $(filter $(_emugl_$(_emugl_HOST)modules),$(_emugl_MODULE)),\ $(error There is already a $(if $3,host,) module named $1!)\ )\ $(eval _mod = $(_emugl_MODULE)) \ $(eval _emugl.$(_mod).type := $(patsubst HOST_%,%,$2))\ $(eval _emugl.$(_mod).imports :=) \ $(eval _emugl,$(_mod).moved :=) \ $(foreach _type,$(EMUGL_EXPORT_TYPES),\ $(eval _emugl.$(_mod).export.$(_type) :=)\ ) # Called to indicate that a module exports a given local variable for its # users. This also adds this to LOCAL_$1 # $1: Local variable type (e.g. CFLAGS, LDLIBS, etc...) # $2: Value(s) to append to the export emugl-export = \ $(eval _emugl.$(_emugl_MODULE).export.$1 += $2)\ $(eval LOCAL_$1 := $2 $(LOCAL_$1)) emugl-export-outer = \ $(eval _emugl.$(_emugl_MODULE).export.$1 += $2) # Called to indicate that a module imports the exports of another module # $1: list of modules to import # emugl-import = \ $(foreach _imod,$1,\ $(call _emugl-module-import,$(_emugl_HOST)$(_imod))\ ) _emugl-module-import = \ $(eval _mod := $(_emugl_MODULE))\ $(if $(filter-out $(_emugl_$(_emugl_HOST)modules),$1),\ $(info Unknown imported emugles module: $1)\ $(if $(_emugl_HOST),\ $(eval _names := $(patsubst HOST_%,%,$(_emugl_HOST_modules))),\ $(eval _names := $(_emugl_modules))\ )\ $(info Please one of the following names: $(_names))\ $(error Aborting)\ )\ $(if $(filter-out $(_emugl.$(_mod).imports),$1),\ $(eval _emugl.$(_mod).imports += $1)\ $(foreach _sub,$(_emugl.$1.imports),\ $(call _emugl-module-import,$(_sub))\ )\ $(foreach _type,$(EMUGL_EXPORT_TYPES),\ $(eval LOCAL_$(_type) := $(_emugl.$1.export.$(_type)) $(LOCAL_$(_type)))\ )\ $(if $(filter EXECUTABLE SHARED_LIBRARY,$(_emugl.$(_emugl_MODULE).type)),\ $(if $(filter STATIC_LIBRARY,$(_emugl.$1.type)),\ $(eval LOCAL_STATIC_LIBRARIES := $(1:HOST_%=%) $(LOCAL_STATIC_LIBRARIES))\ )\ $(if $(filter SHARED_LIBRARY,$(_emugl.$1.type)),\ $(if $(_emugl.$1.moved),,\ $(eval LOCAL_SHARED_LIBRARIES := $(1:HOST_%=%) $(LOCAL_SHARED_LIBRARIES))\ )\ )\ )\ ) _emugl-dump-list = \ $(foreach _list_item,$(strip $1),$(info . $(_list_item))) emugl-dump-module = \ $(info MODULE=$(_emugl_MODULE))\ $(info . HOST=$(_emugl_HOST))\ $(info . TYPE=$(_emugl.$(_emugl_MODULE).type))\ $(info . IMPORTS=$(_emugl.$(_emugl_MODULE).imports))\ $(foreach _type,$(EMUGL_EXPORT_TYPES),\ $(if $(filter C_INCLUDES ADDITIONAL_DEPENDENCIES,$(_type)),\ $(info . EXPORT.$(_type) :=)\ $(call _emugl-dump-list,$(_emugl.$(_emugl_MODULE).export.$(_type)))\ $(info . LOCAL_$(_type) :=)\ $(call _emugl-dump-list,$(LOCAL_$(_type)))\ ,\ $(info . EXPORT.$(_type) := $(strip $(_emugl.$(_emugl_MODULE).export.$(_type))))\ $(info . LOCAL_$(_type) := $(strip $(LOCAL_$(_type))))\ )\ )\ $(info . LOCAL_SRC_FILES := $(LOCAL_SRC_FILES))\ # This function can be called to generate the wrapper source files. # LOCAL_MODULE and LOCAL_MODULE_CLASS must be defined or the build will abort. # Source files will be stored in the local intermediates directory that will # be automatically added to your LOCAL_C_INCLUDES. # Usage: # $(call emugl-gen-wrapper,,) # emugl-gen-wrapper = \ $(eval _emugl_out := $(call local-intermediates-dir)) \ $(call emugl-gen-wrapper-generic,$(_emugl_out),$1,$2) \ $(call emugl-export,C_INCLUDES,$(_emugl_out)) # DO NOT CALL DIRECTLY, USE emugl-gen-wrapper instead. # # The following function can be called to generate GL library wrapper # Usage is: # # $(call emugl-gen-wrapper-generic,,,) # # is the destination directory where the generated sources are stored # is the source directory where to find .attrib, etc.. # is the emugen basename (see host/tools/emugen/README) # emugl-gen-wrapper-generic = $(eval $(emugl-gen-wrapper-generic-ev)) define emugl-gen-wrapper-generic-ev _emugl_wrap := $$1/$$3 _emugl_src := $$2/$$3 GEN := $$(_emugl_wrap)_wrapper_entry.cpp \ $$(_emugl_wrap)_wrapper_context.cpp \ $$(_emugl_wrap)_wrapper_context.h \ $$(_emugl_wrap)_wrapper_proc.h $$(GEN): PRIVATE_PATH := $$(LOCAL_PATH) $$(GEN): PRIVATE_CUSTOM_TOOL := $$(EMUGL_EMUGEN) -W $$1 -i $$2 $$3 $$(GEN): $$(EMUGL_EMUGEN) $$(_emugl_src).attrib $$(_emugl_src).in $$(_emugl_src).types $$(transform-generated-source) $$(call emugl-export,ADDITIONAL_DEPENDENCIES,$$(GEN)) LOCAL_GENERATED_SOURCES += $$(GEN) LOCAL_C_INCLUDES += $$1 #ifneq ($$(HOST_OS),windows) $$(call emugl-export,LDFLAGS,-ldl) #endif endef # Call this function when your shared library must be placed in a non-standard # library path (i.e. not under /system/lib # $1: library sub-path,relative to /system/lib # For example: $(call emugl-set-shared-library-subpath,egl) emugl-set-shared-library-subpath = \ $(eval LOCAL_MODULE_RELATIVE_PATH := $1)\ $(eval _emugl.$(LOCAL_MODULE).moved := true) anbox-0.0~git20191115/android/opengl/host/000077500000000000000000000000001356361734700201065ustar00rootroot00000000000000anbox-0.0~git20191115/android/opengl/host/include/000077500000000000000000000000001356361734700215315ustar00rootroot00000000000000anbox-0.0~git20191115/android/opengl/host/include/libOpenglRender/000077500000000000000000000000001356361734700246045ustar00rootroot00000000000000anbox-0.0~git20191115/android/opengl/host/include/libOpenglRender/IOStream.h000066400000000000000000000052251356361734700264440ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __IO_STREAM_H__ #define __IO_STREAM_H__ #include #include #include "ErrorLog.h" class IOStream { public: IOStream(size_t bufSize) { m_buf = NULL; m_bufsize = bufSize; m_free = 0; } virtual void *allocBuffer(size_t minSize) = 0; virtual int commitBuffer(size_t size) = 0; virtual const unsigned char *readFully( void *buf, size_t len) = 0; virtual const unsigned char *read( void *buf, size_t *inout_len) = 0; virtual int writeFully(const void* buf, size_t len) = 0; virtual ~IOStream() { // NOTE: m_buf is 'owned' by the child class thus we expect it to be released by it } unsigned char *alloc(size_t len) { if (m_buf && len > m_free) { if (flush() < 0) { ERR("Failed to flush in alloc\n"); return NULL; // we failed to flush so something is wrong } } if (!m_buf || len > m_bufsize) { int allocLen = m_bufsize < len ? len : m_bufsize; m_buf = (unsigned char *)allocBuffer(allocLen); if (!m_buf) { ERR("Alloc (%u bytes) failed\n", allocLen); return NULL; } m_bufsize = m_free = allocLen; } unsigned char *ptr; ptr = m_buf + (m_bufsize - m_free); m_free -= len; return ptr; } int flush() { if (!m_buf || m_free == m_bufsize) return 0; int stat = commitBuffer(m_bufsize - m_free); m_buf = NULL; m_free = 0; return stat; } const unsigned char *readback(void *buf, size_t len) { flush(); return readFully(buf, len); } private: unsigned char *m_buf; size_t m_bufsize; size_t m_free; }; // // When a client opens a connection to the renderer, it should // send unsigned int value indicating the "clientFlags". // The following are the bitmask of the clientFlags. // currently only one bit is used which flags the server // it should exit. // #define IOSTREAM_CLIENT_EXIT_SERVER 1 #endif anbox-0.0~git20191115/android/opengl/shared/000077500000000000000000000000001356361734700203775ustar00rootroot00000000000000anbox-0.0~git20191115/android/opengl/shared/OpenglCodecCommon/000077500000000000000000000000001356361734700237325ustar00rootroot00000000000000anbox-0.0~git20191115/android/opengl/shared/OpenglCodecCommon/Android.mk000066400000000000000000000012601356361734700256420ustar00rootroot00000000000000# This build script corresponds to a library containing many definitions # common to both the guest and the host. They relate to # LOCAL_PATH := $(call my-dir) commonSources := \ GLClientState.cpp \ ChecksumCalculator.cpp \ GLSharedGroup.cpp \ glUtils.cpp \ SocketStream.cpp \ TcpStream.cpp \ ### CodecCommon guest ############################################## $(call emugl-begin-static-library,libOpenglCodecCommon) LOCAL_SRC_FILES := $(commonSources) LOCAL_CFLAGS += -DLOG_TAG=\"eglCodecCommon\" $(call emugl-export,SHARED_LIBRARIES,libcutils libutils liblog) $(call emugl-export,C_INCLUDES,$(LOCAL_PATH)) $(call emugl-end-module) anbox-0.0~git20191115/android/opengl/shared/OpenglCodecCommon/ChecksumCalculator.cpp000066400000000000000000000124251356361734700302160ustar00rootroot00000000000000/* * Copyright (C) 2016 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "ChecksumCalculator.h" #include #include #include // Checklist when implementing new protocol: // 1. update CHECKSUMHELPER_MAX_VERSION // 2. update maxChecksumSize() // 3. update checksumByteSize() // 4. update addBuffer, writeChecksum, resetChecksum, validate // change CHECKSUMHELPER_MAX_VERSION when you want to update the protocol version #define CHECKSUMHELPER_MAX_VERSION 1 // checksum buffer size // Please add a new checksum buffer size when implementing a new protocol, // as well as modifying the maxChecksumSize function. static const size_t kV1ChecksumSize = 8; static constexpr size_t maxChecksumSize() { return 0 > kV1ChecksumSize ? 0 : kV1ChecksumSize; } static const size_t kMaxChecksumSize = maxChecksumSize(); // utility macros to create checksum string at compilation time #define CHECKSUMHELPER_VERSION_STR_PREFIX "ANDROID_EMU_CHECKSUM_HELPER_v" #define CHECKSUMHELPER_MACRO_TO_STR(x) #x #define CHECKSUMHELPER_MACRO_VAL_TO_STR(x) CHECKSUMHELPER_MACRO_TO_STR(x) static const uint32_t kMaxVersion = CHECKSUMHELPER_MAX_VERSION; static const char* kMaxVersionStrPrefix = CHECKSUMHELPER_VERSION_STR_PREFIX; static const char* kMaxVersionStr = CHECKSUMHELPER_VERSION_STR_PREFIX CHECKSUMHELPER_MACRO_VAL_TO_STR(CHECKSUMHELPER_MAX_VERSION); #undef CHECKSUMHELPER_MAX_VERSION #undef CHECKSUMHELPER_VERSION_STR_PREFIX #undef CHECKSUMHELPER_MACRO_TO_STR #undef CHECKSUMHELPER_MACRO_VAL_TO_STR uint32_t ChecksumCalculator::getMaxVersion() {return kMaxVersion;} const char* ChecksumCalculator::getMaxVersionStr() {return kMaxVersionStr;} const char* ChecksumCalculator::getMaxVersionStrPrefix() {return kMaxVersionStrPrefix;} bool ChecksumCalculator::setVersion(uint32_t version) { if (version > kMaxVersion) { // unsupported version LOG_CHECKSUMHELPER("%s: ChecksumCalculator Set Unsupported version Version %d\n", __FUNCTION__, m_version); return false; } if (m_isEncodingChecksum) { // setVersion is called in the middle of encoding checksums LOG_CHECKSUMHELPER("%s: called between addBuffer and writeChecksum\n", __FUNCTION__); return false; } m_version = version; LOG_CHECKSUMHELPER("%s: ChecksumCalculator Set Version %d\n", __FUNCTION__, m_version); return true; } size_t ChecksumCalculator::checksumByteSize() const { switch (m_version) { case 0: return 0; case 1: return sizeof(uint32_t) + sizeof(m_numWrite); default: return 0; } } void ChecksumCalculator::addBuffer(const void* buf, size_t packetLen) { m_isEncodingChecksum = true; switch (m_version) { case 1: m_v1BufferTotalLength += packetLen; break; } } bool ChecksumCalculator::writeChecksum(void* outputChecksum, size_t outputChecksumLen) { if (outputChecksumLen < checksumByteSize()) return false; char *checksumPtr = (char *)outputChecksum; switch (m_version) { case 1: { // protocol v1 is to reverse the packetLen and write it at the end uint32_t val = computeV1Checksum(); memcpy(checksumPtr, &val, sizeof(val)); memcpy(checksumPtr+sizeof(val), &m_numWrite, sizeof(m_numWrite)); break; } } resetChecksum(); m_numWrite++; return true; } void ChecksumCalculator::resetChecksum() { switch (m_version) { case 1: m_v1BufferTotalLength = 0; break; } m_isEncodingChecksum = false; } bool ChecksumCalculator::validate(const void* expectedChecksum, size_t expectedChecksumLen) { size_t checksumSize = checksumByteSize(); if (expectedChecksumLen != checksumSize) { m_numRead++; resetChecksum(); return false; } // buffers for computing the checksum unsigned char sChecksumBuffer[kMaxChecksumSize]; switch (m_version) { case 1: { uint32_t val = computeV1Checksum(); memcpy(sChecksumBuffer, &val, sizeof(val)); memcpy(sChecksumBuffer+sizeof(val), &m_numRead, sizeof(m_numRead)); break; } } bool isValid = !memcmp(sChecksumBuffer, expectedChecksum, checksumSize); m_numRead++; resetChecksum(); return isValid; } uint32_t ChecksumCalculator::computeV1Checksum() { uint32_t revLen = m_v1BufferTotalLength; revLen = (revLen & 0xffff0000) >> 16 | (revLen & 0x0000ffff) << 16; revLen = (revLen & 0xff00ff00) >> 8 | (revLen & 0x00ff00ff) << 8; revLen = (revLen & 0xf0f0f0f0) >> 4 | (revLen & 0x0f0f0f0f) << 4; revLen = (revLen & 0xcccccccc) >> 2 | (revLen & 0x33333333) << 2; revLen = (revLen & 0xaaaaaaaa) >> 1 | (revLen & 0x55555555) << 1; return revLen; } anbox-0.0~git20191115/android/opengl/shared/OpenglCodecCommon/ChecksumCalculator.h000066400000000000000000000167241356361734700276710ustar00rootroot00000000000000/* * Copyright (C) 2016 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include // Set TRACE_CHECKSUMHELPER to 1 to debug creation/destruction of GLprotocol // instances. #define TRACE_CHECKSUMHELPER 0 #if TRACE_CHECKSUMHELPER #define LOG_CHECKSUMHELPER(x...) fprintf(stderr, x) #else #define LOG_CHECKSUMHELPER(x...) #endif // ChecksumCalculator adds checksum as an array of bytes to GL pipe communication, which // size depends on the protocol version. Each pipe should use one ChecksumCalculator. // It can: // (1) take a list of buffers one by one and compute their checksum string, // in this case the checksum should be as the data in those buffers are // concatenated; // (2) compute the checksum of the buffer list, then either write them into // a buffer provided by user, or compare it against a checksum provided // by user // (3) support different checksum version in future. // // For backward compatibility, checksum version 0 behaves the same as there is // no checksum (i.e., checksumByteSize returns 0, validate always returns true, // addBuffer and writeCheckSum does nothing). // // Notice that to detect package lost, ChecksumCalculator also keeps track of how // many times it generates/validates checksums, and might use it as part of the // checksum. // // To evaluate checksums from a list of data buffers buf1, buf2... Please call // addBuffer(buf1, buf1len), addBuffer(buf2, buf2len) ... in order. // Then if the checksum needs to be encoded into a buffer, one needs to allocate // a checksum buffer with size checksumByteSize(), and call // writeChecksum(checksumBuffer) to write the checksum to the buffer. // If the checksum needs to be validated against an existing one, one needs to // call validate(existChecksum, existChecksumLen). // // The checksum generator and validator must be set to the same version, and // the validator must check ALL checksums in the order they are generated, // otherwise the validation function will return false. // // It is allowed to change the checksum version between calculating two // checksums. This is designed for backward compatibility reason. // // Example 1, encoding and decoding: // // bool testChecksum(void* buf, size_t bufLen) { // // encoding message // ChecksumCalculator encoder; // encoder.setVersion(1); // encoder.addBuffer(buf, bufLen); // std::vector message(bufLen + encoder.checksumByteSize()); // memcpy(&message[0], buf, bufLen); // encoder.writeChecksum(&message[0] + bufLen, encoder.checksumByteSize()); // // // decoding message // ChecksumCalculator decoder; // decoder.setVersion(1); // decoder.addBuffer(&message[0], bufLen); // return decoder.validate(&message[0] + bufLen, decoder.checksumByteSize()); // } // The return value is true. // // Example 2, decoding will fail if the order of messages is wrong: // // bool testChecksumOrder(void* buf1, size_t bufLen1, // void* buf2, size_t bufLen2) { // // encoding messages // ChecksumCalculator encoder; // encoder.setVersion(1); // // std::vector message1(bufLen1 + encoder.checksumByteSize()); // std::vector message2(bufLen2 + encoder.checksumByteSize()); // // encoder.addBuffer(buf1, bufLen1); // std::vector message1(bufLen1 + encoder.checksumByteSize()); // memcpy(&message1[0], buf1, bufLen1); // encoder.writeChecksum(&message1[0] + bufLen1, encoder.checksumByteSize()); // // encoder.addBuffer(buf2, bufLen2); // std::vector message2(bufLen2 + encoder.checksumByteSize()); // memcpy(&message2[0], buf2, bufLen2); // encoder.writeChecksum(&message2[0] + bufLen2, encoder.checksumByteSize()); // // // decoding messages // ChecksumCalculator decoder; // decoder.setVersion(1); // decoder.addBuffer(&message2[0], bufLen2); // // returns false because the decoding order is not consistent with // // encoding order // if (!decoder.validate(&message2[0]+bufLen2, decoder.checksumByteSize())) { // return false; // } // // decoder.addBuffer(&message1[0], bufLen1); // if (!decoder.validate(&message1[0]+bufLen1, decoder.checksumByteSize())) { // return false; // } // // return false; // } class ChecksumCalculator { public: // Get and set current checksum version uint32_t getVersion() const { return m_version; } // Call setVersion to set a checksum version. It should be called before // addBuffer(), writeChecksum() and validate(). And it should be called // exact once per rendering thread if both host and guest support checksum. // It won't be called if either host or guest does not support checksum. bool setVersion(uint32_t version); // Maximum supported checksum version static uint32_t getMaxVersion(); // A version string that looks like "ANDROID_EMU_CHECKSUM_HELPER_v1" // Used multiple times when the guest queries the maximum supported version // from the host. // The library owns the returned pointer. The returned pointer will be // deconstructed when unloading library. static const char* getMaxVersionStr(); static const char* getMaxVersionStrPrefix(); // Size of checksum in the current version size_t checksumByteSize() const; // Update the current checksum value from the data // at |buf| of |bufLen| bytes. Once all buffers // have been added, call writeChecksum() to store // the final checksum value and reset its state. void addBuffer(const void* buf, size_t bufLen); // Write the checksum from the list of buffers to outputChecksum // Will reset the list of buffers by calling resetChecksum. // Return false if the buffer is not long enough // Please query buffer size from checksumByteSize() bool writeChecksum(void* outputChecksum, size_t outputChecksumLen); // Restore the states for computing checksums. // Automatically called at the end of writeChecksum and validate. // Can also be used to abandon the current checksum being calculated. // Notes: it doesn't update the internal read / write counter void resetChecksum(); // Calculate the checksum from the list of buffers and // compare it with the checksum encoded in expectedChecksum // Will reset the list of buffers by calling resetChecksum. bool validate(const void* expectedChecksum, size_t expectedChecksumLen); protected: uint32_t m_version = 0; // A temporary state used to compute the total length of a list of buffers, // if addBuffer is called. uint32_t m_numRead = 0; uint32_t m_numWrite = 0; // m_isEncodingChecksum is true when between addBuffer and writeChecksum bool m_isEncodingChecksum = false; private: // Compute a 32bit checksum // Used in protocol v1 uint32_t computeV1Checksum(); // The buffer used in protocol version 1 to compute checksum. uint32_t m_v1BufferTotalLength = 0; }; anbox-0.0~git20191115/android/opengl/shared/OpenglCodecCommon/ErrorLog.h000066400000000000000000000021241356361734700256350ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _ERROR_LOG_H_ #define _ERROR_LOG_H_ #if defined(__ANDROID__) # include # define ERR(...) ALOGE(__VA_ARGS__) # ifdef EMUGL_DEBUG # define DBG(...) ALOGD(__VA_ARGS__) # else # define DBG(...) ((void)0) # endif #else # include # define ERR(...) fprintf(stderr, __VA_ARGS__) # ifdef EMUGL_DEBUG # define DBG(...) fprintf(stderr, __VA_ARGS__) # else # define DBG(...) ((void)0) # endif #endif #endif anbox-0.0~git20191115/android/opengl/shared/OpenglCodecCommon/FixedBuffer.h000066400000000000000000000025501356361734700262760ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _FIXED_BUFFER_H #define _FIXED_BUFFER_H class FixedBuffer { public: FixedBuffer(size_t initialSize = 0) { m_buffer = NULL; m_bufferLen = initialSize; alloc(m_bufferLen); } ~FixedBuffer() { delete [] m_buffer; m_bufferLen = 0; } void * alloc(size_t size) { if (m_bufferLen >= size) return (void *)(m_buffer); if (m_buffer != NULL) delete[] m_buffer; m_bufferLen = size; m_buffer = new unsigned char[m_bufferLen]; if (m_buffer == NULL) m_bufferLen = 0; return m_buffer; } void *ptr() { return m_buffer; } size_t len() { return m_bufferLen; } private: unsigned char *m_buffer; size_t m_bufferLen; }; #endif anbox-0.0~git20191115/android/opengl/shared/OpenglCodecCommon/GLClientState.cpp000066400000000000000000000300451356361734700271020ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "GLClientState.h" #include "ErrorLog.h" #include #include #include #include "glUtils.h" #include #ifndef MAX #define MAX(a, b) ((a) < (b) ? (b) : (a)) #endif GLClientState::GLClientState(int nLocations) { if (nLocations < LAST_LOCATION) { nLocations = LAST_LOCATION; } m_nLocations = nLocations; m_states = new VertexAttribState[m_nLocations]; for (int i = 0; i < m_nLocations; i++) { m_states[i].enabled = 0; m_states[i].enableDirty = false; m_states[i].data = 0; } m_currentArrayVbo = 0; m_currentIndexVbo = 0; // init gl constans; m_states[VERTEX_LOCATION].glConst = GL_VERTEX_ARRAY; m_states[NORMAL_LOCATION].glConst = GL_NORMAL_ARRAY; m_states[COLOR_LOCATION].glConst = GL_COLOR_ARRAY; m_states[POINTSIZE_LOCATION].glConst = GL_POINT_SIZE_ARRAY_OES; m_states[TEXCOORD0_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY; m_states[TEXCOORD1_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY; m_states[TEXCOORD2_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY; m_states[TEXCOORD3_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY; m_states[TEXCOORD4_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY; m_states[TEXCOORD5_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY; m_states[TEXCOORD6_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY; m_states[TEXCOORD7_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY; m_states[MATRIXINDEX_LOCATION].glConst = GL_MATRIX_INDEX_ARRAY_OES; m_states[WEIGHT_LOCATION].glConst = GL_WEIGHT_ARRAY_OES; m_activeTexture = 0; m_currentProgram = 0; m_pixelStore.unpack_alignment = 4; m_pixelStore.pack_alignment = 4; memset(m_tex.unit, 0, sizeof(m_tex.unit)); m_tex.activeUnit = &m_tex.unit[0]; m_tex.textures = NULL; m_tex.numTextures = 0; m_tex.allocTextures = 0; m_maxVertexAttribsDirty = true; } GLClientState::~GLClientState() { delete m_states; } void GLClientState::enable(int location, int state) { if (!validLocation(location)) { return; } m_states[location].enableDirty |= (state != m_states[location].enabled); m_states[location].enabled = state; } void GLClientState::setState(int location, int size, GLenum type, GLboolean normalized, GLsizei stride, const void *data) { if (!validLocation(location)) { return; } m_states[location].size = size; m_states[location].type = type; m_states[location].stride = stride; m_states[location].data = (void*)data; m_states[location].bufferObject = m_currentArrayVbo; m_states[location].elementSize = size ? (glSizeof(type) * size) : 0; m_states[location].normalized = normalized; } void GLClientState::setBufferObject(int location, GLuint id) { if (!validLocation(location)) { return; } m_states[location].bufferObject = id; } const GLClientState::VertexAttribState * GLClientState::getState(int location) { if (!validLocation(location)) { return NULL; } return & m_states[location]; } const GLClientState::VertexAttribState * GLClientState::getStateAndEnableDirty(int location, bool *enableChanged) { if (!validLocation(location)) { return NULL; } if (enableChanged) { *enableChanged = m_states[location].enableDirty; } m_states[location].enableDirty = false; return & m_states[location]; } int GLClientState::getLocation(GLenum loc) { int retval; switch(loc) { case GL_VERTEX_ARRAY: retval = int(VERTEX_LOCATION); break; case GL_NORMAL_ARRAY: retval = int(NORMAL_LOCATION); break; case GL_COLOR_ARRAY: retval = int(COLOR_LOCATION); break; case GL_POINT_SIZE_ARRAY_OES: retval = int(POINTSIZE_LOCATION); break; case GL_TEXTURE_COORD_ARRAY: retval = int (TEXCOORD0_LOCATION + m_activeTexture); break; case GL_MATRIX_INDEX_ARRAY_OES: retval = int (MATRIXINDEX_LOCATION); break; case GL_WEIGHT_ARRAY_OES: retval = int (WEIGHT_LOCATION); break; default: retval = loc; } return retval; } void GLClientState::getClientStatePointer(GLenum pname, GLvoid** params) { const GLClientState::VertexAttribState *state = NULL; switch (pname) { case GL_VERTEX_ARRAY_POINTER: { state = getState(GLClientState::VERTEX_LOCATION); break; } case GL_NORMAL_ARRAY_POINTER: { state = getState(GLClientState::NORMAL_LOCATION); break; } case GL_COLOR_ARRAY_POINTER: { state = getState(GLClientState::COLOR_LOCATION); break; } case GL_TEXTURE_COORD_ARRAY_POINTER: { state = getState(getActiveTexture() + GLClientState::TEXCOORD0_LOCATION); break; } case GL_POINT_SIZE_ARRAY_POINTER_OES: { state = getState(GLClientState::POINTSIZE_LOCATION); break; } case GL_MATRIX_INDEX_ARRAY_POINTER_OES: { state = getState(GLClientState::MATRIXINDEX_LOCATION); break; } case GL_WEIGHT_ARRAY_POINTER_OES: { state = getState(GLClientState::WEIGHT_LOCATION); break; } } if (state && params) *params = state->data; } int GLClientState::setPixelStore(GLenum param, GLint value) { int retval = 0; switch(param) { case GL_UNPACK_ALIGNMENT: if (value == 1 || value == 2 || value == 4 || value == 8) { m_pixelStore.unpack_alignment = value; } else { retval = GL_INVALID_VALUE; } break; case GL_PACK_ALIGNMENT: if (value == 1 || value == 2 || value == 4 || value == 8) { m_pixelStore.pack_alignment = value; } else { retval = GL_INVALID_VALUE; } break; default: retval = GL_INVALID_ENUM; } return retval; } size_t GLClientState::pixelDataSize(GLsizei width, GLsizei height, GLenum format, GLenum type, int pack) const { if (width <= 0 || height <= 0) return 0; int pixelsize = glUtilsPixelBitSize(format, type) >> 3; int alignment = pack ? m_pixelStore.pack_alignment : m_pixelStore.unpack_alignment; if (pixelsize == 0 ) { ERR("unknown pixel size: width: %d height: %d format: %d type: %d pack: %d align: %d\n", width, height, format, type, pack, alignment); } size_t linesize = pixelsize * width; size_t aligned_linesize = int(linesize / alignment) * alignment; if (aligned_linesize < linesize) { aligned_linesize += alignment; } return aligned_linesize * height; } GLenum GLClientState::setActiveTextureUnit(GLenum texture) { GLuint unit = texture - GL_TEXTURE0; if (unit >= MAX_TEXTURE_UNITS) { return GL_INVALID_ENUM; } m_tex.activeUnit = &m_tex.unit[unit]; return GL_NO_ERROR; } GLenum GLClientState::getActiveTextureUnit() const { return GL_TEXTURE0 + (m_tex.activeUnit - &m_tex.unit[0]); } void GLClientState::enableTextureTarget(GLenum target) { switch (target) { case GL_TEXTURE_2D: m_tex.activeUnit->enables |= (1u << TEXTURE_2D); break; case GL_TEXTURE_EXTERNAL_OES: m_tex.activeUnit->enables |= (1u << TEXTURE_EXTERNAL); break; } } void GLClientState::disableTextureTarget(GLenum target) { switch (target) { case GL_TEXTURE_2D: m_tex.activeUnit->enables &= ~(1u << TEXTURE_2D); break; case GL_TEXTURE_EXTERNAL_OES: m_tex.activeUnit->enables &= ~(1u << TEXTURE_EXTERNAL); break; } } GLenum GLClientState::getPriorityEnabledTarget(GLenum allDisabled) const { unsigned int enables = m_tex.activeUnit->enables; if (enables & (1u << TEXTURE_EXTERNAL)) { return GL_TEXTURE_EXTERNAL_OES; } else if (enables & (1u << TEXTURE_2D)) { return GL_TEXTURE_2D; } else { return allDisabled; } } int GLClientState::compareTexId(const void* pid, const void* prec) { const GLuint* id = (const GLuint*)pid; const TextureRec* rec = (const TextureRec*)prec; return (GLint)(*id) - (GLint)rec->id; } GLenum GLClientState::bindTexture(GLenum target, GLuint texture, GLboolean* firstUse) { GLboolean first = GL_FALSE; TextureRec* texrec = NULL; if (texture != 0) { if (m_tex.textures) { texrec = (TextureRec*)bsearch(&texture, m_tex.textures, m_tex.numTextures, sizeof(TextureRec), compareTexId); } if (!texrec) { if (!(texrec = addTextureRec(texture, target))) { return GL_OUT_OF_MEMORY; } first = GL_TRUE; } if (target != texrec->target) { return GL_INVALID_OPERATION; } } switch (target) { case GL_TEXTURE_2D: m_tex.activeUnit->texture[TEXTURE_2D] = texture; break; case GL_TEXTURE_EXTERNAL_OES: m_tex.activeUnit->texture[TEXTURE_EXTERNAL] = texture; break; } if (firstUse) { *firstUse = first; } return GL_NO_ERROR; } GLClientState::TextureRec* GLClientState::addTextureRec(GLuint id, GLenum target) { if (m_tex.numTextures == m_tex.allocTextures) { const GLuint MAX_TEXTURES = 0xFFFFFFFFu; GLuint newAlloc; if (MAX_TEXTURES - m_tex.allocTextures >= m_tex.allocTextures) { newAlloc = MAX(4, 2 * m_tex.allocTextures); } else { if (m_tex.allocTextures == MAX_TEXTURES) { return NULL; } newAlloc = MAX_TEXTURES; } TextureRec* newTextures = (TextureRec*)realloc(m_tex.textures, newAlloc * sizeof(TextureRec)); if (!newTextures) { return NULL; } m_tex.textures = newTextures; m_tex.allocTextures = newAlloc; } TextureRec* tex = m_tex.textures + m_tex.numTextures; TextureRec* prev = tex - 1; while (tex != m_tex.textures && id < prev->id) { *tex-- = *prev--; } tex->id = id; tex->target = target; m_tex.numTextures++; return tex; } GLuint GLClientState::getBoundTexture(GLenum target) const { switch (target) { case GL_TEXTURE_2D: return m_tex.activeUnit->texture[TEXTURE_2D]; case GL_TEXTURE_EXTERNAL_OES: return m_tex.activeUnit->texture[TEXTURE_EXTERNAL]; default: return 0; } } void GLClientState::deleteTextures(GLsizei n, const GLuint* textures) { // Updating the textures array could be made more efficient when deleting // several textures: // - compacting the array could be done in a single pass once the deleted // textures are marked, or // - could swap deleted textures to the end and re-sort. TextureRec* texrec; for (const GLuint* texture = textures; texture != textures + n; texture++) { texrec = (TextureRec*)bsearch(texture, m_tex.textures, m_tex.numTextures, sizeof(TextureRec), compareTexId); if (texrec) { const TextureRec* end = m_tex.textures + m_tex.numTextures; memmove(texrec, texrec + 1, (end - texrec - 1) * sizeof(TextureRec)); m_tex.numTextures--; for (TextureUnit* unit = m_tex.unit; unit != m_tex.unit + MAX_TEXTURE_UNITS; unit++) { if (unit->texture[TEXTURE_2D] == *texture) { unit->texture[TEXTURE_2D] = 0; } else if (unit->texture[TEXTURE_EXTERNAL] == *texture) { unit->texture[TEXTURE_EXTERNAL] = 0; } } } } } anbox-0.0~git20191115/android/opengl/shared/OpenglCodecCommon/GLClientState.h000066400000000000000000000400321356361734700265440ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _GL_CLIENT_STATE_H_ #define _GL_CLIENT_STATE_H_ #define GL_API #ifndef ANDROID #define GL_APIENTRY #define GL_APIENTRYP #endif #include #include #include #include #include #include #include "ErrorLog.h" #include "codec_defs.h" class GLClientState { public: typedef enum { VERTEX_LOCATION = 0, NORMAL_LOCATION = 1, COLOR_LOCATION = 2, POINTSIZE_LOCATION = 3, TEXCOORD0_LOCATION = 4, TEXCOORD1_LOCATION = 5, TEXCOORD2_LOCATION = 6, TEXCOORD3_LOCATION = 7, TEXCOORD4_LOCATION = 8, TEXCOORD5_LOCATION = 9, TEXCOORD6_LOCATION = 10, TEXCOORD7_LOCATION = 11, MATRIXINDEX_LOCATION = 12, WEIGHT_LOCATION = 13, LAST_LOCATION = 14 } StateLocation; typedef struct { GLint enabled; GLint size; GLenum type; GLsizei stride; void *data; GLuint bufferObject; GLenum glConst; unsigned int elementSize; bool enableDirty; // true if any enable state has changed since last draw bool normalized; } VertexAttribState; typedef struct { int unpack_alignment; int pack_alignment; } PixelStoreState; enum { MAX_TEXTURE_UNITS = 32, }; public: GLClientState(int nLocations = CODEC_MAX_VERTEX_ATTRIBUTES); ~GLClientState(); int nLocations() { return m_nLocations; } const PixelStoreState *pixelStoreState() { return &m_pixelStore; } int setPixelStore(GLenum param, GLint value); GLuint currentArrayVbo() { return m_currentArrayVbo; } GLuint currentIndexVbo() { return m_currentIndexVbo; } void enable(int location, int state); void setState(int location, int size, GLenum type, GLboolean normalized, GLsizei stride, const void *data); void setBufferObject(int location, GLuint id); const VertexAttribState *getState(int location); const VertexAttribState *getStateAndEnableDirty(int location, bool *enableChanged); int getLocation(GLenum loc); void setActiveTexture(int texUnit) {m_activeTexture = texUnit; }; int getActiveTexture() const { return m_activeTexture; } void setMaxVertexAttribs(int val) { m_maxVertexAttribs = val; m_maxVertexAttribsDirty = false; } void unBindBuffer(GLuint id) { if (m_currentArrayVbo == id) m_currentArrayVbo = 0; else if (m_currentIndexVbo == id) m_currentIndexVbo = 0; } int bindBuffer(GLenum target, GLuint id) { int err = 0; switch(target) { case GL_ARRAY_BUFFER: m_currentArrayVbo = id; break; case GL_ELEMENT_ARRAY_BUFFER: m_currentIndexVbo = id; break; default: err = -1; } return err; } int getBuffer(GLenum target) { int ret=0; switch (target) { case GL_ARRAY_BUFFER: ret = m_currentArrayVbo; break; case GL_ELEMENT_ARRAY_BUFFER: ret = m_currentIndexVbo; break; default: ret = -1; } return ret; } size_t pixelDataSize(GLsizei width, GLsizei height, GLenum format, GLenum type, int pack) const; void setCurrentProgram(GLint program) { m_currentProgram = program; } GLint currentProgram() const { return m_currentProgram; } /* OES_EGL_image_external * * These functions manipulate GL state which interacts with the * OES_EGL_image_external extension, to support client-side emulation on * top of host implementations that don't have it. * * Most of these calls should only be used with TEXTURE_2D or * TEXTURE_EXTERNAL_OES texture targets; TEXTURE_CUBE_MAP or other extension * targets should bypass this. An exception is bindTexture(), which should * see all glBindTexture() calls for any target. */ // glActiveTexture(GL_TEXTURE0 + i) // Sets the active texture unit. Up to MAX_TEXTURE_UNITS are supported. GLenum setActiveTextureUnit(GLenum texture); GLenum getActiveTextureUnit() const; // glEnable(GL_TEXTURE_(2D|EXTERNAL_OES)) void enableTextureTarget(GLenum target); // glDisable(GL_TEXTURE_(2D|EXTERNAL_OES)) void disableTextureTarget(GLenum target); // Implements the target priority logic: // * Return GL_TEXTURE_EXTERNAL_OES if enabled, else // * Return GL_TEXTURE_2D if enabled, else // * Return the allDisabled value. // For some cases passing GL_TEXTURE_2D for allDisabled makes callee code // simpler; for other cases passing a recognizable enum like GL_ZERO or // GL_INVALID_ENUM is appropriate. GLenum getPriorityEnabledTarget(GLenum allDisabled) const; // glBindTexture(GL_TEXTURE_*, ...) // Set the target binding of the active texture unit to texture. Returns // GL_NO_ERROR on success or GL_INVALID_OPERATION if the texture has // previously been bound to a different target. If firstUse is not NULL, // it is set to indicate whether this is the first use of the texture. // For accurate error detection, bindTexture should be called for *all* // targets, not just 2D and EXTERNAL_OES. GLenum bindTexture(GLenum target, GLuint texture, GLboolean* firstUse); // Return the texture currently bound to GL_TEXTURE_(2D|EXTERNAL_OES). GLuint getBoundTexture(GLenum target) const; // glDeleteTextures(...) // Remove references to the to-be-deleted textures. void deleteTextures(GLsizei n, const GLuint* textures); private: PixelStoreState m_pixelStore; VertexAttribState *m_states; int m_maxVertexAttribs; bool m_maxVertexAttribsDirty; int m_nLocations; GLuint m_currentArrayVbo; GLuint m_currentIndexVbo; int m_activeTexture; GLint m_currentProgram; bool validLocation(int location) { return (location >= 0 && location < m_nLocations); } enum TextureTarget { TEXTURE_2D = 0, TEXTURE_EXTERNAL = 1, TEXTURE_TARGET_COUNT }; struct TextureUnit { unsigned int enables; GLuint texture[TEXTURE_TARGET_COUNT]; }; struct TextureRec { GLuint id; GLenum target; }; struct TextureState { TextureUnit unit[MAX_TEXTURE_UNITS]; TextureUnit* activeUnit; TextureRec* textures; GLuint numTextures; GLuint allocTextures; }; TextureState m_tex; static int compareTexId(const void* pid, const void* prec); TextureRec* addTextureRec(GLuint id, GLenum target); public: void getClientStatePointer(GLenum pname, GLvoid** params); template int getVertexAttribParameter(GLuint index, GLenum param, T *ptr) { bool handled = true; const VertexAttribState *vertexAttrib = getState(index); if (vertexAttrib == NULL) { ERR("getVeterxAttriParameter for non existant index %d\n", index); // set gl error; return handled; } switch(param) { case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: *ptr = (T)(vertexAttrib->bufferObject); break; case GL_VERTEX_ATTRIB_ARRAY_ENABLED: *ptr = (T)(vertexAttrib->enabled); break; case GL_VERTEX_ATTRIB_ARRAY_SIZE: *ptr = (T)(vertexAttrib->size); break; case GL_VERTEX_ATTRIB_ARRAY_STRIDE: *ptr = (T)(vertexAttrib->stride); break; case GL_VERTEX_ATTRIB_ARRAY_TYPE: *ptr = (T)(vertexAttrib->type); break; case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED: *ptr = (T)(vertexAttrib->normalized); break; case GL_CURRENT_VERTEX_ATTRIB: handled = false; break; default: handled = false; ERR("unknown vertex-attrib parameter param %d\n", param); } return handled; } template bool getClientStateParameter(GLenum param, T* ptr) { bool isClientStateParam = false; switch (param) { case GL_CLIENT_ACTIVE_TEXTURE: { GLint tex = getActiveTexture() + GL_TEXTURE0; *ptr = tex; isClientStateParam = true; break; } case GL_VERTEX_ARRAY_SIZE: { const GLClientState::VertexAttribState *state = getState(GLClientState::VERTEX_LOCATION); *ptr = state->size; isClientStateParam = true; break; } case GL_VERTEX_ARRAY_TYPE: { const GLClientState::VertexAttribState *state = getState(GLClientState::VERTEX_LOCATION); *ptr = state->type; isClientStateParam = true; break; } case GL_VERTEX_ARRAY_STRIDE: { const GLClientState::VertexAttribState *state = getState(GLClientState::VERTEX_LOCATION); *ptr = state->stride; isClientStateParam = true; break; } case GL_COLOR_ARRAY_SIZE: { const GLClientState::VertexAttribState *state = getState(GLClientState::COLOR_LOCATION); *ptr = state->size; isClientStateParam = true; break; } case GL_COLOR_ARRAY_TYPE: { const GLClientState::VertexAttribState *state = getState(GLClientState::COLOR_LOCATION); *ptr = state->type; isClientStateParam = true; break; } case GL_COLOR_ARRAY_STRIDE: { const GLClientState::VertexAttribState *state = getState(GLClientState::COLOR_LOCATION); *ptr = state->stride; isClientStateParam = true; break; } case GL_NORMAL_ARRAY_TYPE: { const GLClientState::VertexAttribState *state = getState(GLClientState::NORMAL_LOCATION); *ptr = state->type; isClientStateParam = true; break; } case GL_NORMAL_ARRAY_STRIDE: { const GLClientState::VertexAttribState *state = getState(GLClientState::NORMAL_LOCATION); *ptr = state->stride; isClientStateParam = true; break; } case GL_TEXTURE_COORD_ARRAY_SIZE: { const GLClientState::VertexAttribState *state = getState(getActiveTexture() + GLClientState::TEXCOORD0_LOCATION); *ptr = state->size; isClientStateParam = true; break; } case GL_TEXTURE_COORD_ARRAY_TYPE: { const GLClientState::VertexAttribState *state = getState(getActiveTexture() + GLClientState::TEXCOORD0_LOCATION); *ptr = state->type; isClientStateParam = true; break; } case GL_TEXTURE_COORD_ARRAY_STRIDE: { const GLClientState::VertexAttribState *state = getState(getActiveTexture() + GLClientState::TEXCOORD0_LOCATION); *ptr = state->stride; isClientStateParam = true; break; } case GL_POINT_SIZE_ARRAY_TYPE_OES: { const GLClientState::VertexAttribState *state = getState(GLClientState::POINTSIZE_LOCATION); *ptr = state->type; isClientStateParam = true; break; } case GL_POINT_SIZE_ARRAY_STRIDE_OES: { const GLClientState::VertexAttribState *state = getState(GLClientState::POINTSIZE_LOCATION); *ptr = state->stride; isClientStateParam = true; break; } case GL_MATRIX_INDEX_ARRAY_SIZE_OES: { const GLClientState::VertexAttribState *state = getState(GLClientState::MATRIXINDEX_LOCATION); *ptr = state->size; isClientStateParam = true; break; } case GL_MATRIX_INDEX_ARRAY_TYPE_OES: { const GLClientState::VertexAttribState *state = getState(GLClientState::MATRIXINDEX_LOCATION); *ptr = state->type; isClientStateParam = true; break; } case GL_MATRIX_INDEX_ARRAY_STRIDE_OES: { const GLClientState::VertexAttribState *state = getState(GLClientState::MATRIXINDEX_LOCATION); *ptr = state->stride; isClientStateParam = true; break; } case GL_WEIGHT_ARRAY_SIZE_OES: { const GLClientState::VertexAttribState *state = getState(GLClientState::WEIGHT_LOCATION); *ptr = state->size; isClientStateParam = true; break; } case GL_WEIGHT_ARRAY_TYPE_OES: { const GLClientState::VertexAttribState *state = getState(GLClientState::WEIGHT_LOCATION); *ptr = state->type; isClientStateParam = true; break; } case GL_WEIGHT_ARRAY_STRIDE_OES: { const GLClientState::VertexAttribState *state = getState(GLClientState::WEIGHT_LOCATION); *ptr = state->stride; isClientStateParam = true; break; } case GL_VERTEX_ARRAY_BUFFER_BINDING: { const GLClientState::VertexAttribState *state = getState(GLClientState::VERTEX_LOCATION); *ptr = state->bufferObject; isClientStateParam = true; break; } case GL_NORMAL_ARRAY_BUFFER_BINDING: { const GLClientState::VertexAttribState *state = getState(GLClientState::NORMAL_LOCATION); *ptr = state->bufferObject; isClientStateParam = true; break; } case GL_COLOR_ARRAY_BUFFER_BINDING: { const GLClientState::VertexAttribState *state = getState(GLClientState::COLOR_LOCATION); *ptr = state->bufferObject; isClientStateParam = true; break; } case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING: { const GLClientState::VertexAttribState *state = getState(getActiveTexture()+GLClientState::TEXCOORD0_LOCATION); *ptr = state->bufferObject; isClientStateParam = true; break; } case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES: { const GLClientState::VertexAttribState *state = getState(GLClientState::POINTSIZE_LOCATION); *ptr = state->bufferObject; isClientStateParam = true; break; } case GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES: { const GLClientState::VertexAttribState *state = getState(GLClientState::MATRIXINDEX_LOCATION); *ptr = state->bufferObject; isClientStateParam = true; break; } case GL_WEIGHT_ARRAY_BUFFER_BINDING_OES: { const GLClientState::VertexAttribState *state = getState(GLClientState::WEIGHT_LOCATION); *ptr = state->bufferObject; isClientStateParam = true; break; } case GL_ARRAY_BUFFER_BINDING: { int buffer = getBuffer(GL_ARRAY_BUFFER); *ptr = buffer; isClientStateParam = true; break; } case GL_ELEMENT_ARRAY_BUFFER_BINDING: { int buffer = getBuffer(GL_ELEMENT_ARRAY_BUFFER); *ptr = buffer; isClientStateParam = true; break; } case GL_MAX_VERTEX_ATTRIBS: { if (m_maxVertexAttribsDirty) { isClientStateParam = false; } else { *ptr = m_maxVertexAttribs; isClientStateParam = true; } break; } } return isClientStateParam; } }; #endif anbox-0.0~git20191115/android/opengl/shared/OpenglCodecCommon/GLSharedGroup.cpp000077500000000000000000000332301356361734700271100ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "GLSharedGroup.h" /**** KeyedVector utilities ****/ template static void clearObjectMap(android::DefaultKeyedVector& v) { for (size_t i = 0; i < v.size(); i++) delete v.valueAt(i); v.clear(); } /**** BufferData ****/ BufferData::BufferData() : m_size(0) {}; BufferData::BufferData(GLsizeiptr size, void * data) : m_size(size) { void * buffer = NULL; if (size>0) buffer = m_fixedBuffer.alloc(size); if (data) memcpy(buffer, data, size); } /**** ProgramData ****/ ProgramData::ProgramData() : m_numIndexes(0), m_initialized(false), m_locShiftWAR(false) { m_Indexes = NULL; } void ProgramData::initProgramData(GLuint numIndexes) { m_initialized = true; m_numIndexes = numIndexes; delete[] m_Indexes; m_Indexes = new IndexInfo[numIndexes]; m_locShiftWAR = false; } bool ProgramData::isInitialized() { return m_initialized; } ProgramData::~ProgramData() { delete[] m_Indexes; m_Indexes = NULL; } void ProgramData::setIndexInfo(GLuint index, GLint base, GLint size, GLenum type) { if (index>=m_numIndexes) return; m_Indexes[index].base = base; m_Indexes[index].size = size; m_Indexes[index].type = type; if (index > 0) { m_Indexes[index].appBase = m_Indexes[index-1].appBase + m_Indexes[index-1].size; } else { m_Indexes[index].appBase = 0; } m_Indexes[index].hostLocsPerElement = 1; m_Indexes[index].flags = 0; m_Indexes[index].samplerValue = 0; } void ProgramData::setIndexFlags(GLuint index, GLuint flags) { if (index >= m_numIndexes) return; m_Indexes[index].flags |= flags; } GLuint ProgramData::getIndexForLocation(GLint location) { GLuint index = m_numIndexes; GLint minDist = -1; for (GLuint i=0;i= 0 && (minDist < 0 || dist < minDist)) { index = i; minDist = dist; } } return index; } GLenum ProgramData::getTypeForLocation(GLint location) { GLuint index = getIndexForLocation(location); if (index 1) { m_locShiftWAR = true; } } GLint ProgramData::locationWARHostToApp(GLint hostLoc, GLint arrIndex) { if (!m_locShiftWAR) return hostLoc; GLuint index = getIndexForLocation(hostLoc); if (index 0) { m_Indexes[index].hostLocsPerElement = (hostLoc - m_Indexes[index].base) / arrIndex; } return m_Indexes[index].appBase + arrIndex; } return -1; } GLint ProgramData::locationWARAppToHost(GLint appLoc) { if (!m_locShiftWAR) return appLoc; for(GLuint i=0; i= 0 && elemIndex < m_Indexes[i].size) { return m_Indexes[i].base + elemIndex * m_Indexes[i].hostLocsPerElement; } } return -1; } GLint ProgramData::getNextSamplerUniform(GLint index, GLint* val, GLenum* target) { for (GLint i = index + 1; i >= 0 && i < (GLint)m_numIndexes; i++) { if (m_Indexes[i].type == GL_SAMPLER_2D) { if (val) *val = m_Indexes[i].samplerValue; if (target) { if (m_Indexes[i].flags & INDEX_FLAG_SAMPLER_EXTERNAL) { *target = GL_TEXTURE_EXTERNAL_OES; } else { *target = GL_TEXTURE_2D; } } return i; } } return -1; } bool ProgramData::setSamplerUniform(GLint appLoc, GLint val, GLenum* target) { for (GLuint i = 0; i < m_numIndexes; i++) { GLint elemIndex = appLoc - m_Indexes[i].appBase; if (elemIndex >= 0 && elemIndex < m_Indexes[i].size) { if (m_Indexes[i].type == GL_TEXTURE_2D) { m_Indexes[i].samplerValue = val; if (target) { if (m_Indexes[i].flags & INDEX_FLAG_SAMPLER_EXTERNAL) { *target = GL_TEXTURE_EXTERNAL_OES; } else { *target = GL_TEXTURE_2D; } } return true; } } } return false; } bool ProgramData::attachShader(GLuint shader) { size_t n = m_shaders.size(); for (size_t i = 0; i < n; i++) { if (m_shaders[i] == shader) { return false; } } // AKA m_shaders.push_back(), but that has an ambiguous call to insertAt() // due to the default parameters. This is the desired insertAt() overload. m_shaders.insertAt(shader, m_shaders.size(), 1); return true; } bool ProgramData::detachShader(GLuint shader) { size_t n = m_shaders.size(); for (size_t i = 0; i < n; i++) { if (m_shaders[i] == shader) { m_shaders.removeAt(i); return true; } } return false; } /***** GLSharedGroup ****/ GLSharedGroup::GLSharedGroup() : m_buffers(android::DefaultKeyedVector(NULL)), m_programs(android::DefaultKeyedVector(NULL)), m_shaders(android::DefaultKeyedVector(NULL)) { } GLSharedGroup::~GLSharedGroup() { m_buffers.clear(); m_programs.clear(); clearObjectMap(m_buffers); clearObjectMap(m_programs); clearObjectMap(m_shaders); } bool GLSharedGroup::isObject(GLuint obj) { android::AutoMutex _lock(m_lock); return ((m_shaders.valueFor(obj)!=NULL) || (m_programs.valueFor(obj)!=NULL)); } BufferData * GLSharedGroup::getBufferData(GLuint bufferId) { android::AutoMutex _lock(m_lock); return m_buffers.valueFor(bufferId); } void GLSharedGroup::addBufferData(GLuint bufferId, GLsizeiptr size, void * data) { android::AutoMutex _lock(m_lock); m_buffers.add(bufferId, new BufferData(size, data)); } void GLSharedGroup::updateBufferData(GLuint bufferId, GLsizeiptr size, void * data) { android::AutoMutex _lock(m_lock); ssize_t idx = m_buffers.indexOfKey(bufferId); if (idx >= 0) { delete m_buffers.valueAt(idx); m_buffers.editValueAt(idx) = new BufferData(size, data); } else { m_buffers.add(bufferId, new BufferData(size, data)); } } GLenum GLSharedGroup::subUpdateBufferData(GLuint bufferId, GLintptr offset, GLsizeiptr size, void * data) { android::AutoMutex _lock(m_lock); BufferData * buf = m_buffers.valueFor(bufferId); if ((!buf) || (buf->m_size < offset+size) || (offset < 0) || (size<0)) return GL_INVALID_VALUE; //it's safe to update now memcpy((char*)buf->m_fixedBuffer.ptr() + offset, data, size); return GL_NO_ERROR; } void GLSharedGroup::deleteBufferData(GLuint bufferId) { android::AutoMutex _lock(m_lock); ssize_t idx = m_buffers.indexOfKey(bufferId); if (idx >= 0) { delete m_buffers.valueAt(idx); m_buffers.removeItemsAt(idx); } } void GLSharedGroup::addProgramData(GLuint program) { android::AutoMutex _lock(m_lock); ProgramData *pData = m_programs.valueFor(program); if (pData) { m_programs.removeItem(program); delete pData; } m_programs.add(program,new ProgramData()); } void GLSharedGroup::initProgramData(GLuint program, GLuint numIndexes) { android::AutoMutex _lock(m_lock); ProgramData *pData = m_programs.valueFor(program); if (pData) { pData->initProgramData(numIndexes); } } bool GLSharedGroup::isProgramInitialized(GLuint program) { android::AutoMutex _lock(m_lock); ProgramData* pData = m_programs.valueFor(program); if (pData) { return pData->isInitialized(); } return false; } void GLSharedGroup::deleteProgramData(GLuint program) { android::AutoMutex _lock(m_lock); ProgramData *pData = m_programs.valueFor(program); if (pData) delete pData; m_programs.removeItem(program); } void GLSharedGroup::attachShader(GLuint program, GLuint shader) { android::AutoMutex _lock(m_lock); ProgramData* programData = m_programs.valueFor(program); ssize_t idx = m_shaders.indexOfKey(shader); if (programData && idx >= 0) { if (programData->attachShader(shader)) { refShaderDataLocked(idx); } } } void GLSharedGroup::detachShader(GLuint program, GLuint shader) { android::AutoMutex _lock(m_lock); ProgramData* programData = m_programs.valueFor(program); ssize_t idx = m_shaders.indexOfKey(shader); if (programData && idx >= 0) { if (programData->detachShader(shader)) { unrefShaderDataLocked(idx); } } } void GLSharedGroup::setProgramIndexInfo(GLuint program, GLuint index, GLint base, GLint size, GLenum type, const char* name) { android::AutoMutex _lock(m_lock); ProgramData* pData = m_programs.valueFor(program); if (pData) { pData->setIndexInfo(index,base,size,type); if (type == GL_SAMPLER_2D) { size_t n = pData->getNumShaders(); for (size_t i = 0; i < n; i++) { GLuint shaderId = pData->getShader(i); ShaderData* shader = m_shaders.valueFor(shaderId); if (!shader) continue; ShaderData::StringList::iterator nameIter = shader->samplerExternalNames.begin(); ShaderData::StringList::iterator nameEnd = shader->samplerExternalNames.end(); while (nameIter != nameEnd) { if (*nameIter == name) { pData->setIndexFlags(index, ProgramData::INDEX_FLAG_SAMPLER_EXTERNAL); break; } ++nameIter; } } } } } GLenum GLSharedGroup::getProgramUniformType(GLuint program, GLint location) { android::AutoMutex _lock(m_lock); ProgramData* pData = m_programs.valueFor(program); GLenum type=0; if (pData) { type = pData->getTypeForLocation(location); } return type; } bool GLSharedGroup::isProgram(GLuint program) { android::AutoMutex _lock(m_lock); ProgramData* pData = m_programs.valueFor(program); return (pData!=NULL); } void GLSharedGroup::setupLocationShiftWAR(GLuint program) { android::AutoMutex _lock(m_lock); ProgramData* pData = m_programs.valueFor(program); if (pData) pData->setupLocationShiftWAR(); } GLint GLSharedGroup::locationWARHostToApp(GLuint program, GLint hostLoc, GLint arrIndex) { android::AutoMutex _lock(m_lock); ProgramData* pData = m_programs.valueFor(program); if (pData) return pData->locationWARHostToApp(hostLoc, arrIndex); else return hostLoc; } GLint GLSharedGroup::locationWARAppToHost(GLuint program, GLint appLoc) { android::AutoMutex _lock(m_lock); ProgramData* pData = m_programs.valueFor(program); if (pData) return pData->locationWARAppToHost(appLoc); else return appLoc; } bool GLSharedGroup::needUniformLocationWAR(GLuint program) { android::AutoMutex _lock(m_lock); ProgramData* pData = m_programs.valueFor(program); if (pData) return pData->needUniformLocationWAR(); return false; } GLint GLSharedGroup::getNextSamplerUniform(GLuint program, GLint index, GLint* val, GLenum* target) const { android::AutoMutex _lock(m_lock); ProgramData* pData = m_programs.valueFor(program); return pData ? pData->getNextSamplerUniform(index, val, target) : -1; } bool GLSharedGroup::setSamplerUniform(GLuint program, GLint appLoc, GLint val, GLenum* target) { android::AutoMutex _lock(m_lock); ProgramData* pData = m_programs.valueFor(program); return pData ? pData->setSamplerUniform(appLoc, val, target) : false; } bool GLSharedGroup::addShaderData(GLuint shader) { android::AutoMutex _lock(m_lock); ShaderData* data = new ShaderData; if (data) { if (m_shaders.add(shader, data) < 0) { delete data; data = NULL; } data->refcount = 1; } return data != NULL; } ShaderData* GLSharedGroup::getShaderData(GLuint shader) { android::AutoMutex _lock(m_lock); return m_shaders.valueFor(shader); } void GLSharedGroup::unrefShaderData(GLuint shader) { android::AutoMutex _lock(m_lock); ssize_t idx = m_shaders.indexOfKey(shader); if (idx >= 0) { unrefShaderDataLocked(idx); } } void GLSharedGroup::refShaderDataLocked(ssize_t shaderIdx) { assert(shaderIdx >= 0 && shaderIdx <= m_shaders.size()); ShaderData* data = m_shaders.valueAt(shaderIdx); data->refcount++; } void GLSharedGroup::unrefShaderDataLocked(ssize_t shaderIdx) { assert(shaderIdx >= 0 && shaderIdx <= m_shaders.size()); ShaderData* data = m_shaders.valueAt(shaderIdx); if (--data->refcount == 0) { delete data; m_shaders.removeItemsAt(shaderIdx); } } anbox-0.0~git20191115/android/opengl/shared/OpenglCodecCommon/GLSharedGroup.h000077500000000000000000000112621356361734700265560ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _GL_SHARED_GROUP_H_ #define _GL_SHARED_GROUP_H_ #define GL_API #ifndef ANDROID #define GL_APIENTRY #define GL_APIENTRYP #endif #include #include #include #include #include #include #include "ErrorLog.h" #include #include #include #include #include "FixedBuffer.h" #include "SmartPtr.h" struct BufferData { BufferData(); BufferData(GLsizeiptr size, void * data); GLsizeiptr m_size; FixedBuffer m_fixedBuffer; }; class ProgramData { private: typedef struct _IndexInfo { GLint base; GLint size; GLenum type; GLint appBase; GLint hostLocsPerElement; GLuint flags; GLint samplerValue; // only set for sampler uniforms } IndexInfo; GLuint m_numIndexes; IndexInfo* m_Indexes; bool m_initialized; bool m_locShiftWAR; android::Vector m_shaders; public: enum { INDEX_FLAG_SAMPLER_EXTERNAL = 0x00000001, }; ProgramData(); void initProgramData(GLuint numIndexes); bool isInitialized(); virtual ~ProgramData(); void setIndexInfo(GLuint index, GLint base, GLint size, GLenum type); void setIndexFlags(GLuint index, GLuint flags); GLuint getIndexForLocation(GLint location); GLenum getTypeForLocation(GLint location); bool needUniformLocationWAR() const { return m_locShiftWAR; } void setupLocationShiftWAR(); GLint locationWARHostToApp(GLint hostLoc, GLint arrIndex); GLint locationWARAppToHost(GLint appLoc); GLint getNextSamplerUniform(GLint index, GLint* val, GLenum* target); bool setSamplerUniform(GLint appLoc, GLint val, GLenum* target); bool attachShader(GLuint shader); bool detachShader(GLuint shader); size_t getNumShaders() const { return m_shaders.size(); } GLuint getShader(size_t i) const { return m_shaders[i]; } }; struct ShaderData { typedef android::List StringList; StringList samplerExternalNames; int refcount; }; class GLSharedGroup { private: android::DefaultKeyedVector m_buffers; android::DefaultKeyedVector m_programs; android::DefaultKeyedVector m_shaders; mutable android::Mutex m_lock; void refShaderDataLocked(ssize_t shaderIdx); void unrefShaderDataLocked(ssize_t shaderIdx); public: GLSharedGroup(); ~GLSharedGroup(); bool isObject(GLuint obj); BufferData * getBufferData(GLuint bufferId); void addBufferData(GLuint bufferId, GLsizeiptr size, void * data); void updateBufferData(GLuint bufferId, GLsizeiptr size, void * data); GLenum subUpdateBufferData(GLuint bufferId, GLintptr offset, GLsizeiptr size, void * data); void deleteBufferData(GLuint); bool isProgram(GLuint program); bool isProgramInitialized(GLuint program); void addProgramData(GLuint program); void initProgramData(GLuint program, GLuint numIndexes); void attachShader(GLuint program, GLuint shader); void detachShader(GLuint program, GLuint shader); void deleteProgramData(GLuint program); void setProgramIndexInfo(GLuint program, GLuint index, GLint base, GLint size, GLenum type, const char* name); GLenum getProgramUniformType(GLuint program, GLint location); void setupLocationShiftWAR(GLuint program); GLint locationWARHostToApp(GLuint program, GLint hostLoc, GLint arrIndex); GLint locationWARAppToHost(GLuint program, GLint appLoc); bool needUniformLocationWAR(GLuint program); GLint getNextSamplerUniform(GLuint program, GLint index, GLint* val, GLenum* target) const; bool setSamplerUniform(GLuint program, GLint appLoc, GLint val, GLenum* target); bool addShaderData(GLuint shader); // caller must hold a reference to the shader as long as it holds the pointer ShaderData* getShaderData(GLuint shader); void unrefShaderData(GLuint shader); }; typedef SmartPtr GLSharedGroupPtr; #endif //_GL_SHARED_GROUP_H_ anbox-0.0~git20191115/android/opengl/shared/OpenglCodecCommon/Makefile000066400000000000000000000003231356361734700253700ustar00rootroot00000000000000 ROOT=../.. include $(ROOT)/make/commondefs CXXFILES = TcpStream.cpp GLClientState.cpp glUtils.cpp CXXINCS += -I$(ROOT)/libs/GLESv1 -I$(ROOT)/include LIBRARY_NAME = libcodecCommon.a include $(COMMONRULES) anbox-0.0~git20191115/android/opengl/shared/OpenglCodecCommon/SmartPtr.h000066400000000000000000000075161356361734700256700ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __SMART_PTR_H #define __SMART_PTR_H #include #include template class SmartPtr { public: explicit SmartPtr(T* ptr = (T*)NULL) { if (threadSafe) { m_lock = new mutex_t; mutex_init(m_lock); } else m_lock = NULL; m_ptr = ptr; if (ptr) m_pRefCount = new int32_t(1); else m_pRefCount = NULL; } SmartPtr(const SmartPtr& rhs) { if (threadSafe) { m_lock = new mutex_t; mutex_init(m_lock); } else m_lock = NULL; m_pRefCount = rhs.m_pRefCount; m_ptr = rhs.m_ptr; use(); } SmartPtr(SmartPtr& rhs) { if (threadSafe) { m_lock = new mutex_t; mutex_init(m_lock); } else m_lock = NULL; if (rhs.m_lock) mutex_lock(rhs.m_lock); m_pRefCount = rhs.m_pRefCount; m_ptr = rhs.m_ptr; use(); if (rhs.m_lock) mutex_unlock(rhs.m_lock); } ~SmartPtr() { if (m_lock) mutex_lock(m_lock); release(); if (m_lock) { mutex_unlock(m_lock); mutex_destroy(m_lock); delete m_lock; } } T* Ptr() const { return m_ptr; } const T* constPtr() const { return m_ptr; } T* operator->() const { return m_ptr; } T& operator*() const { return *m_ptr; } operator void*() const { return (void *)m_ptr; } // This gives STL lists something to compare. bool operator <(const SmartPtr& t1) const { return m_ptr < t1.m_ptr; } SmartPtr& operator=(const SmartPtr& rhs) { if (m_ptr == rhs.m_ptr) return *this; if (m_lock) mutex_lock(m_lock); release(); m_pRefCount = rhs.m_pRefCount; m_ptr = rhs.m_ptr; use(); if (m_lock) mutex_unlock(m_lock); return *this; } SmartPtr& operator=(SmartPtr& rhs) { if (m_ptr == rhs.m_ptr) return *this; if (m_lock) mutex_lock(m_lock); release(); if (rhs.m_lock) mutex_lock(rhs.m_lock); m_pRefCount = rhs.m_pRefCount; m_ptr = rhs.m_ptr; use(); if (rhs.m_lock) mutex_unlock(rhs.m_lock); if (m_lock) mutex_unlock(m_lock); return *this; } private: int32_t *m_pRefCount; mutex_t *m_lock; T* m_ptr; // Increment the reference count on this pointer by 1. int use() { if (!m_pRefCount) return 0; return android_atomic_inc(m_pRefCount) + 1; } // Decrement the reference count on the pointer by 1. // If the reference count goes to (or below) 0, the pointer is deleted. int release() { if (!m_pRefCount) return 0; int iVal = android_atomic_dec(m_pRefCount); if (iVal > 1) return iVal - 1; delete m_pRefCount; m_pRefCount = NULL; if (m_ptr) { delete m_ptr; m_ptr = NULL; } return 0; } }; #endif // of __SMART_PTR_H anbox-0.0~git20191115/android/opengl/shared/OpenglCodecCommon/SocketStream.cpp000066400000000000000000000074451356361734700270540ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "SocketStream.h" #include #include #include #include #include #include #ifndef _WIN32 #include #include #include #else #include #endif SocketStream::SocketStream(size_t bufSize) : IOStream(bufSize), m_sock(-1), m_bufsize(bufSize), m_buf(NULL) { } SocketStream::SocketStream(int sock, size_t bufSize) : IOStream(bufSize), m_sock(sock), m_bufsize(bufSize), m_buf(NULL) { } SocketStream::~SocketStream() { if (m_sock >= 0) { #ifdef _WIN32 closesocket(m_sock); #else ::close(m_sock); #endif } if (m_buf != NULL) { free(m_buf); m_buf = NULL; } } void *SocketStream::allocBuffer(size_t minSize) { size_t allocSize = (m_bufsize < minSize ? minSize : m_bufsize); if (!m_buf) { m_buf = (unsigned char *)malloc(allocSize); } else if (m_bufsize < allocSize) { unsigned char *p = (unsigned char *)realloc(m_buf, allocSize); if (p != NULL) { m_buf = p; m_bufsize = allocSize; } else { ERR("%s: realloc (%zu) failed\n", __FUNCTION__, allocSize); free(m_buf); m_buf = NULL; m_bufsize = 0; } } return m_buf; }; int SocketStream::commitBuffer(size_t size) { return writeFully(m_buf, size); } int SocketStream::writeFully(const void* buffer, size_t size) { if (!valid()) return -1; size_t res = size; int retval = 0; while (res > 0) { ssize_t stat = ::send(m_sock, (const char *)buffer + (size - res), res, 0); if (stat < 0) { if (errno != EINTR) { retval = stat; ERR("%s: failed: %s\n", __FUNCTION__, strerror(errno)); break; } } else { res -= stat; } } return retval; } const unsigned char *SocketStream::readFully(void *buf, size_t len) { const unsigned char* ret = NULL; if (!valid()) return NULL; if (!buf) { return NULL; // do not allow NULL buf in that implementation } size_t res = len; while (res > 0) { ssize_t stat = ::recv(m_sock, (char *)(buf) + len - res, res, 0); if (stat > 0) { res -= stat; continue; } if (stat == 0 || errno != EINTR) { // client shutdown or error return NULL; } } return (const unsigned char *)buf; } const unsigned char *SocketStream::read( void *buf, size_t *inout_len) { if (!valid()) return NULL; if (!buf) { return NULL; // do not allow NULL buf in that implementation } int n; do { n = recv(buf, *inout_len); } while( n < 0 && errno == EINTR ); if (n > 0) { *inout_len = n; return (const unsigned char *)buf; } return NULL; } int SocketStream::recv(void *buf, size_t len) { if (!valid()) return int(ERR_INVALID_SOCKET); int res = 0; while(true) { res = ::recv(m_sock, (char *)buf, len, 0); if (res < 0) { if (errno == EINTR) { continue; } } break; } return res; } anbox-0.0~git20191115/android/opengl/shared/OpenglCodecCommon/SocketStream.h000066400000000000000000000030521356361734700265070ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __SOCKET_STREAM_H #define __SOCKET_STREAM_H #include #include "IOStream.h" class SocketStream : public IOStream { public: typedef enum { ERR_INVALID_SOCKET = -1000 } SocketStreamError; explicit SocketStream(size_t bufsize = 10000); virtual ~SocketStream(); virtual int listen(unsigned short port) = 0; virtual SocketStream *accept() = 0; virtual int connect(unsigned short port) = 0; virtual void *allocBuffer(size_t minSize); virtual int commitBuffer(size_t size); virtual const unsigned char *readFully(void *buf, size_t len); virtual const unsigned char *read(void *buf, size_t *inout_len); bool valid() { return m_sock >= 0; } virtual int recv(void *buf, size_t len); virtual int writeFully(const void *buf, size_t len); protected: int m_sock; size_t m_bufsize; unsigned char *m_buf; SocketStream(int sock, size_t bufSize); }; #endif /* __SOCKET_STREAM_H */ anbox-0.0~git20191115/android/opengl/shared/OpenglCodecCommon/TcpStream.cpp000066400000000000000000000042321356361734700263410ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "TcpStream.h" #include #include #include #include #include #include #ifndef _WIN32 #include #include #else #include #endif TcpStream::TcpStream(size_t bufSize) : SocketStream(bufSize) { } TcpStream::TcpStream(int sock, size_t bufSize) : SocketStream(sock, bufSize) { // disable Nagle algorithm to improve bandwidth of small // packets which are quite common in our implementation. #ifdef _WIN32 DWORD flag; #else int flag; #endif flag = 1; setsockopt( sock, IPPROTO_TCP, TCP_NODELAY, (const char*)&flag, sizeof(flag) ); } int TcpStream::listen(unsigned short port) { m_sock = socket_loopback_server(port, SOCK_STREAM); if (!valid()) return int(ERR_INVALID_SOCKET); return 0; } SocketStream * TcpStream::accept() { int clientSock = -1; while (true) { struct sockaddr_in addr; socklen_t len = sizeof(addr); clientSock = ::accept(m_sock, (sockaddr *)&addr, &len); if (clientSock < 0 && errno == EINTR) { continue; } break; } TcpStream *clientStream = NULL; if (clientSock >= 0) { clientStream = new TcpStream(clientSock, m_bufsize); } return clientStream; } int TcpStream::connect(unsigned short port) { return connect("127.0.0.1",port); } int TcpStream::connect(const char* hostname, unsigned short port) { m_sock = socket_network_client(hostname, port, SOCK_STREAM); if (!valid()) return -1; return 0; } anbox-0.0~git20191115/android/opengl/shared/OpenglCodecCommon/TcpStream.h000066400000000000000000000017731356361734700260150ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __TCP_STREAM_H #define __TCP_STREAM_H #include "SocketStream.h" class TcpStream : public SocketStream { public: explicit TcpStream(size_t bufsize = 10000); virtual int listen(unsigned short port); virtual SocketStream *accept(); virtual int connect(unsigned short port); int connect(const char* hostname, unsigned short port); private: TcpStream(int sock, size_t bufSize); }; #endif anbox-0.0~git20191115/android/opengl/shared/OpenglCodecCommon/codec_defs.h000066400000000000000000000013261356361734700261630ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _CODEC_DEFS_H #define _CODEC_DEFS_H #define CODEC_SERVER_PORT 22468 #define CODEC_MAX_VERTEX_ATTRIBUTES 64 #endif anbox-0.0~git20191115/android/opengl/shared/OpenglCodecCommon/glUtils.cpp000066400000000000000000000315071356361734700260670ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "glUtils.h" #include #include "ErrorLog.h" #include size_t glSizeof(GLenum type) { size_t retval = 0; switch(type) { case GL_BYTE: case GL_UNSIGNED_BYTE: retval = 1; break; case GL_SHORT: case GL_UNSIGNED_SHORT: case GL_HALF_FLOAT_OES: retval = 2; break; case GL_UNSIGNED_INT: case GL_INT: case GL_FLOAT: case GL_FIXED: case GL_BOOL: retval = 4; break; #ifdef GL_DOUBLE case GL_DOUBLE: retval = 8; break; #endif case GL_FLOAT_VEC2: case GL_INT_VEC2: case GL_BOOL_VEC2: retval = 8; break; case GL_INT_VEC3: case GL_BOOL_VEC3: case GL_FLOAT_VEC3: retval = 12; break; case GL_FLOAT_VEC4: case GL_BOOL_VEC4: case GL_INT_VEC4: case GL_FLOAT_MAT2: retval = 16; break; case GL_FLOAT_MAT3: retval = 36; break; case GL_FLOAT_MAT4: retval = 64; break; case GL_SAMPLER_2D: case GL_SAMPLER_CUBE: retval = 4; break; default: ERR("**** ERROR unknown type 0x%x (%s,%d)\n", type, __FUNCTION__,__LINE__); } return retval; } size_t glUtilsParamSize(GLenum param) { size_t s = 0; switch(param) { case GL_DEPTH_TEST: case GL_DEPTH_FUNC: case GL_DEPTH_BITS: case GL_MAX_CLIP_PLANES: case GL_GREEN_BITS: case GL_MAX_MODELVIEW_STACK_DEPTH: case GL_MAX_PROJECTION_STACK_DEPTH: case GL_MAX_TEXTURE_STACK_DEPTH: case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES: case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES: case GL_NUM_COMPRESSED_TEXTURE_FORMATS: case GL_MAX_TEXTURE_SIZE: case GL_TEXTURE_GEN_MODE_OES: case GL_TEXTURE_ENV_MODE: case GL_FOG_MODE: case GL_FOG_DENSITY: case GL_FOG_START: case GL_FOG_END: case GL_SPOT_EXPONENT: case GL_CONSTANT_ATTENUATION: case GL_LINEAR_ATTENUATION: case GL_QUADRATIC_ATTENUATION: case GL_SHININESS: case GL_LIGHT_MODEL_TWO_SIDE: case GL_POINT_SIZE: case GL_POINT_SIZE_MIN: case GL_POINT_SIZE_MAX: case GL_POINT_FADE_THRESHOLD_SIZE: case GL_CULL_FACE: case GL_CULL_FACE_MODE: case GL_FRONT_FACE: case GL_SHADE_MODEL: case GL_DEPTH_WRITEMASK: case GL_DEPTH_CLEAR_VALUE: case GL_STENCIL_FAIL: case GL_STENCIL_PASS_DEPTH_FAIL: case GL_STENCIL_PASS_DEPTH_PASS: case GL_STENCIL_REF: case GL_STENCIL_WRITEMASK: case GL_MATRIX_MODE: case GL_MODELVIEW_STACK_DEPTH: case GL_PROJECTION_STACK_DEPTH: case GL_TEXTURE_STACK_DEPTH: case GL_ALPHA_TEST_FUNC: case GL_ALPHA_TEST_REF: case GL_ALPHA_TEST: case GL_DITHER: case GL_BLEND_DST: case GL_BLEND_SRC: case GL_BLEND: case GL_LOGIC_OP_MODE: case GL_SCISSOR_TEST: case GL_MAX_TEXTURE_UNITS: case GL_ACTIVE_TEXTURE: case GL_ALPHA_BITS: case GL_ARRAY_BUFFER_BINDING: case GL_BLUE_BITS: case GL_CLIENT_ACTIVE_TEXTURE: case GL_CLIP_PLANE0: case GL_CLIP_PLANE1: case GL_CLIP_PLANE2: case GL_CLIP_PLANE3: case GL_CLIP_PLANE4: case GL_CLIP_PLANE5: case GL_COLOR_ARRAY: case GL_COLOR_ARRAY_BUFFER_BINDING: case GL_COLOR_ARRAY_SIZE: case GL_COLOR_ARRAY_STRIDE: case GL_COLOR_ARRAY_TYPE: case GL_COLOR_LOGIC_OP: case GL_COLOR_MATERIAL: case GL_PACK_ALIGNMENT: case GL_PERSPECTIVE_CORRECTION_HINT: case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES: case GL_POINT_SIZE_ARRAY_STRIDE_OES: case GL_POINT_SIZE_ARRAY_TYPE_OES: case GL_POINT_SMOOTH: case GL_POINT_SMOOTH_HINT: case GL_POINT_SPRITE_OES: case GL_COORD_REPLACE_OES: case GL_COMBINE_ALPHA: case GL_SRC0_RGB: case GL_SRC1_RGB: case GL_SRC2_RGB: case GL_OPERAND0_RGB: case GL_OPERAND1_RGB: case GL_OPERAND2_RGB: case GL_SRC0_ALPHA: case GL_SRC1_ALPHA: case GL_SRC2_ALPHA: case GL_OPERAND0_ALPHA: case GL_OPERAND1_ALPHA: case GL_OPERAND2_ALPHA: case GL_RGB_SCALE: case GL_ALPHA_SCALE: case GL_COMBINE_RGB: case GL_POLYGON_OFFSET_FACTOR: case GL_POLYGON_OFFSET_FILL: case GL_POLYGON_OFFSET_UNITS: case GL_RED_BITS: case GL_RESCALE_NORMAL: case GL_SAMPLE_ALPHA_TO_COVERAGE: case GL_SAMPLE_ALPHA_TO_ONE: case GL_SAMPLE_BUFFERS: case GL_SAMPLE_COVERAGE: case GL_SAMPLE_COVERAGE_INVERT: case GL_SAMPLE_COVERAGE_VALUE: case GL_SAMPLES: case GL_MAX_SAMPLES_EXT: case GL_STENCIL_BITS: case GL_STENCIL_CLEAR_VALUE: case GL_STENCIL_FUNC: case GL_STENCIL_TEST: case GL_STENCIL_VALUE_MASK: case GL_STENCIL_BACK_FUNC: case GL_STENCIL_BACK_VALUE_MASK: case GL_STENCIL_BACK_REF: case GL_STENCIL_BACK_FAIL: case GL_STENCIL_BACK_PASS_DEPTH_FAIL: case GL_STENCIL_BACK_PASS_DEPTH_PASS: case GL_STENCIL_BACK_WRITEMASK: case GL_TEXTURE_2D: case GL_TEXTURE_BINDING_2D: case GL_TEXTURE_BINDING_CUBE_MAP: case GL_TEXTURE_BINDING_EXTERNAL_OES: case GL_TEXTURE_COORD_ARRAY: case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING: case GL_TEXTURE_COORD_ARRAY_SIZE: case GL_TEXTURE_COORD_ARRAY_STRIDE: case GL_TEXTURE_COORD_ARRAY_TYPE: case GL_UNPACK_ALIGNMENT: case GL_VERTEX_ARRAY: case GL_VERTEX_ARRAY_BUFFER_BINDING: case GL_VERTEX_ARRAY_SIZE: case GL_VERTEX_ARRAY_STRIDE: case GL_VERTEX_ARRAY_TYPE: case GL_SPOT_CUTOFF: case GL_TEXTURE_MIN_FILTER: case GL_TEXTURE_MAG_FILTER: case GL_TEXTURE_WRAP_S: case GL_TEXTURE_WRAP_T: case GL_GENERATE_MIPMAP: case GL_GENERATE_MIPMAP_HINT: case GL_RENDERBUFFER_WIDTH_OES: case GL_RENDERBUFFER_HEIGHT_OES: case GL_RENDERBUFFER_INTERNAL_FORMAT_OES: case GL_RENDERBUFFER_RED_SIZE_OES: case GL_RENDERBUFFER_GREEN_SIZE_OES: case GL_RENDERBUFFER_BLUE_SIZE_OES: case GL_RENDERBUFFER_ALPHA_SIZE_OES: case GL_RENDERBUFFER_DEPTH_SIZE_OES: case GL_RENDERBUFFER_STENCIL_SIZE_OES: case GL_RENDERBUFFER_BINDING: case GL_FRAMEBUFFER_BINDING: case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES: case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES: case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES: case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES: case GL_FENCE_STATUS_NV: case GL_FENCE_CONDITION_NV: case GL_TEXTURE_WIDTH_QCOM: case GL_TEXTURE_HEIGHT_QCOM: case GL_TEXTURE_DEPTH_QCOM: case GL_TEXTURE_INTERNAL_FORMAT_QCOM: case GL_TEXTURE_FORMAT_QCOM: case GL_TEXTURE_TYPE_QCOM: case GL_TEXTURE_IMAGE_VALID_QCOM: case GL_TEXTURE_NUM_LEVELS_QCOM: case GL_TEXTURE_TARGET_QCOM: case GL_TEXTURE_OBJECT_VALID_QCOM: case GL_BLEND_EQUATION_RGB_OES: case GL_BLEND_EQUATION_ALPHA_OES: case GL_BLEND_DST_RGB_OES: case GL_BLEND_SRC_RGB_OES: case GL_BLEND_DST_ALPHA_OES: case GL_BLEND_SRC_ALPHA_OES: case GL_MAX_LIGHTS: case GL_SHADER_TYPE: case GL_DELETE_STATUS: case GL_COMPILE_STATUS: case GL_INFO_LOG_LENGTH: case GL_SHADER_SOURCE_LENGTH: case GL_CURRENT_PROGRAM: case GL_LINK_STATUS: case GL_VALIDATE_STATUS: case GL_ATTACHED_SHADERS: case GL_ACTIVE_UNIFORMS: case GL_ACTIVE_ATTRIBUTES: case GL_SUBPIXEL_BITS: case GL_MAX_CUBE_MAP_TEXTURE_SIZE: case GL_NUM_SHADER_BINARY_FORMATS: case GL_SHADER_COMPILER: case GL_MAX_VERTEX_ATTRIBS: case GL_MAX_VERTEX_UNIFORM_VECTORS: case GL_MAX_VARYING_VECTORS: case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS: case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS: case GL_MAX_FRAGMENT_UNIFORM_VECTORS: case GL_MAX_RENDERBUFFER_SIZE: case GL_MAX_TEXTURE_IMAGE_UNITS: case GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES: case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES: case GL_LINE_WIDTH: s = 1; break; case GL_ALIASED_LINE_WIDTH_RANGE: case GL_ALIASED_POINT_SIZE_RANGE: case GL_DEPTH_RANGE: case GL_MAX_VIEWPORT_DIMS: case GL_SMOOTH_POINT_SIZE_RANGE: case GL_SMOOTH_LINE_WIDTH_RANGE: s= 2; break; case GL_SPOT_DIRECTION: case GL_POINT_DISTANCE_ATTENUATION: case GL_CURRENT_NORMAL: s = 3; break; case GL_CURRENT_VERTEX_ATTRIB: case GL_CURRENT_TEXTURE_COORDS: case GL_CURRENT_COLOR: case GL_FOG_COLOR: case GL_AMBIENT: case GL_DIFFUSE: case GL_SPECULAR: case GL_EMISSION: case GL_POSITION: case GL_LIGHT_MODEL_AMBIENT: case GL_TEXTURE_ENV_COLOR: case GL_SCISSOR_BOX: case GL_VIEWPORT: case GL_TEXTURE_CROP_RECT_OES: case GL_COLOR_CLEAR_VALUE: case GL_COLOR_WRITEMASK: case GL_AMBIENT_AND_DIFFUSE: case GL_BLEND_COLOR: s = 4; break; case GL_MODELVIEW_MATRIX: case GL_PROJECTION_MATRIX: case GL_TEXTURE_MATRIX: s = 16; break; default: ERR("glUtilsParamSize: unknow param 0x%08x\n", param); s = 1; // assume 1 } return s; } void glUtilsPackPointerData(unsigned char *dst, unsigned char *src, int size, GLenum type, unsigned int stride, unsigned int datalen) { unsigned int vsize = size * glSizeof(type); if (stride == 0) stride = vsize; if (stride == vsize) { memcpy(dst, src, datalen); } else { for (unsigned int i = 0; i < datalen; i += vsize) { memcpy(dst, src, vsize); dst += vsize; src += stride; } } } void glUtilsWritePackPointerData(void* _stream, unsigned char *src, int size, GLenum type, unsigned int stride, unsigned int datalen) { IOStream* stream = reinterpret_cast(_stream); unsigned int vsize = size * glSizeof(type); if (stride == 0) stride = vsize; if (stride == vsize) { stream->writeFully(src, datalen); } else { for (unsigned int i = 0; i < datalen; i += vsize) { stream->writeFully(src, (size_t)vsize); src += stride; } } } int glUtilsPixelBitSize(GLenum format, GLenum type) { int components = 0; int componentsize = 0; int pixelsize = 0; switch(type) { case GL_BYTE: case GL_UNSIGNED_BYTE: componentsize = 8; break; case GL_SHORT: case GL_UNSIGNED_SHORT: case GL_UNSIGNED_SHORT_5_6_5: case GL_UNSIGNED_SHORT_4_4_4_4: case GL_UNSIGNED_SHORT_5_5_5_1: case GL_RGB565_OES: case GL_RGB5_A1_OES: case GL_RGBA4_OES: pixelsize = 16; break; case GL_INT: case GL_UNSIGNED_INT: case GL_FLOAT: case GL_FIXED: case GL_UNSIGNED_INT_24_8_OES: pixelsize = 32; break; default: ERR("glUtilsPixelBitSize: unknown pixel type - assuming pixel data 0\n"); componentsize = 0; } if (pixelsize == 0) { switch(format) { #if 0 case GL_RED: case GL_GREEN: case GL_BLUE: #endif case GL_ALPHA: case GL_LUMINANCE: case GL_DEPTH_COMPONENT: case GL_DEPTH_STENCIL_OES: components = 1; break; case GL_LUMINANCE_ALPHA: components = 2; break; case GL_RGB: #if 0 case GL_BGR: #endif components = 3; break; case GL_RGBA: case GL_BGRA_EXT: components = 4; break; default: ERR("glUtilsPixelBitSize: unknown pixel format...\n"); components = 0; } pixelsize = components * componentsize; } return pixelsize; } // pack a list of strings into one. void glUtilsPackStrings(char *ptr, char **strings, GLint *length, GLsizei count) { char *p = ptr; *p = '\0'; for (int i = 0; i < count; i++) { int l=0; if (strings[i]!=NULL) { if (length == NULL || length[i] < 0) { l = strlen(strings[i]); strcat(p, strings[i]); } else { l = length[i]; strncat(p, strings[i], l); } } p += l; } } // claculate the length of a list of strings int glUtilsCalcShaderSourceLen( char **strings, GLint *length, GLsizei count) { int len = 0; for (int i = 0; i < count; i++) { int l; if (length == NULL || length[i] < 0) { l = strings[i]!=NULL ? strlen(strings[i]) : 0; } else { l = length[i]; } len += l; } return len; } anbox-0.0~git20191115/android/opengl/shared/OpenglCodecCommon/glUtils.h000066400000000000000000000050461356361734700255330ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __GL_UTILS_H__ #define __GL_UTILS_H__ #include #include #ifdef GL_API #undef GL_API #endif #define GL_API #ifdef GL_APIENTRY #undef GL_APIENTRY #endif #ifdef GL_APIENTRYP #undef GL_APIENTRYP #endif #define GL_APIENTRYP #ifndef ANDROID #define GL_APIENTRY #endif #include #include #include #include #ifdef __cplusplus extern "C" { #endif size_t glSizeof(GLenum type); size_t glUtilsParamSize(GLenum param); void glUtilsPackPointerData(unsigned char *dst, unsigned char *str, int size, GLenum type, unsigned int stride, unsigned int datalen); void glUtilsWritePackPointerData(void* stream, unsigned char *src, int size, GLenum type, unsigned int stride, unsigned int datalen); int glUtilsPixelBitSize(GLenum format, GLenum type); void glUtilsPackStrings(char *ptr, char **strings, GLint *length, GLsizei count); int glUtilsCalcShaderSourceLen(char **strings, GLint *length, GLsizei count); #ifdef __cplusplus }; #endif namespace GLUtils { template void minmax(T *indices, int count, int *min, int *max) { *min = -1; *max = -1; T *ptr = indices; for (int i = 0; i < count; i++) { if (*min == -1 || *ptr < *min) *min = *ptr; if (*max == -1 || *ptr > *max) *max = *ptr; ptr++; } } template void shiftIndices(T *indices, int count, int offset) { T *ptr = indices; for (int i = 0; i < count; i++) { *ptr += offset; ptr++; } } template void shiftIndices(T *src, T *dst, int count, int offset) { for (int i = 0; i < count; i++) { *dst = *src + offset; dst++; src++; } } }; // namespace GLUtils #endif anbox-0.0~git20191115/android/opengl/shared/OpenglCodecCommon/gl_base_types.h000066400000000000000000000037071356361734700267320ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __GL_BASE_TYPES__H #define __GL_BASE_TYPES__H #include #ifndef gl_APIENTRY #define gl_APIENTRY KHRONOS_APIENTRY #endif #ifndef gl2_APIENTRY #define gl2_APIENTRY KHRONOS_APIENTRY #endif typedef void GLvoid; typedef unsigned int GLenum; typedef unsigned char GLboolean; typedef unsigned int GLbitfield; typedef char GLchar; typedef khronos_int8_t GLbyte; typedef short GLshort; typedef int GLint; typedef int GLsizei; typedef khronos_uint8_t GLubyte; typedef unsigned short GLushort; typedef unsigned int GLuint; typedef khronos_float_t GLfloat; typedef khronos_float_t GLclampf; typedef khronos_int32_t GLfixed; typedef khronos_int32_t GLclampx; typedef khronos_intptr_t GLintptr; typedef khronos_ssize_t GLsizeiptr; typedef char *GLstr; /* JR XXX Treating this as an in handle - is this correct? */ typedef void * GLeglImageOES; /* ErrorCode */ #ifndef GL_INVALID_ENUM #define GL_NO_ERROR 0 #define GL_INVALID_ENUM 0x0500 #define GL_INVALID_VALUE 0x0501 #define GL_INVALID_OPERATION 0x0502 #define GL_STACK_OVERFLOW 0x0503 #define GL_STACK_UNDERFLOW 0x0504 #define GL_OUT_OF_MEMORY 0x0505 #define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 #endif #endif anbox-0.0~git20191115/android/opengl/system/000077500000000000000000000000001356361734700204555ustar00rootroot00000000000000anbox-0.0~git20191115/android/opengl/system/GLESv1/000077500000000000000000000000001356361734700214565ustar00rootroot00000000000000anbox-0.0~git20191115/android/opengl/system/GLESv1/Android.mk000066400000000000000000000006101356361734700233640ustar00rootroot00000000000000LOCAL_PATH := $(call my-dir) ### GLESv1 implementation ########################################### $(call emugl-begin-shared-library,libGLESv1_CM_emulation) $(call emugl-import,libOpenglSystemCommon libGLESv1_enc lib_renderControl_enc) LOCAL_CFLAGS += -DLOG_TAG=\"GLES_emulation\" -DGL_GLEXT_PROTOTYPES LOCAL_SRC_FILES := gl.cpp LOCAL_MODULE_RELATIVE_PATH := egl $(call emugl-end-module) anbox-0.0~git20191115/android/opengl/system/GLESv1/gl.cpp000066400000000000000000000110101356361734700225550ustar00rootroot00000000000000/* * Copyright 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "EGLClientIface.h" #include "HostConnection.h" #include "GLEncoder.h" #include "GLES/gl.h" #include "GLES/glext.h" #include "ErrorLog.h" #include "gralloc_cb.h" #include "ThreadInfo.h" #include "EGLImage.h" //XXX: fix this macro to get the context from fast tls path #define GET_CONTEXT GLEncoder * ctx = getEGLThreadInfo()->hostConn->glEncoder(); #include "gl_entry.cpp" //The functions table #include "gl_ftable.h" static EGLClient_eglInterface * s_egl = NULL; static EGLClient_glesInterface * s_gl = NULL; #define DEFINE_AND_VALIDATE_HOST_CONNECTION(ret) \ HostConnection *hostCon = HostConnection::get(); \ if (!hostCon) { \ ALOGE("egl: Failed to get host connection\n"); \ return ret; \ } \ renderControl_encoder_context_t *rcEnc = hostCon->rcEncoder(); \ if (!rcEnc) { \ ALOGE("egl: Failed to get renderControl encoder context\n"); \ return ret; \ } //GL extensions void glEGLImageTargetTexture2DOES(void * self, GLenum target, GLeglImageOES img) { (void)self; DBG("glEGLImageTargetTexture2DOES v1 target=%#x img=%p", target, img); EGLImage_t *image = (EGLImage_t*)img; if (image->target == EGL_NATIVE_BUFFER_ANDROID) { //TODO: check error - we don't have a way to set gl error android_native_buffer_t* native_buffer = image->native_buffer; if (native_buffer->common.magic != ANDROID_NATIVE_BUFFER_MAGIC) { return; } if (native_buffer->common.version != sizeof(android_native_buffer_t)) { return; } GET_CONTEXT; DEFINE_AND_VALIDATE_HOST_CONNECTION(); ctx->override2DTextureTarget(target); rcEnc->rcBindTexture(rcEnc, ((cb_handle_t *)(native_buffer->handle))->hostHandle); ctx->restore2DTextureTarget(); } else if (image->target == EGL_GL_TEXTURE_2D_KHR) { GET_CONTEXT; ctx->override2DTextureTarget(target); GLeglImageOES hostImage = reinterpret_cast((intptr_t)image->host_egl_image); ctx->m_glEGLImageTargetTexture2DOES_enc(self, target, hostImage); ctx->restore2DTextureTarget(); } } void glEGLImageTargetRenderbufferStorageOES(void *self, GLenum target, GLeglImageOES image) { (void)self; (void)target; DBG("glEGLImageTargetRenderbufferStorageOES v1 target=%#x image=%p", target, image); //TODO: check error - we don't have a way to set gl error android_native_buffer_t* native_buffer = (android_native_buffer_t*)image; if (native_buffer->common.magic != ANDROID_NATIVE_BUFFER_MAGIC) { return; } if (native_buffer->common.version != sizeof(android_native_buffer_t)) { return; } DEFINE_AND_VALIDATE_HOST_CONNECTION(); rcEnc->rcBindRenderbuffer(rcEnc, ((cb_handle_t *)(native_buffer->handle))->hostHandle); return; } void * getProcAddress(const char * procname) { // search in GL function table for (int i=0; igetGLString(name); } return NULL; } void init() { GET_CONTEXT; ctx->m_glEGLImageTargetTexture2DOES_enc = ctx->glEGLImageTargetTexture2DOES; ctx->glEGLImageTargetTexture2DOES = &glEGLImageTargetTexture2DOES; ctx->glEGLImageTargetRenderbufferStorageOES = &glEGLImageTargetRenderbufferStorageOES; ctx->glGetString = &my_glGetString; } extern "C" { EGLClient_glesInterface * init_emul_gles(EGLClient_eglInterface *eglIface) { s_egl = eglIface; if (!s_gl) { s_gl = new EGLClient_glesInterface(); s_gl->getProcAddress = getProcAddress; s_gl->finish = finish; s_gl->init = init; } return s_gl; } } //extern anbox-0.0~git20191115/android/opengl/system/GLESv1_enc/000077500000000000000000000000001356361734700223035ustar00rootroot00000000000000anbox-0.0~git20191115/android/opengl/system/GLESv1_enc/Android.mk000066400000000000000000000007721356361734700242220ustar00rootroot00000000000000LOCAL_PATH := $(call my-dir) ### GLESv1_enc Encoder ########################################### $(call emugl-begin-shared-library,libGLESv1_enc) LOCAL_CFLAGS += -DLOG_TAG=\"emuglGLESv1_enc\" LOCAL_SRC_FILES := \ GLEncoder.cpp \ GLEncoderUtils.cpp \ gl_client_context.cpp \ gl_enc.cpp \ gl_entry.cpp $(call emugl-import,libOpenglCodecCommon) $(call emugl-export,C_INCLUDES,$(LOCAL_PATH)) $(call emugl-export,C_INCLUDES,$(intermediates)) $(call emugl-end-module) anbox-0.0~git20191115/android/opengl/system/GLESv1_enc/GLEncoder.cpp000066400000000000000000001072001356361734700246110ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "GLEncoder.h" #include "glUtils.h" #include "FixedBuffer.h" #include #include #ifndef MIN #define MIN(a, b) ((a) < (b) ? (a) : (b)) #endif static GLubyte *gVendorString= (GLubyte *) "Android"; static GLubyte *gRendererString= (GLubyte *) "Android HW-GLES 1.0"; static GLubyte *gVersionString= (GLubyte *) "OpenGL ES-CM 1.0"; static GLubyte *gExtensionsString= (GLubyte *) "GL_OES_EGL_image_external "; #define SET_ERROR_IF(condition,err) if((condition)) { \ ALOGE("%s:%s:%d GL error 0x%x\n", __FILE__, __FUNCTION__, __LINE__, err); \ ctx->setError(err); \ return; \ } #define RET_AND_SET_ERROR_IF(condition,err,ret) if((condition)) { \ ALOGE("%s:%s:%d GL error 0x%x\n", __FILE__, __FUNCTION__, __LINE__, err); \ ctx->setError(err); \ return ret; \ } GLenum GLEncoder::s_glGetError(void * self) { GLEncoder *ctx = (GLEncoder *)self; GLenum err = ctx->getError(); if(err != GL_NO_ERROR) { ctx->setError(GL_NO_ERROR); return err; } return ctx->m_glGetError_enc(self); } GLint * GLEncoder::getCompressedTextureFormats() { if (m_compressedTextureFormats == NULL) { this->glGetIntegerv(this, GL_NUM_COMPRESSED_TEXTURE_FORMATS, &m_num_compressedTextureFormats); if (m_num_compressedTextureFormats > 0) { // get number of texture formats; m_compressedTextureFormats = new GLint[m_num_compressedTextureFormats]; this->glGetCompressedTextureFormats(this, m_num_compressedTextureFormats, m_compressedTextureFormats); } } return m_compressedTextureFormats; } void GLEncoder::s_glGetIntegerv(void *self, GLenum param, GLint *ptr) { GLEncoder *ctx = (GLEncoder *)self; assert(ctx->m_state != NULL); GLClientState* state = ctx->m_state; switch (param) { case GL_COMPRESSED_TEXTURE_FORMATS: { GLint * compressedTextureFormats = ctx->getCompressedTextureFormats(); if (ctx->m_num_compressedTextureFormats > 0 && compressedTextureFormats != NULL) { memcpy(ptr, compressedTextureFormats, ctx->m_num_compressedTextureFormats * sizeof(GLint)); } break; } case GL_MAX_TEXTURE_UNITS: ctx->m_glGetIntegerv_enc(self, param, ptr); *ptr = MIN(*ptr, GLClientState::MAX_TEXTURE_UNITS); break; case GL_TEXTURE_BINDING_2D: *ptr = state->getBoundTexture(GL_TEXTURE_2D); break; case GL_TEXTURE_BINDING_EXTERNAL_OES: *ptr = state->getBoundTexture(GL_TEXTURE_EXTERNAL_OES); break; default: if (!state->getClientStateParameter(param,ptr)) { ctx->m_glGetIntegerv_enc(self, param, ptr); } break; } } void GLEncoder::s_glGetFloatv(void *self, GLenum param, GLfloat *ptr) { GLEncoder *ctx = (GLEncoder *)self; assert(ctx->m_state != NULL); GLClientState* state = ctx->m_state; switch (param) { case GL_COMPRESSED_TEXTURE_FORMATS: { GLint * compressedTextureFormats = ctx->getCompressedTextureFormats(); if (ctx->m_num_compressedTextureFormats > 0 && compressedTextureFormats != NULL) { for (int i = 0; i < ctx->m_num_compressedTextureFormats; i++) { ptr[i] = (GLfloat) compressedTextureFormats[i]; } } break; } case GL_MAX_TEXTURE_UNITS: ctx->m_glGetFloatv_enc(self, param, ptr); *ptr = MIN(*ptr, (GLfloat)GLClientState::MAX_TEXTURE_UNITS); break; case GL_TEXTURE_BINDING_2D: *ptr = (GLfloat)state->getBoundTexture(GL_TEXTURE_2D); break; case GL_TEXTURE_BINDING_EXTERNAL_OES: *ptr = (GLfloat)state->getBoundTexture(GL_TEXTURE_EXTERNAL_OES); break; default: if (!state->getClientStateParameter(param,ptr)) { ctx->m_glGetFloatv_enc(self, param, ptr); } break; } } void GLEncoder::s_glGetFixedv(void *self, GLenum param, GLfixed *ptr) { GLEncoder *ctx = (GLEncoder *)self; assert(ctx->m_state != NULL); GLClientState* state = ctx->m_state; switch (param) { case GL_COMPRESSED_TEXTURE_FORMATS: { GLint * compressedTextureFormats = ctx->getCompressedTextureFormats(); if (ctx->m_num_compressedTextureFormats > 0 && compressedTextureFormats != NULL) { for (int i = 0; i < ctx->m_num_compressedTextureFormats; i++) { ptr[i] = compressedTextureFormats[i] << 16; } } break; } case GL_MAX_TEXTURE_UNITS: ctx->m_glGetFixedv_enc(self, param, ptr); *ptr = MIN(*ptr, GLClientState::MAX_TEXTURE_UNITS << 16); break; case GL_TEXTURE_BINDING_2D: *ptr = state->getBoundTexture(GL_TEXTURE_2D) << 16; break; case GL_TEXTURE_BINDING_EXTERNAL_OES: *ptr = state->getBoundTexture(GL_TEXTURE_EXTERNAL_OES) << 16; break; default: if (!state->getClientStateParameter(param,ptr)) { ctx->m_glGetFixedv_enc(self, param, ptr); } break; } } void GLEncoder::s_glGetBooleanv(void *self, GLenum param, GLboolean *ptr) { GLEncoder *ctx = (GLEncoder *)self; assert(ctx->m_state != NULL); GLClientState* state = ctx->m_state; switch (param) { case GL_COMPRESSED_TEXTURE_FORMATS: { GLint* compressedTextureFormats = ctx->getCompressedTextureFormats(); if (ctx->m_num_compressedTextureFormats > 0 && compressedTextureFormats != NULL) { for (int i = 0; i < ctx->m_num_compressedTextureFormats; i++) { ptr[i] = compressedTextureFormats[i] != 0 ? GL_TRUE : GL_FALSE; } } break; } case GL_TEXTURE_BINDING_2D: *ptr = state->getBoundTexture(GL_TEXTURE_2D) != 0 ? GL_TRUE : GL_FALSE; break; case GL_TEXTURE_BINDING_EXTERNAL_OES: *ptr = state->getBoundTexture(GL_TEXTURE_EXTERNAL_OES) != 0 ? GL_TRUE : GL_FALSE; break; default: if (!state->getClientStateParameter(param,ptr)) { ctx->m_glGetBooleanv_enc(self, param, ptr); } break; } } void GLEncoder::s_glGetPointerv(void * self, GLenum param, GLvoid **params) { GLEncoder * ctx = (GLEncoder *) self; assert(ctx->m_state != NULL); ctx->m_state->getClientStatePointer(param,params); } void GLEncoder::s_glFlush(void *self) { GLEncoder *ctx = (GLEncoder *)self; ctx->m_glFlush_enc(self); ctx->m_stream->flush(); } const GLubyte *GLEncoder::s_glGetString(void *self, GLenum name) { (void)self; GLubyte *retval = (GLubyte *) ""; switch(name) { case GL_VENDOR: retval = gVendorString; break; case GL_RENDERER: retval = gRendererString; break; case GL_VERSION: retval = gVersionString; break; case GL_EXTENSIONS: retval = gExtensionsString; break; } return retval; } void GLEncoder::s_glPixelStorei(void *self, GLenum param, GLint value) { GLEncoder *ctx = (GLEncoder *)self; ctx->m_glPixelStorei_enc(ctx, param, value); ALOG_ASSERT(ctx->m_state, "GLEncoder::s_glPixelStorei"); ctx->m_state->setPixelStore(param, value); } void GLEncoder::s_glVertexPointer(void *self, int size, GLenum type, GLsizei stride, const void *data) { GLEncoder *ctx = (GLEncoder *)self; assert(ctx->m_state != NULL); ctx->m_state->setState(GLClientState::VERTEX_LOCATION, size, type, false, stride, data); } void GLEncoder::s_glNormalPointer(void *self, GLenum type, GLsizei stride, const void *data) { GLEncoder *ctx = (GLEncoder *)self; assert(ctx->m_state != NULL); ctx->m_state->setState(GLClientState::NORMAL_LOCATION, 3, type, false, stride, data); } void GLEncoder::s_glColorPointer(void *self, int size, GLenum type, GLsizei stride, const void *data) { GLEncoder *ctx = (GLEncoder *)self; assert(ctx->m_state != NULL); ctx->m_state->setState(GLClientState::COLOR_LOCATION, size, type, false, stride, data); } void GLEncoder::s_glPointSizePointerOES(void *self, GLenum type, GLsizei stride, const void *data) { GLEncoder *ctx = (GLEncoder *)self; assert(ctx->m_state != NULL); ctx->m_state->setState(GLClientState::POINTSIZE_LOCATION, 1, type, false, stride, data); } void GLEncoder::s_glClientActiveTexture(void *self, GLenum texture) { GLEncoder *ctx = (GLEncoder *)self; assert(ctx->m_state != NULL); ctx->m_state->setActiveTexture(texture - GL_TEXTURE0); } void GLEncoder::s_glTexCoordPointer(void *self, int size, GLenum type, GLsizei stride, const void *data) { GLEncoder *ctx = (GLEncoder *)self; assert(ctx->m_state != NULL); int loc = ctx->m_state->getLocation(GL_TEXTURE_COORD_ARRAY); ctx->m_state->setState(loc, size, type, false, stride, data); } void GLEncoder::s_glMatrixIndexPointerOES(void *self, int size, GLenum type, GLsizei stride, const void * data) { GLEncoder *ctx = (GLEncoder *)self; assert(ctx->m_state != NULL); int loc = ctx->m_state->getLocation(GL_MATRIX_INDEX_ARRAY_OES); ctx->m_state->setState(loc, size, type, false, stride, data); } void GLEncoder::s_glWeightPointerOES(void * self, int size, GLenum type, GLsizei stride, const void * data) { GLEncoder *ctx = (GLEncoder *)self; assert(ctx->m_state != NULL); int loc = ctx->m_state->getLocation(GL_WEIGHT_ARRAY_OES); ctx->m_state->setState(loc, size, type, false, stride, data); } void GLEncoder::s_glEnableClientState(void *self, GLenum state) { GLEncoder *ctx = (GLEncoder *) self; assert(ctx->m_state != NULL); int loc = ctx->m_state->getLocation(state); ctx->m_state->enable(loc, 1); } void GLEncoder::s_glDisableClientState(void *self, GLenum state) { GLEncoder *ctx = (GLEncoder *) self; assert(ctx->m_state != NULL); int loc = ctx->m_state->getLocation(state); ctx->m_state->enable(loc, 0); } GLboolean GLEncoder::s_glIsEnabled(void *self, GLenum cap) { GLEncoder *ctx = (GLEncoder *) self; assert(ctx->m_state != NULL); int loc = ctx->m_state->getLocation(cap); const GLClientState::VertexAttribState *state = ctx->m_state->getState(loc); if (state!=NULL) return state->enabled; return ctx->m_glIsEnabled_enc(self,cap); } void GLEncoder::s_glBindBuffer(void *self, GLenum target, GLuint id) { GLEncoder *ctx = (GLEncoder *) self; assert(ctx->m_state != NULL); ctx->m_state->bindBuffer(target, id); // TODO set error state if needed; ctx->m_glBindBuffer_enc(self, target, id); } void GLEncoder::s_glBufferData(void * self, GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage) { GLEncoder *ctx = (GLEncoder *) self; GLuint bufferId = ctx->m_state->getBuffer(target); SET_ERROR_IF(bufferId==0, GL_INVALID_OPERATION); SET_ERROR_IF(size<0, GL_INVALID_VALUE); ctx->m_shared->updateBufferData(bufferId, size, (void*)data); ctx->m_glBufferData_enc(self, target, size, data, usage); } void GLEncoder::s_glBufferSubData(void * self, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data) { GLEncoder *ctx = (GLEncoder *) self; GLuint bufferId = ctx->m_state->getBuffer(target); SET_ERROR_IF(bufferId==0, GL_INVALID_OPERATION); GLenum res = ctx->m_shared->subUpdateBufferData(bufferId, offset, size, (void*)data); SET_ERROR_IF(res, res); ctx->m_glBufferSubData_enc(self, target, offset, size, data); } void GLEncoder::s_glDeleteBuffers(void * self, GLsizei n, const GLuint * buffers) { GLEncoder *ctx = (GLEncoder *) self; SET_ERROR_IF(n<0, GL_INVALID_VALUE); for (int i=0; im_shared->deleteBufferData(buffers[i]); ctx->m_glDeleteBuffers_enc(self,1,&buffers[i]); } } void GLEncoder::sendVertexData(unsigned int first, unsigned int count) { assert(m_state != NULL); for (int i = 0; i < GLClientState::LAST_LOCATION; i++) { bool enableDirty; const GLClientState::VertexAttribState *state = m_state->getStateAndEnableDirty(i, &enableDirty); // do not process if state not valid if (!state) continue; // do not send disable state if state was already disabled if (!enableDirty && !state->enabled) continue; if ( i >= GLClientState::TEXCOORD0_LOCATION && i <= GLClientState::TEXCOORD7_LOCATION ) { m_glClientActiveTexture_enc(this, GL_TEXTURE0 + i - GLClientState::TEXCOORD0_LOCATION); } if (state->enabled) { if (enableDirty) m_glEnableClientState_enc(this, state->glConst); unsigned int datalen = state->elementSize * count; int stride = state->stride; if (stride == 0) stride = state->elementSize; int firstIndex = stride * first; this->m_glBindBuffer_enc(this, GL_ARRAY_BUFFER, state->bufferObject); if (state->bufferObject == 0) { switch(i) { case GLClientState::VERTEX_LOCATION: this->glVertexPointerData(this, state->size, state->type, state->stride, (unsigned char *)state->data + firstIndex, datalen); break; case GLClientState::NORMAL_LOCATION: this->glNormalPointerData(this, state->type, state->stride, (unsigned char *)state->data + firstIndex, datalen); break; case GLClientState::COLOR_LOCATION: this->glColorPointerData(this, state->size, state->type, state->stride, (unsigned char *)state->data + firstIndex, datalen); break; case GLClientState::TEXCOORD0_LOCATION: case GLClientState::TEXCOORD1_LOCATION: case GLClientState::TEXCOORD2_LOCATION: case GLClientState::TEXCOORD3_LOCATION: case GLClientState::TEXCOORD4_LOCATION: case GLClientState::TEXCOORD5_LOCATION: case GLClientState::TEXCOORD6_LOCATION: case GLClientState::TEXCOORD7_LOCATION: this->glTexCoordPointerData(this, i - GLClientState::TEXCOORD0_LOCATION, state->size, state->type, state->stride, (unsigned char *)state->data + firstIndex, datalen); break; case GLClientState::POINTSIZE_LOCATION: this->glPointSizePointerData(this, state->type, state->stride, (unsigned char *) state->data + firstIndex, datalen); break; case GLClientState::WEIGHT_LOCATION: this->glWeightPointerData(this, state->size, state->type, state->stride, (unsigned char * ) state->data + firstIndex, datalen); break; case GLClientState::MATRIXINDEX_LOCATION: this->glMatrixIndexPointerData(this, state->size, state->type, state->stride, (unsigned char *)state->data + firstIndex, datalen); break; } } else { switch(i) { case GLClientState::VERTEX_LOCATION: this->glVertexPointerOffset(this, state->size, state->type, state->stride, (uintptr_t)state->data + firstIndex); break; case GLClientState::NORMAL_LOCATION: this->glNormalPointerOffset(this, state->type, state->stride, (uintptr_t)state->data + firstIndex); break; case GLClientState::POINTSIZE_LOCATION: this->glPointSizePointerOffset(this, state->type, state->stride, (uintptr_t)state->data + firstIndex); break; case GLClientState::COLOR_LOCATION: this->glColorPointerOffset(this, state->size, state->type, state->stride, (uintptr_t)state->data + firstIndex); break; case GLClientState::TEXCOORD0_LOCATION: case GLClientState::TEXCOORD1_LOCATION: case GLClientState::TEXCOORD2_LOCATION: case GLClientState::TEXCOORD3_LOCATION: case GLClientState::TEXCOORD4_LOCATION: case GLClientState::TEXCOORD5_LOCATION: case GLClientState::TEXCOORD6_LOCATION: case GLClientState::TEXCOORD7_LOCATION: this->glTexCoordPointerOffset(this, state->size, state->type, state->stride, (uintptr_t)state->data + firstIndex); break; case GLClientState::WEIGHT_LOCATION: this->glWeightPointerOffset(this,state->size,state->type,state->stride, (uintptr_t)state->data+firstIndex); break; case GLClientState::MATRIXINDEX_LOCATION: this->glMatrixIndexPointerOffset(this,state->size,state->type,state->stride, (uintptr_t)state->data+firstIndex); break; } } this->m_glBindBuffer_enc(this, GL_ARRAY_BUFFER, m_state->currentArrayVbo()); } else { this->m_glDisableClientState_enc(this, state->glConst); } } } void GLEncoder::s_glDrawArrays(void *self, GLenum mode, GLint first, GLsizei count) { GLEncoder *ctx = (GLEncoder *)self; bool has_arrays = false; for (int i = 0; i < GLClientState::LAST_LOCATION; i++) { const GLClientState::VertexAttribState *state = ctx->m_state->getState(i); if (state->enabled) { if (state->bufferObject || state->data) { has_arrays = true; } else { ALOGE("glDrawArrays: a vertex attribute array is enabled with no data bound\n"); ctx->setError(GL_INVALID_OPERATION); return; } } } if (!has_arrays) { ALOGE("glDrawArrays: no data bound to the command - ignoring\n"); return; } ctx->sendVertexData(first, count); ctx->m_glDrawArrays_enc(ctx, mode, /*first*/ 0, count); } void GLEncoder::s_glDrawElements(void *self, GLenum mode, GLsizei count, GLenum type, const void *indices) { GLEncoder *ctx = (GLEncoder *)self; assert(ctx->m_state != NULL); SET_ERROR_IF(count<0, GL_INVALID_VALUE); bool has_immediate_arrays = false; bool has_indirect_arrays = false; for (int i = 0; i < GLClientState::LAST_LOCATION; i++) { const GLClientState::VertexAttribState *state = ctx->m_state->getState(i); if (state->enabled) { if (state->bufferObject != 0) { has_indirect_arrays = true; } else if (state->data) { has_immediate_arrays = true; } else { ALOGE("glDrawElements: a vertex attribute array is enabled with no data bound\n"); ctx->setError(GL_INVALID_OPERATION); return; } } } if (!has_immediate_arrays && !has_indirect_arrays) { ALOGE("glDrawElements: no data bound to the command - ignoring\n"); return; } bool adjustIndices = true; if (ctx->m_state->currentIndexVbo() != 0) { if (!has_immediate_arrays) { ctx->sendVertexData(0, count); ctx->m_glBindBuffer_enc(self, GL_ELEMENT_ARRAY_BUFFER, ctx->m_state->currentIndexVbo()); ctx->glDrawElementsOffset(ctx, mode, count, type, (uintptr_t)indices); adjustIndices = false; } else { BufferData * buf = ctx->m_shared->getBufferData(ctx->m_state->currentIndexVbo()); ctx->m_glBindBuffer_enc(self, GL_ELEMENT_ARRAY_BUFFER, 0); indices = (void*)((GLintptr)buf->m_fixedBuffer.ptr() + (GLintptr)indices); } } if (adjustIndices) { void *adjustedIndices = (void*)indices; int minIndex = 0, maxIndex = 0; switch(type) { case GL_BYTE: case GL_UNSIGNED_BYTE: GLUtils::minmax((unsigned char *)indices, count, &minIndex, &maxIndex); if (minIndex != 0) { adjustedIndices = ctx->m_fixedBuffer.alloc(glSizeof(type) * count); GLUtils::shiftIndices((unsigned char *)indices, (unsigned char *)adjustedIndices, count, -minIndex); } break; case GL_SHORT: case GL_UNSIGNED_SHORT: GLUtils::minmax((unsigned short *)indices, count, &minIndex, &maxIndex); if (minIndex != 0) { adjustedIndices = ctx->m_fixedBuffer.alloc(glSizeof(type) * count); GLUtils::shiftIndices((unsigned short *)indices, (unsigned short *)adjustedIndices, count, -minIndex); } break; case GL_INT: case GL_UNSIGNED_INT: GLUtils::minmax((unsigned int *)indices, count, &minIndex, &maxIndex); if (minIndex != 0) { adjustedIndices = ctx->m_fixedBuffer.alloc(glSizeof(type) * count); GLUtils::shiftIndices((unsigned int *)indices, (unsigned int *)adjustedIndices, count, -minIndex); } break; default: ALOGE("unsupported index buffer type %d\n", type); } if (has_indirect_arrays || 1) { ctx->sendVertexData(minIndex, maxIndex - minIndex + 1); ctx->glDrawElementsData(ctx, mode, count, type, adjustedIndices, count * glSizeof(type)); // XXX - OPTIMIZATION (see the other else branch) should be implemented if(!has_indirect_arrays) { //ALOGD("unoptimized drawelements !!!\n"); } } else { // we are all direct arrays and immidate mode index array - // rebuild the arrays and the index array; ALOGE("glDrawElements: direct index & direct buffer data - will be implemented in later versions;\n"); } } } void GLEncoder::s_glActiveTexture(void* self, GLenum texture) { GLEncoder* ctx = (GLEncoder*)self; GLClientState* state = ctx->m_state; GLenum err; if ((err = state->setActiveTextureUnit(texture)) != GL_NO_ERROR) { ALOGE("%s:%s:%d GL error %#x\n", __FILE__, __FUNCTION__, __LINE__, err); ctx->setError(err); return; } ctx->m_glActiveTexture_enc(ctx, texture); } void GLEncoder::s_glBindTexture(void* self, GLenum target, GLuint texture) { GLEncoder* ctx = (GLEncoder*)self; GLClientState* state = ctx->m_state; GLenum err; GLboolean firstUse; if ((err = state->bindTexture(target, texture, &firstUse)) != GL_NO_ERROR) { ALOGE("%s:%s:%d GL error %#x\n", __FILE__, __FUNCTION__, __LINE__, err); ctx->setError(err); return; } if (target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES) { ctx->m_glBindTexture_enc(ctx, target, texture); return; } GLenum priorityTarget = state->getPriorityEnabledTarget(GL_TEXTURE_2D); if (target == GL_TEXTURE_EXTERNAL_OES && firstUse) { // set TEXTURE_EXTERNAL_OES default states which differ from TEXTURE_2D ctx->m_glBindTexture_enc(ctx, GL_TEXTURE_2D, texture); ctx->m_glTexParameteri_enc(ctx, GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); ctx->m_glTexParameteri_enc(ctx, GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); ctx->m_glTexParameteri_enc(ctx, GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); if (target != priorityTarget) { ctx->m_glBindTexture_enc(ctx, GL_TEXTURE_2D, state->getBoundTexture(GL_TEXTURE_2D)); } } if (target == priorityTarget) { ctx->m_glBindTexture_enc(ctx, GL_TEXTURE_2D, texture); } } void GLEncoder::s_glDeleteTextures(void* self, GLsizei n, const GLuint* textures) { GLEncoder* ctx = (GLEncoder*)self; GLClientState* state = ctx->m_state; state->deleteTextures(n, textures); ctx->m_glDeleteTextures_enc(ctx, n, textures); } void GLEncoder::s_glDisable(void* self, GLenum cap) { GLEncoder* ctx = (GLEncoder*)self; GLClientState* state = ctx->m_state; if (cap == GL_TEXTURE_2D || cap == GL_TEXTURE_EXTERNAL_OES) { GLenum prevTarget = state->getPriorityEnabledTarget(GL_INVALID_ENUM); state->disableTextureTarget(cap); GLenum currTarget = state->getPriorityEnabledTarget(GL_INVALID_ENUM); if (prevTarget != currTarget) { if (currTarget == GL_INVALID_ENUM) { ctx->m_glDisable_enc(ctx, GL_TEXTURE_2D); currTarget = GL_TEXTURE_2D; } // maintain the invariant that when TEXTURE_EXTERNAL_OES is // disabled, the TEXTURE_2D binding is active, even if // TEXTURE_2D is also disabled. ctx->m_glBindTexture_enc(ctx, GL_TEXTURE_2D, state->getBoundTexture(currTarget)); } } else { ctx->m_glDisable_enc(ctx, cap); } } void GLEncoder::s_glEnable(void* self, GLenum cap) { GLEncoder* ctx = (GLEncoder*)self; GLClientState* state = ctx->m_state; if (cap == GL_TEXTURE_2D || cap == GL_TEXTURE_EXTERNAL_OES) { GLenum prevTarget = state->getPriorityEnabledTarget(GL_INVALID_ENUM); state->enableTextureTarget(cap); GLenum currTarget = state->getPriorityEnabledTarget(GL_INVALID_ENUM); if (prevTarget != currTarget) { if (prevTarget == GL_INVALID_ENUM) { ctx->m_glEnable_enc(ctx, GL_TEXTURE_2D); } if (currTarget == GL_TEXTURE_EXTERNAL_OES) { ctx->m_glBindTexture_enc(ctx, GL_TEXTURE_2D, state->getBoundTexture(currTarget)); } } } else { ctx->m_glEnable_enc(ctx, cap); } } void GLEncoder::s_glGetTexParameterfv(void* self, GLenum target, GLenum pname, GLfloat* params) { GLEncoder* ctx = (GLEncoder*)self; const GLClientState* state = ctx->m_state; if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { ctx->override2DTextureTarget(target); ctx->m_glGetTexParameterfv_enc(ctx, GL_TEXTURE_2D, pname, params); ctx->restore2DTextureTarget(); } else { ctx->m_glGetTexParameterfv_enc(ctx, target, pname, params); } } void GLEncoder::s_glGetTexParameteriv(void* self, GLenum target, GLenum pname, GLint* params) { GLEncoder* ctx = (GLEncoder*)self; const GLClientState* state = ctx->m_state; switch (pname) { case GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES: *params = 1; break; default: if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { ctx->override2DTextureTarget(target); ctx->m_glGetTexParameteriv_enc(ctx, GL_TEXTURE_2D, pname, params); ctx->restore2DTextureTarget(); } else { ctx->m_glGetTexParameteriv_enc(ctx, target, pname, params); } break; } } void GLEncoder::s_glGetTexParameterxv(void* self, GLenum target, GLenum pname, GLfixed* params) { GLEncoder* ctx = (GLEncoder*)self; const GLClientState* state = ctx->m_state; if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { ctx->override2DTextureTarget(target); ctx->m_glGetTexParameterxv_enc(ctx, GL_TEXTURE_2D, pname, params); ctx->restore2DTextureTarget(); } else { ctx->m_glGetTexParameterxv_enc(ctx, target, pname, params); } } static bool isValidTextureExternalParam(GLenum pname, GLenum param) { switch (pname) { case GL_TEXTURE_MIN_FILTER: case GL_TEXTURE_MAG_FILTER: return param == GL_NEAREST || param == GL_LINEAR; case GL_TEXTURE_WRAP_S: case GL_TEXTURE_WRAP_T: return param == GL_CLAMP_TO_EDGE; case GL_GENERATE_MIPMAP: return param == GL_FALSE; default: return true; } } void GLEncoder::s_glTexParameterf(void* self, GLenum target, GLenum pname, GLfloat param) { GLEncoder* ctx = (GLEncoder*)self; const GLClientState* state = ctx->m_state; SET_ERROR_IF((target == GL_TEXTURE_EXTERNAL_OES && !isValidTextureExternalParam(pname, (GLenum)param)), GL_INVALID_ENUM); if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { ctx->override2DTextureTarget(target); ctx->m_glTexParameterf_enc(ctx, GL_TEXTURE_2D, pname, param); ctx->restore2DTextureTarget(); } else { ctx->m_glTexParameterf_enc(ctx, target, pname, param); } } void GLEncoder::s_glTexParameterfv(void* self, GLenum target, GLenum pname, const GLfloat* params) { GLEncoder* ctx = (GLEncoder*)self; const GLClientState* state = ctx->m_state; SET_ERROR_IF((target == GL_TEXTURE_EXTERNAL_OES && !isValidTextureExternalParam(pname, (GLenum)params[0])), GL_INVALID_ENUM); if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { ctx->override2DTextureTarget(target); ctx->m_glTexParameterfv_enc(ctx, GL_TEXTURE_2D, pname, params); ctx->restore2DTextureTarget(); } else { ctx->m_glTexParameterfv_enc(ctx, target, pname, params); } } void GLEncoder::s_glTexParameteri(void* self, GLenum target, GLenum pname, GLint param) { GLEncoder* ctx = (GLEncoder*)self; const GLClientState* state = ctx->m_state; SET_ERROR_IF((target == GL_TEXTURE_EXTERNAL_OES && !isValidTextureExternalParam(pname, (GLenum)param)), GL_INVALID_ENUM); if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { ctx->override2DTextureTarget(target); ctx->m_glTexParameteri_enc(ctx, GL_TEXTURE_2D, pname, param); ctx->restore2DTextureTarget(); } else { ctx->m_glTexParameteri_enc(ctx, target, pname, param); } } void GLEncoder::s_glTexParameterx(void* self, GLenum target, GLenum pname, GLfixed param) { GLEncoder* ctx = (GLEncoder*)self; const GLClientState* state = ctx->m_state; SET_ERROR_IF((target == GL_TEXTURE_EXTERNAL_OES && !isValidTextureExternalParam(pname, (GLenum)param)), GL_INVALID_ENUM); if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { ctx->override2DTextureTarget(target); ctx->m_glTexParameterx_enc(ctx, GL_TEXTURE_2D, pname, param); ctx->restore2DTextureTarget(); } else { ctx->m_glTexParameterx_enc(ctx, target, pname, param); } } void GLEncoder::s_glTexParameteriv(void* self, GLenum target, GLenum pname, const GLint* params) { GLEncoder* ctx = (GLEncoder*)self; const GLClientState* state = ctx->m_state; SET_ERROR_IF((target == GL_TEXTURE_EXTERNAL_OES && !isValidTextureExternalParam(pname, (GLenum)params[0])), GL_INVALID_ENUM); if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { ctx->override2DTextureTarget(target); ctx->m_glTexParameteriv_enc(ctx, GL_TEXTURE_2D, pname, params); ctx->restore2DTextureTarget(); } else { ctx->m_glTexParameteriv_enc(ctx, target, pname, params); } } void GLEncoder::s_glTexParameterxv(void* self, GLenum target, GLenum pname, const GLfixed* params) { GLEncoder* ctx = (GLEncoder*)self; const GLClientState* state = ctx->m_state; SET_ERROR_IF((target == GL_TEXTURE_EXTERNAL_OES && !isValidTextureExternalParam(pname, (GLenum)params[0])), GL_INVALID_ENUM); if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { ctx->override2DTextureTarget(target); ctx->m_glTexParameterxv_enc(ctx, GL_TEXTURE_2D, pname, params); ctx->restore2DTextureTarget(); } else { ctx->m_glTexParameterxv_enc(ctx, target, pname, params); } } void GLEncoder::override2DTextureTarget(GLenum target) { if ((target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) && target != m_state->getPriorityEnabledTarget(GL_TEXTURE_2D)) { m_glBindTexture_enc(this, GL_TEXTURE_2D, m_state->getBoundTexture(target)); } } void GLEncoder::restore2DTextureTarget() { GLenum priorityTarget = m_state->getPriorityEnabledTarget(GL_TEXTURE_2D); m_glBindTexture_enc(this, GL_TEXTURE_2D, m_state->getBoundTexture(priorityTarget)); } GLEncoder::GLEncoder(IOStream *stream, ChecksumCalculator *protocol) : gl_encoder_context_t(stream, protocol) { m_initialized = false; m_state = NULL; m_error = GL_NO_ERROR; m_num_compressedTextureFormats = 0; m_compressedTextureFormats = NULL; // overrides; #define OVERRIDE(name) m_##name##_enc = this-> name ; this-> name = &s_##name OVERRIDE(glFlush); OVERRIDE(glPixelStorei); OVERRIDE(glVertexPointer); OVERRIDE(glNormalPointer); OVERRIDE(glColorPointer); OVERRIDE(glPointSizePointerOES); OVERRIDE(glClientActiveTexture); OVERRIDE(glTexCoordPointer); OVERRIDE(glMatrixIndexPointerOES); OVERRIDE(glWeightPointerOES); OVERRIDE(glGetIntegerv); OVERRIDE(glGetFloatv); OVERRIDE(glGetBooleanv); OVERRIDE(glGetFixedv); OVERRIDE(glGetPointerv); OVERRIDE(glBindBuffer); OVERRIDE(glBufferData); OVERRIDE(glBufferSubData); OVERRIDE(glDeleteBuffers); OVERRIDE(glEnableClientState); OVERRIDE(glDisableClientState); OVERRIDE(glIsEnabled); OVERRIDE(glDrawArrays); OVERRIDE(glDrawElements); this->glGetString = s_glGetString; this->glFinish = s_glFinish; OVERRIDE(glGetError); OVERRIDE(glActiveTexture); OVERRIDE(glBindTexture); OVERRIDE(glDeleteTextures); OVERRIDE(glDisable); OVERRIDE(glEnable); OVERRIDE(glGetTexParameterfv); OVERRIDE(glGetTexParameteriv); OVERRIDE(glGetTexParameterxv); OVERRIDE(glTexParameterf); OVERRIDE(glTexParameterfv); OVERRIDE(glTexParameteri); OVERRIDE(glTexParameterx); OVERRIDE(glTexParameteriv); OVERRIDE(glTexParameterxv); } GLEncoder::~GLEncoder() { delete [] m_compressedTextureFormats; } size_t GLEncoder::pixelDataSize(GLsizei width, GLsizei height, GLenum format, GLenum type, int pack) { assert(m_state != NULL); return m_state->pixelDataSize(width, height, format, type, pack); } void GLEncoder::s_glFinish(void *self) { GLEncoder *ctx = (GLEncoder *)self; ctx->glFinishRoundTrip(self); } anbox-0.0~git20191115/android/opengl/system/GLESv1_enc/GLEncoder.h000066400000000000000000000166401356361734700242650ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _GL_ENCODER_H_ #define _GL_ENCODER_H_ #include "gl_enc.h" #include "GLClientState.h" #include "GLSharedGroup.h" #include "FixedBuffer.h" #include "ChecksumCalculator.h" class GLEncoder : public gl_encoder_context_t { public: GLEncoder(IOStream *stream, ChecksumCalculator* protocol); virtual ~GLEncoder(); void setClientState(GLClientState *state) { m_state = state; } void setSharedGroup(GLSharedGroupPtr shared) { m_shared = shared; } void flush() { m_stream->flush(); } size_t pixelDataSize(GLsizei width, GLsizei height, GLenum format, GLenum type, int pack); void setInitialized(){ m_initialized = true; }; bool isInitialized(){ return m_initialized; }; virtual void setError(GLenum error){ m_error = error; }; virtual GLenum getError() { return m_error; }; void override2DTextureTarget(GLenum target); void restore2DTextureTarget(); private: bool m_initialized; GLClientState *m_state; GLSharedGroupPtr m_shared; GLenum m_error; FixedBuffer m_fixedBuffer; GLint *m_compressedTextureFormats; GLint m_num_compressedTextureFormats; GLint *getCompressedTextureFormats(); // original functions; glGetError_client_proc_t m_glGetError_enc; glGetIntegerv_client_proc_t m_glGetIntegerv_enc; glGetFloatv_client_proc_t m_glGetFloatv_enc; glGetFixedv_client_proc_t m_glGetFixedv_enc; glGetBooleanv_client_proc_t m_glGetBooleanv_enc; glGetPointerv_client_proc_t m_glGetPointerv_enc; glPixelStorei_client_proc_t m_glPixelStorei_enc; glVertexPointer_client_proc_t m_glVertexPointer_enc; glNormalPointer_client_proc_t m_glNormalPointer_enc; glColorPointer_client_proc_t m_glColorPointer_enc; glPointSizePointerOES_client_proc_t m_glPointSizePointerOES_enc; glTexCoordPointer_client_proc_t m_glTexCoordPointer_enc; glClientActiveTexture_client_proc_t m_glClientActiveTexture_enc; glMatrixIndexPointerOES_client_proc_t m_glMatrixIndexPointerOES_enc; glWeightPointerOES_client_proc_t m_glWeightPointerOES_enc; glBindBuffer_client_proc_t m_glBindBuffer_enc; glBufferData_client_proc_t m_glBufferData_enc; glBufferSubData_client_proc_t m_glBufferSubData_enc; glDeleteBuffers_client_proc_t m_glDeleteBuffers_enc; glEnableClientState_client_proc_t m_glEnableClientState_enc; glDisableClientState_client_proc_t m_glDisableClientState_enc; glIsEnabled_client_proc_t m_glIsEnabled_enc; glDrawArrays_client_proc_t m_glDrawArrays_enc; glDrawElements_client_proc_t m_glDrawElements_enc; glFlush_client_proc_t m_glFlush_enc; glActiveTexture_client_proc_t m_glActiveTexture_enc; glBindTexture_client_proc_t m_glBindTexture_enc; glDeleteTextures_client_proc_t m_glDeleteTextures_enc; glDisable_client_proc_t m_glDisable_enc; glEnable_client_proc_t m_glEnable_enc; glGetTexParameterfv_client_proc_t m_glGetTexParameterfv_enc; glGetTexParameteriv_client_proc_t m_glGetTexParameteriv_enc; glGetTexParameterxv_client_proc_t m_glGetTexParameterxv_enc; glTexParameterf_client_proc_t m_glTexParameterf_enc; glTexParameterfv_client_proc_t m_glTexParameterfv_enc; glTexParameteri_client_proc_t m_glTexParameteri_enc; glTexParameterx_client_proc_t m_glTexParameterx_enc; glTexParameteriv_client_proc_t m_glTexParameteriv_enc; glTexParameterxv_client_proc_t m_glTexParameterxv_enc; // statics static GLenum s_glGetError(void * self); static void s_glGetIntegerv(void *self, GLenum pname, GLint *ptr); static void s_glGetBooleanv(void *self, GLenum pname, GLboolean *ptr); static void s_glGetFloatv(void *self, GLenum pname, GLfloat *ptr); static void s_glGetFixedv(void *self, GLenum pname, GLfixed *ptr); static void s_glGetPointerv(void *self, GLenum pname, GLvoid **params); static void s_glFlush(void * self); static const GLubyte * s_glGetString(void *self, GLenum name); static void s_glVertexPointer(void *self, int size, GLenum type, GLsizei stride, const void *data); static void s_glNormalPointer(void *self, GLenum type, GLsizei stride, const void *data); static void s_glColorPointer(void *self, int size, GLenum type, GLsizei stride, const void *data); static void s_glPointSizePointerOES(void *self, GLenum type, GLsizei stride, const void *data); static void s_glClientActiveTexture(void *self, GLenum texture); static void s_glTexCoordPointer(void *self, int size, GLenum type, GLsizei stride, const void *data); static void s_glMatrixIndexPointerOES(void *self, int size, GLenum type, GLsizei stride, const void * data); static void s_glWeightPointerOES(void *self, int size, GLenum type, GLsizei stride, const void * data); static void s_glDisableClientState(void *self, GLenum state); static void s_glEnableClientState(void *self, GLenum state); static GLboolean s_glIsEnabled(void *self, GLenum cap); static void s_glBindBuffer(void *self, GLenum target, GLuint id); static void s_glBufferData(void *self, GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage); static void s_glBufferSubData(void *self, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data); static void s_glDeleteBuffers(void *self, GLsizei n, const GLuint * buffers); static void s_glDrawArrays(void *self, GLenum mode, GLint first, GLsizei count); static void s_glDrawElements(void *self, GLenum mode, GLsizei count, GLenum type, const void *indices); static void s_glPixelStorei(void *self, GLenum param, GLint value); static void s_glFinish(void *self); void sendVertexData(unsigned first, unsigned count); static void s_glActiveTexture(void* self, GLenum texture); static void s_glBindTexture(void* self, GLenum target, GLuint texture); static void s_glDeleteTextures(void* self, GLsizei n, const GLuint* textures); static void s_glDisable(void* self, GLenum cap); static void s_glEnable(void* self, GLenum cap); static void s_glGetTexParameterfv(void* self, GLenum target, GLenum pname, GLfloat* params); static void s_glGetTexParameteriv(void* self, GLenum target, GLenum pname, GLint* params); static void s_glGetTexParameterxv(void* self, GLenum target, GLenum pname, GLfixed* params); static void s_glTexParameterf(void* self, GLenum target, GLenum pname, GLfloat param); static void s_glTexParameterfv(void* self, GLenum target, GLenum pname, const GLfloat* params); static void s_glTexParameteri(void* self, GLenum target, GLenum pname, GLint param); static void s_glTexParameterx(void* self, GLenum target, GLenum pname, GLfixed param); static void s_glTexParameteriv(void* self, GLenum target, GLenum pname, const GLint* params); static void s_glTexParameterxv(void* self, GLenum target, GLenum pname, const GLfixed* params); public: glEGLImageTargetTexture2DOES_client_proc_t m_glEGLImageTargetTexture2DOES_enc; }; #endif anbox-0.0~git20191115/android/opengl/system/GLESv1_enc/GLEncoderUtils.cpp000066400000000000000000000016401356361734700256330ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include "GLEncoder.h" namespace glesv1_enc { size_t pixelDataSize(void *self, GLsizei width, GLsizei height, GLenum format, GLenum type, int pack) { GLEncoder *ctx = (GLEncoder *)self; return ctx->pixelDataSize(width, height, format, type, pack); } } // namespace glesv1_enc anbox-0.0~git20191115/android/opengl/system/GLESv1_enc/GLEncoderUtils.h000066400000000000000000000014351356361734700253020ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef GL_ENCODER_UTILS_H #define GL_ENCODER_UTILS_H namespace glesv1_enc { size_t pixelDataSize(void *self, GLsizei width, GLsizei height, GLenum format, GLenum type, int pack); }; #endif anbox-0.0~git20191115/android/opengl/system/GLESv1_enc/gl_client_context.cpp000066400000000000000000000643731356361734700265300ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #include #include "gl_client_context.h" #include int gl_client_context_t::initDispatchByName(void *(*getProc)(const char *, void *userData), void *userData) { glAlphaFunc = (glAlphaFunc_client_proc_t) getProc("glAlphaFunc", userData); glClearColor = (glClearColor_client_proc_t) getProc("glClearColor", userData); glClearDepthf = (glClearDepthf_client_proc_t) getProc("glClearDepthf", userData); glClipPlanef = (glClipPlanef_client_proc_t) getProc("glClipPlanef", userData); glColor4f = (glColor4f_client_proc_t) getProc("glColor4f", userData); glDepthRangef = (glDepthRangef_client_proc_t) getProc("glDepthRangef", userData); glFogf = (glFogf_client_proc_t) getProc("glFogf", userData); glFogfv = (glFogfv_client_proc_t) getProc("glFogfv", userData); glFrustumf = (glFrustumf_client_proc_t) getProc("glFrustumf", userData); glGetClipPlanef = (glGetClipPlanef_client_proc_t) getProc("glGetClipPlanef", userData); glGetFloatv = (glGetFloatv_client_proc_t) getProc("glGetFloatv", userData); glGetLightfv = (glGetLightfv_client_proc_t) getProc("glGetLightfv", userData); glGetMaterialfv = (glGetMaterialfv_client_proc_t) getProc("glGetMaterialfv", userData); glGetTexEnvfv = (glGetTexEnvfv_client_proc_t) getProc("glGetTexEnvfv", userData); glGetTexParameterfv = (glGetTexParameterfv_client_proc_t) getProc("glGetTexParameterfv", userData); glLightModelf = (glLightModelf_client_proc_t) getProc("glLightModelf", userData); glLightModelfv = (glLightModelfv_client_proc_t) getProc("glLightModelfv", userData); glLightf = (glLightf_client_proc_t) getProc("glLightf", userData); glLightfv = (glLightfv_client_proc_t) getProc("glLightfv", userData); glLineWidth = (glLineWidth_client_proc_t) getProc("glLineWidth", userData); glLoadMatrixf = (glLoadMatrixf_client_proc_t) getProc("glLoadMatrixf", userData); glMaterialf = (glMaterialf_client_proc_t) getProc("glMaterialf", userData); glMaterialfv = (glMaterialfv_client_proc_t) getProc("glMaterialfv", userData); glMultMatrixf = (glMultMatrixf_client_proc_t) getProc("glMultMatrixf", userData); glMultiTexCoord4f = (glMultiTexCoord4f_client_proc_t) getProc("glMultiTexCoord4f", userData); glNormal3f = (glNormal3f_client_proc_t) getProc("glNormal3f", userData); glOrthof = (glOrthof_client_proc_t) getProc("glOrthof", userData); glPointParameterf = (glPointParameterf_client_proc_t) getProc("glPointParameterf", userData); glPointParameterfv = (glPointParameterfv_client_proc_t) getProc("glPointParameterfv", userData); glPointSize = (glPointSize_client_proc_t) getProc("glPointSize", userData); glPolygonOffset = (glPolygonOffset_client_proc_t) getProc("glPolygonOffset", userData); glRotatef = (glRotatef_client_proc_t) getProc("glRotatef", userData); glScalef = (glScalef_client_proc_t) getProc("glScalef", userData); glTexEnvf = (glTexEnvf_client_proc_t) getProc("glTexEnvf", userData); glTexEnvfv = (glTexEnvfv_client_proc_t) getProc("glTexEnvfv", userData); glTexParameterf = (glTexParameterf_client_proc_t) getProc("glTexParameterf", userData); glTexParameterfv = (glTexParameterfv_client_proc_t) getProc("glTexParameterfv", userData); glTranslatef = (glTranslatef_client_proc_t) getProc("glTranslatef", userData); glActiveTexture = (glActiveTexture_client_proc_t) getProc("glActiveTexture", userData); glAlphaFuncx = (glAlphaFuncx_client_proc_t) getProc("glAlphaFuncx", userData); glBindBuffer = (glBindBuffer_client_proc_t) getProc("glBindBuffer", userData); glBindTexture = (glBindTexture_client_proc_t) getProc("glBindTexture", userData); glBlendFunc = (glBlendFunc_client_proc_t) getProc("glBlendFunc", userData); glBufferData = (glBufferData_client_proc_t) getProc("glBufferData", userData); glBufferSubData = (glBufferSubData_client_proc_t) getProc("glBufferSubData", userData); glClear = (glClear_client_proc_t) getProc("glClear", userData); glClearColorx = (glClearColorx_client_proc_t) getProc("glClearColorx", userData); glClearDepthx = (glClearDepthx_client_proc_t) getProc("glClearDepthx", userData); glClearStencil = (glClearStencil_client_proc_t) getProc("glClearStencil", userData); glClientActiveTexture = (glClientActiveTexture_client_proc_t) getProc("glClientActiveTexture", userData); glColor4ub = (glColor4ub_client_proc_t) getProc("glColor4ub", userData); glColor4x = (glColor4x_client_proc_t) getProc("glColor4x", userData); glColorMask = (glColorMask_client_proc_t) getProc("glColorMask", userData); glColorPointer = (glColorPointer_client_proc_t) getProc("glColorPointer", userData); glCompressedTexImage2D = (glCompressedTexImage2D_client_proc_t) getProc("glCompressedTexImage2D", userData); glCompressedTexSubImage2D = (glCompressedTexSubImage2D_client_proc_t) getProc("glCompressedTexSubImage2D", userData); glCopyTexImage2D = (glCopyTexImage2D_client_proc_t) getProc("glCopyTexImage2D", userData); glCopyTexSubImage2D = (glCopyTexSubImage2D_client_proc_t) getProc("glCopyTexSubImage2D", userData); glCullFace = (glCullFace_client_proc_t) getProc("glCullFace", userData); glDeleteBuffers = (glDeleteBuffers_client_proc_t) getProc("glDeleteBuffers", userData); glDeleteTextures = (glDeleteTextures_client_proc_t) getProc("glDeleteTextures", userData); glDepthFunc = (glDepthFunc_client_proc_t) getProc("glDepthFunc", userData); glDepthMask = (glDepthMask_client_proc_t) getProc("glDepthMask", userData); glDepthRangex = (glDepthRangex_client_proc_t) getProc("glDepthRangex", userData); glDisable = (glDisable_client_proc_t) getProc("glDisable", userData); glDisableClientState = (glDisableClientState_client_proc_t) getProc("glDisableClientState", userData); glDrawArrays = (glDrawArrays_client_proc_t) getProc("glDrawArrays", userData); glDrawElements = (glDrawElements_client_proc_t) getProc("glDrawElements", userData); glEnable = (glEnable_client_proc_t) getProc("glEnable", userData); glEnableClientState = (glEnableClientState_client_proc_t) getProc("glEnableClientState", userData); glFinish = (glFinish_client_proc_t) getProc("glFinish", userData); glFlush = (glFlush_client_proc_t) getProc("glFlush", userData); glFogx = (glFogx_client_proc_t) getProc("glFogx", userData); glFogxv = (glFogxv_client_proc_t) getProc("glFogxv", userData); glFrontFace = (glFrontFace_client_proc_t) getProc("glFrontFace", userData); glFrustumx = (glFrustumx_client_proc_t) getProc("glFrustumx", userData); glGetBooleanv = (glGetBooleanv_client_proc_t) getProc("glGetBooleanv", userData); glGetBufferParameteriv = (glGetBufferParameteriv_client_proc_t) getProc("glGetBufferParameteriv", userData); glClipPlanex = (glClipPlanex_client_proc_t) getProc("glClipPlanex", userData); glGenBuffers = (glGenBuffers_client_proc_t) getProc("glGenBuffers", userData); glGenTextures = (glGenTextures_client_proc_t) getProc("glGenTextures", userData); glGetError = (glGetError_client_proc_t) getProc("glGetError", userData); glGetFixedv = (glGetFixedv_client_proc_t) getProc("glGetFixedv", userData); glGetIntegerv = (glGetIntegerv_client_proc_t) getProc("glGetIntegerv", userData); glGetLightxv = (glGetLightxv_client_proc_t) getProc("glGetLightxv", userData); glGetMaterialxv = (glGetMaterialxv_client_proc_t) getProc("glGetMaterialxv", userData); glGetPointerv = (glGetPointerv_client_proc_t) getProc("glGetPointerv", userData); glGetString = (glGetString_client_proc_t) getProc("glGetString", userData); glGetTexEnviv = (glGetTexEnviv_client_proc_t) getProc("glGetTexEnviv", userData); glGetTexEnvxv = (glGetTexEnvxv_client_proc_t) getProc("glGetTexEnvxv", userData); glGetTexParameteriv = (glGetTexParameteriv_client_proc_t) getProc("glGetTexParameteriv", userData); glGetTexParameterxv = (glGetTexParameterxv_client_proc_t) getProc("glGetTexParameterxv", userData); glHint = (glHint_client_proc_t) getProc("glHint", userData); glIsBuffer = (glIsBuffer_client_proc_t) getProc("glIsBuffer", userData); glIsEnabled = (glIsEnabled_client_proc_t) getProc("glIsEnabled", userData); glIsTexture = (glIsTexture_client_proc_t) getProc("glIsTexture", userData); glLightModelx = (glLightModelx_client_proc_t) getProc("glLightModelx", userData); glLightModelxv = (glLightModelxv_client_proc_t) getProc("glLightModelxv", userData); glLightx = (glLightx_client_proc_t) getProc("glLightx", userData); glLightxv = (glLightxv_client_proc_t) getProc("glLightxv", userData); glLineWidthx = (glLineWidthx_client_proc_t) getProc("glLineWidthx", userData); glLoadIdentity = (glLoadIdentity_client_proc_t) getProc("glLoadIdentity", userData); glLoadMatrixx = (glLoadMatrixx_client_proc_t) getProc("glLoadMatrixx", userData); glLogicOp = (glLogicOp_client_proc_t) getProc("glLogicOp", userData); glMaterialx = (glMaterialx_client_proc_t) getProc("glMaterialx", userData); glMaterialxv = (glMaterialxv_client_proc_t) getProc("glMaterialxv", userData); glMatrixMode = (glMatrixMode_client_proc_t) getProc("glMatrixMode", userData); glMultMatrixx = (glMultMatrixx_client_proc_t) getProc("glMultMatrixx", userData); glMultiTexCoord4x = (glMultiTexCoord4x_client_proc_t) getProc("glMultiTexCoord4x", userData); glNormal3x = (glNormal3x_client_proc_t) getProc("glNormal3x", userData); glNormalPointer = (glNormalPointer_client_proc_t) getProc("glNormalPointer", userData); glOrthox = (glOrthox_client_proc_t) getProc("glOrthox", userData); glPixelStorei = (glPixelStorei_client_proc_t) getProc("glPixelStorei", userData); glPointParameterx = (glPointParameterx_client_proc_t) getProc("glPointParameterx", userData); glPointParameterxv = (glPointParameterxv_client_proc_t) getProc("glPointParameterxv", userData); glPointSizex = (glPointSizex_client_proc_t) getProc("glPointSizex", userData); glPolygonOffsetx = (glPolygonOffsetx_client_proc_t) getProc("glPolygonOffsetx", userData); glPopMatrix = (glPopMatrix_client_proc_t) getProc("glPopMatrix", userData); glPushMatrix = (glPushMatrix_client_proc_t) getProc("glPushMatrix", userData); glReadPixels = (glReadPixels_client_proc_t) getProc("glReadPixels", userData); glRotatex = (glRotatex_client_proc_t) getProc("glRotatex", userData); glSampleCoverage = (glSampleCoverage_client_proc_t) getProc("glSampleCoverage", userData); glSampleCoveragex = (glSampleCoveragex_client_proc_t) getProc("glSampleCoveragex", userData); glScalex = (glScalex_client_proc_t) getProc("glScalex", userData); glScissor = (glScissor_client_proc_t) getProc("glScissor", userData); glShadeModel = (glShadeModel_client_proc_t) getProc("glShadeModel", userData); glStencilFunc = (glStencilFunc_client_proc_t) getProc("glStencilFunc", userData); glStencilMask = (glStencilMask_client_proc_t) getProc("glStencilMask", userData); glStencilOp = (glStencilOp_client_proc_t) getProc("glStencilOp", userData); glTexCoordPointer = (glTexCoordPointer_client_proc_t) getProc("glTexCoordPointer", userData); glTexEnvi = (glTexEnvi_client_proc_t) getProc("glTexEnvi", userData); glTexEnvx = (glTexEnvx_client_proc_t) getProc("glTexEnvx", userData); glTexEnviv = (glTexEnviv_client_proc_t) getProc("glTexEnviv", userData); glTexEnvxv = (glTexEnvxv_client_proc_t) getProc("glTexEnvxv", userData); glTexImage2D = (glTexImage2D_client_proc_t) getProc("glTexImage2D", userData); glTexParameteri = (glTexParameteri_client_proc_t) getProc("glTexParameteri", userData); glTexParameterx = (glTexParameterx_client_proc_t) getProc("glTexParameterx", userData); glTexParameteriv = (glTexParameteriv_client_proc_t) getProc("glTexParameteriv", userData); glTexParameterxv = (glTexParameterxv_client_proc_t) getProc("glTexParameterxv", userData); glTexSubImage2D = (glTexSubImage2D_client_proc_t) getProc("glTexSubImage2D", userData); glTranslatex = (glTranslatex_client_proc_t) getProc("glTranslatex", userData); glVertexPointer = (glVertexPointer_client_proc_t) getProc("glVertexPointer", userData); glViewport = (glViewport_client_proc_t) getProc("glViewport", userData); glPointSizePointerOES = (glPointSizePointerOES_client_proc_t) getProc("glPointSizePointerOES", userData); glVertexPointerOffset = (glVertexPointerOffset_client_proc_t) getProc("glVertexPointerOffset", userData); glColorPointerOffset = (glColorPointerOffset_client_proc_t) getProc("glColorPointerOffset", userData); glNormalPointerOffset = (glNormalPointerOffset_client_proc_t) getProc("glNormalPointerOffset", userData); glPointSizePointerOffset = (glPointSizePointerOffset_client_proc_t) getProc("glPointSizePointerOffset", userData); glTexCoordPointerOffset = (glTexCoordPointerOffset_client_proc_t) getProc("glTexCoordPointerOffset", userData); glWeightPointerOffset = (glWeightPointerOffset_client_proc_t) getProc("glWeightPointerOffset", userData); glMatrixIndexPointerOffset = (glMatrixIndexPointerOffset_client_proc_t) getProc("glMatrixIndexPointerOffset", userData); glVertexPointerData = (glVertexPointerData_client_proc_t) getProc("glVertexPointerData", userData); glColorPointerData = (glColorPointerData_client_proc_t) getProc("glColorPointerData", userData); glNormalPointerData = (glNormalPointerData_client_proc_t) getProc("glNormalPointerData", userData); glTexCoordPointerData = (glTexCoordPointerData_client_proc_t) getProc("glTexCoordPointerData", userData); glPointSizePointerData = (glPointSizePointerData_client_proc_t) getProc("glPointSizePointerData", userData); glWeightPointerData = (glWeightPointerData_client_proc_t) getProc("glWeightPointerData", userData); glMatrixIndexPointerData = (glMatrixIndexPointerData_client_proc_t) getProc("glMatrixIndexPointerData", userData); glDrawElementsOffset = (glDrawElementsOffset_client_proc_t) getProc("glDrawElementsOffset", userData); glDrawElementsData = (glDrawElementsData_client_proc_t) getProc("glDrawElementsData", userData); glGetCompressedTextureFormats = (glGetCompressedTextureFormats_client_proc_t) getProc("glGetCompressedTextureFormats", userData); glFinishRoundTrip = (glFinishRoundTrip_client_proc_t) getProc("glFinishRoundTrip", userData); glBlendEquationSeparateOES = (glBlendEquationSeparateOES_client_proc_t) getProc("glBlendEquationSeparateOES", userData); glBlendFuncSeparateOES = (glBlendFuncSeparateOES_client_proc_t) getProc("glBlendFuncSeparateOES", userData); glBlendEquationOES = (glBlendEquationOES_client_proc_t) getProc("glBlendEquationOES", userData); glDrawTexsOES = (glDrawTexsOES_client_proc_t) getProc("glDrawTexsOES", userData); glDrawTexiOES = (glDrawTexiOES_client_proc_t) getProc("glDrawTexiOES", userData); glDrawTexxOES = (glDrawTexxOES_client_proc_t) getProc("glDrawTexxOES", userData); glDrawTexsvOES = (glDrawTexsvOES_client_proc_t) getProc("glDrawTexsvOES", userData); glDrawTexivOES = (glDrawTexivOES_client_proc_t) getProc("glDrawTexivOES", userData); glDrawTexxvOES = (glDrawTexxvOES_client_proc_t) getProc("glDrawTexxvOES", userData); glDrawTexfOES = (glDrawTexfOES_client_proc_t) getProc("glDrawTexfOES", userData); glDrawTexfvOES = (glDrawTexfvOES_client_proc_t) getProc("glDrawTexfvOES", userData); glEGLImageTargetTexture2DOES = (glEGLImageTargetTexture2DOES_client_proc_t) getProc("glEGLImageTargetTexture2DOES", userData); glEGLImageTargetRenderbufferStorageOES = (glEGLImageTargetRenderbufferStorageOES_client_proc_t) getProc("glEGLImageTargetRenderbufferStorageOES", userData); glAlphaFuncxOES = (glAlphaFuncxOES_client_proc_t) getProc("glAlphaFuncxOES", userData); glClearColorxOES = (glClearColorxOES_client_proc_t) getProc("glClearColorxOES", userData); glClearDepthxOES = (glClearDepthxOES_client_proc_t) getProc("glClearDepthxOES", userData); glClipPlanexOES = (glClipPlanexOES_client_proc_t) getProc("glClipPlanexOES", userData); glClipPlanexIMG = (glClipPlanexIMG_client_proc_t) getProc("glClipPlanexIMG", userData); glColor4xOES = (glColor4xOES_client_proc_t) getProc("glColor4xOES", userData); glDepthRangexOES = (glDepthRangexOES_client_proc_t) getProc("glDepthRangexOES", userData); glFogxOES = (glFogxOES_client_proc_t) getProc("glFogxOES", userData); glFogxvOES = (glFogxvOES_client_proc_t) getProc("glFogxvOES", userData); glFrustumxOES = (glFrustumxOES_client_proc_t) getProc("glFrustumxOES", userData); glGetClipPlanexOES = (glGetClipPlanexOES_client_proc_t) getProc("glGetClipPlanexOES", userData); glGetClipPlanex = (glGetClipPlanex_client_proc_t) getProc("glGetClipPlanex", userData); glGetFixedvOES = (glGetFixedvOES_client_proc_t) getProc("glGetFixedvOES", userData); glGetLightxvOES = (glGetLightxvOES_client_proc_t) getProc("glGetLightxvOES", userData); glGetMaterialxvOES = (glGetMaterialxvOES_client_proc_t) getProc("glGetMaterialxvOES", userData); glGetTexEnvxvOES = (glGetTexEnvxvOES_client_proc_t) getProc("glGetTexEnvxvOES", userData); glGetTexParameterxvOES = (glGetTexParameterxvOES_client_proc_t) getProc("glGetTexParameterxvOES", userData); glLightModelxOES = (glLightModelxOES_client_proc_t) getProc("glLightModelxOES", userData); glLightModelxvOES = (glLightModelxvOES_client_proc_t) getProc("glLightModelxvOES", userData); glLightxOES = (glLightxOES_client_proc_t) getProc("glLightxOES", userData); glLightxvOES = (glLightxvOES_client_proc_t) getProc("glLightxvOES", userData); glLineWidthxOES = (glLineWidthxOES_client_proc_t) getProc("glLineWidthxOES", userData); glLoadMatrixxOES = (glLoadMatrixxOES_client_proc_t) getProc("glLoadMatrixxOES", userData); glMaterialxOES = (glMaterialxOES_client_proc_t) getProc("glMaterialxOES", userData); glMaterialxvOES = (glMaterialxvOES_client_proc_t) getProc("glMaterialxvOES", userData); glMultMatrixxOES = (glMultMatrixxOES_client_proc_t) getProc("glMultMatrixxOES", userData); glMultiTexCoord4xOES = (glMultiTexCoord4xOES_client_proc_t) getProc("glMultiTexCoord4xOES", userData); glNormal3xOES = (glNormal3xOES_client_proc_t) getProc("glNormal3xOES", userData); glOrthoxOES = (glOrthoxOES_client_proc_t) getProc("glOrthoxOES", userData); glPointParameterxOES = (glPointParameterxOES_client_proc_t) getProc("glPointParameterxOES", userData); glPointParameterxvOES = (glPointParameterxvOES_client_proc_t) getProc("glPointParameterxvOES", userData); glPointSizexOES = (glPointSizexOES_client_proc_t) getProc("glPointSizexOES", userData); glPolygonOffsetxOES = (glPolygonOffsetxOES_client_proc_t) getProc("glPolygonOffsetxOES", userData); glRotatexOES = (glRotatexOES_client_proc_t) getProc("glRotatexOES", userData); glSampleCoveragexOES = (glSampleCoveragexOES_client_proc_t) getProc("glSampleCoveragexOES", userData); glScalexOES = (glScalexOES_client_proc_t) getProc("glScalexOES", userData); glTexEnvxOES = (glTexEnvxOES_client_proc_t) getProc("glTexEnvxOES", userData); glTexEnvxvOES = (glTexEnvxvOES_client_proc_t) getProc("glTexEnvxvOES", userData); glTexParameterxOES = (glTexParameterxOES_client_proc_t) getProc("glTexParameterxOES", userData); glTexParameterxvOES = (glTexParameterxvOES_client_proc_t) getProc("glTexParameterxvOES", userData); glTranslatexOES = (glTranslatexOES_client_proc_t) getProc("glTranslatexOES", userData); glIsRenderbufferOES = (glIsRenderbufferOES_client_proc_t) getProc("glIsRenderbufferOES", userData); glBindRenderbufferOES = (glBindRenderbufferOES_client_proc_t) getProc("glBindRenderbufferOES", userData); glDeleteRenderbuffersOES = (glDeleteRenderbuffersOES_client_proc_t) getProc("glDeleteRenderbuffersOES", userData); glGenRenderbuffersOES = (glGenRenderbuffersOES_client_proc_t) getProc("glGenRenderbuffersOES", userData); glRenderbufferStorageOES = (glRenderbufferStorageOES_client_proc_t) getProc("glRenderbufferStorageOES", userData); glGetRenderbufferParameterivOES = (glGetRenderbufferParameterivOES_client_proc_t) getProc("glGetRenderbufferParameterivOES", userData); glIsFramebufferOES = (glIsFramebufferOES_client_proc_t) getProc("glIsFramebufferOES", userData); glBindFramebufferOES = (glBindFramebufferOES_client_proc_t) getProc("glBindFramebufferOES", userData); glDeleteFramebuffersOES = (glDeleteFramebuffersOES_client_proc_t) getProc("glDeleteFramebuffersOES", userData); glGenFramebuffersOES = (glGenFramebuffersOES_client_proc_t) getProc("glGenFramebuffersOES", userData); glCheckFramebufferStatusOES = (glCheckFramebufferStatusOES_client_proc_t) getProc("glCheckFramebufferStatusOES", userData); glFramebufferRenderbufferOES = (glFramebufferRenderbufferOES_client_proc_t) getProc("glFramebufferRenderbufferOES", userData); glFramebufferTexture2DOES = (glFramebufferTexture2DOES_client_proc_t) getProc("glFramebufferTexture2DOES", userData); glGetFramebufferAttachmentParameterivOES = (glGetFramebufferAttachmentParameterivOES_client_proc_t) getProc("glGetFramebufferAttachmentParameterivOES", userData); glGenerateMipmapOES = (glGenerateMipmapOES_client_proc_t) getProc("glGenerateMipmapOES", userData); glMapBufferOES = (glMapBufferOES_client_proc_t) getProc("glMapBufferOES", userData); glUnmapBufferOES = (glUnmapBufferOES_client_proc_t) getProc("glUnmapBufferOES", userData); glGetBufferPointervOES = (glGetBufferPointervOES_client_proc_t) getProc("glGetBufferPointervOES", userData); glCurrentPaletteMatrixOES = (glCurrentPaletteMatrixOES_client_proc_t) getProc("glCurrentPaletteMatrixOES", userData); glLoadPaletteFromModelViewMatrixOES = (glLoadPaletteFromModelViewMatrixOES_client_proc_t) getProc("glLoadPaletteFromModelViewMatrixOES", userData); glMatrixIndexPointerOES = (glMatrixIndexPointerOES_client_proc_t) getProc("glMatrixIndexPointerOES", userData); glWeightPointerOES = (glWeightPointerOES_client_proc_t) getProc("glWeightPointerOES", userData); glQueryMatrixxOES = (glQueryMatrixxOES_client_proc_t) getProc("glQueryMatrixxOES", userData); glDepthRangefOES = (glDepthRangefOES_client_proc_t) getProc("glDepthRangefOES", userData); glFrustumfOES = (glFrustumfOES_client_proc_t) getProc("glFrustumfOES", userData); glOrthofOES = (glOrthofOES_client_proc_t) getProc("glOrthofOES", userData); glClipPlanefOES = (glClipPlanefOES_client_proc_t) getProc("glClipPlanefOES", userData); glClipPlanefIMG = (glClipPlanefIMG_client_proc_t) getProc("glClipPlanefIMG", userData); glGetClipPlanefOES = (glGetClipPlanefOES_client_proc_t) getProc("glGetClipPlanefOES", userData); glClearDepthfOES = (glClearDepthfOES_client_proc_t) getProc("glClearDepthfOES", userData); glTexGenfOES = (glTexGenfOES_client_proc_t) getProc("glTexGenfOES", userData); glTexGenfvOES = (glTexGenfvOES_client_proc_t) getProc("glTexGenfvOES", userData); glTexGeniOES = (glTexGeniOES_client_proc_t) getProc("glTexGeniOES", userData); glTexGenivOES = (glTexGenivOES_client_proc_t) getProc("glTexGenivOES", userData); glTexGenxOES = (glTexGenxOES_client_proc_t) getProc("glTexGenxOES", userData); glTexGenxvOES = (glTexGenxvOES_client_proc_t) getProc("glTexGenxvOES", userData); glGetTexGenfvOES = (glGetTexGenfvOES_client_proc_t) getProc("glGetTexGenfvOES", userData); glGetTexGenivOES = (glGetTexGenivOES_client_proc_t) getProc("glGetTexGenivOES", userData); glGetTexGenxvOES = (glGetTexGenxvOES_client_proc_t) getProc("glGetTexGenxvOES", userData); glBindVertexArrayOES = (glBindVertexArrayOES_client_proc_t) getProc("glBindVertexArrayOES", userData); glDeleteVertexArraysOES = (glDeleteVertexArraysOES_client_proc_t) getProc("glDeleteVertexArraysOES", userData); glGenVertexArraysOES = (glGenVertexArraysOES_client_proc_t) getProc("glGenVertexArraysOES", userData); glIsVertexArrayOES = (glIsVertexArrayOES_client_proc_t) getProc("glIsVertexArrayOES", userData); glDiscardFramebufferEXT = (glDiscardFramebufferEXT_client_proc_t) getProc("glDiscardFramebufferEXT", userData); glMultiDrawArraysEXT = (glMultiDrawArraysEXT_client_proc_t) getProc("glMultiDrawArraysEXT", userData); glMultiDrawElementsEXT = (glMultiDrawElementsEXT_client_proc_t) getProc("glMultiDrawElementsEXT", userData); glMultiDrawArraysSUN = (glMultiDrawArraysSUN_client_proc_t) getProc("glMultiDrawArraysSUN", userData); glMultiDrawElementsSUN = (glMultiDrawElementsSUN_client_proc_t) getProc("glMultiDrawElementsSUN", userData); glRenderbufferStorageMultisampleIMG = (glRenderbufferStorageMultisampleIMG_client_proc_t) getProc("glRenderbufferStorageMultisampleIMG", userData); glFramebufferTexture2DMultisampleIMG = (glFramebufferTexture2DMultisampleIMG_client_proc_t) getProc("glFramebufferTexture2DMultisampleIMG", userData); glDeleteFencesNV = (glDeleteFencesNV_client_proc_t) getProc("glDeleteFencesNV", userData); glGenFencesNV = (glGenFencesNV_client_proc_t) getProc("glGenFencesNV", userData); glIsFenceNV = (glIsFenceNV_client_proc_t) getProc("glIsFenceNV", userData); glTestFenceNV = (glTestFenceNV_client_proc_t) getProc("glTestFenceNV", userData); glGetFenceivNV = (glGetFenceivNV_client_proc_t) getProc("glGetFenceivNV", userData); glFinishFenceNV = (glFinishFenceNV_client_proc_t) getProc("glFinishFenceNV", userData); glSetFenceNV = (glSetFenceNV_client_proc_t) getProc("glSetFenceNV", userData); glGetDriverControlsQCOM = (glGetDriverControlsQCOM_client_proc_t) getProc("glGetDriverControlsQCOM", userData); glGetDriverControlStringQCOM = (glGetDriverControlStringQCOM_client_proc_t) getProc("glGetDriverControlStringQCOM", userData); glEnableDriverControlQCOM = (glEnableDriverControlQCOM_client_proc_t) getProc("glEnableDriverControlQCOM", userData); glDisableDriverControlQCOM = (glDisableDriverControlQCOM_client_proc_t) getProc("glDisableDriverControlQCOM", userData); glExtGetTexturesQCOM = (glExtGetTexturesQCOM_client_proc_t) getProc("glExtGetTexturesQCOM", userData); glExtGetBuffersQCOM = (glExtGetBuffersQCOM_client_proc_t) getProc("glExtGetBuffersQCOM", userData); glExtGetRenderbuffersQCOM = (glExtGetRenderbuffersQCOM_client_proc_t) getProc("glExtGetRenderbuffersQCOM", userData); glExtGetFramebuffersQCOM = (glExtGetFramebuffersQCOM_client_proc_t) getProc("glExtGetFramebuffersQCOM", userData); glExtGetTexLevelParameterivQCOM = (glExtGetTexLevelParameterivQCOM_client_proc_t) getProc("glExtGetTexLevelParameterivQCOM", userData); glExtTexObjectStateOverrideiQCOM = (glExtTexObjectStateOverrideiQCOM_client_proc_t) getProc("glExtTexObjectStateOverrideiQCOM", userData); glExtGetTexSubImageQCOM = (glExtGetTexSubImageQCOM_client_proc_t) getProc("glExtGetTexSubImageQCOM", userData); glExtGetBufferPointervQCOM = (glExtGetBufferPointervQCOM_client_proc_t) getProc("glExtGetBufferPointervQCOM", userData); glExtGetShadersQCOM = (glExtGetShadersQCOM_client_proc_t) getProc("glExtGetShadersQCOM", userData); glExtGetProgramsQCOM = (glExtGetProgramsQCOM_client_proc_t) getProc("glExtGetProgramsQCOM", userData); glExtIsProgramBinaryQCOM = (glExtIsProgramBinaryQCOM_client_proc_t) getProc("glExtIsProgramBinaryQCOM", userData); glExtGetProgramBinarySourceQCOM = (glExtGetProgramBinarySourceQCOM_client_proc_t) getProc("glExtGetProgramBinarySourceQCOM", userData); glStartTilingQCOM = (glStartTilingQCOM_client_proc_t) getProc("glStartTilingQCOM", userData); glEndTilingQCOM = (glEndTilingQCOM_client_proc_t) getProc("glEndTilingQCOM", userData); return 0; } anbox-0.0~git20191115/android/opengl/system/GLESv1_enc/gl_client_context.h000066400000000000000000000352561356361734700261730ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef __gl_client_context_t_h #define __gl_client_context_t_h #include "gl_client_proc.h" #include "gl_types.h" struct gl_client_context_t { glAlphaFunc_client_proc_t glAlphaFunc; glClearColor_client_proc_t glClearColor; glClearDepthf_client_proc_t glClearDepthf; glClipPlanef_client_proc_t glClipPlanef; glColor4f_client_proc_t glColor4f; glDepthRangef_client_proc_t glDepthRangef; glFogf_client_proc_t glFogf; glFogfv_client_proc_t glFogfv; glFrustumf_client_proc_t glFrustumf; glGetClipPlanef_client_proc_t glGetClipPlanef; glGetFloatv_client_proc_t glGetFloatv; glGetLightfv_client_proc_t glGetLightfv; glGetMaterialfv_client_proc_t glGetMaterialfv; glGetTexEnvfv_client_proc_t glGetTexEnvfv; glGetTexParameterfv_client_proc_t glGetTexParameterfv; glLightModelf_client_proc_t glLightModelf; glLightModelfv_client_proc_t glLightModelfv; glLightf_client_proc_t glLightf; glLightfv_client_proc_t glLightfv; glLineWidth_client_proc_t glLineWidth; glLoadMatrixf_client_proc_t glLoadMatrixf; glMaterialf_client_proc_t glMaterialf; glMaterialfv_client_proc_t glMaterialfv; glMultMatrixf_client_proc_t glMultMatrixf; glMultiTexCoord4f_client_proc_t glMultiTexCoord4f; glNormal3f_client_proc_t glNormal3f; glOrthof_client_proc_t glOrthof; glPointParameterf_client_proc_t glPointParameterf; glPointParameterfv_client_proc_t glPointParameterfv; glPointSize_client_proc_t glPointSize; glPolygonOffset_client_proc_t glPolygonOffset; glRotatef_client_proc_t glRotatef; glScalef_client_proc_t glScalef; glTexEnvf_client_proc_t glTexEnvf; glTexEnvfv_client_proc_t glTexEnvfv; glTexParameterf_client_proc_t glTexParameterf; glTexParameterfv_client_proc_t glTexParameterfv; glTranslatef_client_proc_t glTranslatef; glActiveTexture_client_proc_t glActiveTexture; glAlphaFuncx_client_proc_t glAlphaFuncx; glBindBuffer_client_proc_t glBindBuffer; glBindTexture_client_proc_t glBindTexture; glBlendFunc_client_proc_t glBlendFunc; glBufferData_client_proc_t glBufferData; glBufferSubData_client_proc_t glBufferSubData; glClear_client_proc_t glClear; glClearColorx_client_proc_t glClearColorx; glClearDepthx_client_proc_t glClearDepthx; glClearStencil_client_proc_t glClearStencil; glClientActiveTexture_client_proc_t glClientActiveTexture; glColor4ub_client_proc_t glColor4ub; glColor4x_client_proc_t glColor4x; glColorMask_client_proc_t glColorMask; glColorPointer_client_proc_t glColorPointer; glCompressedTexImage2D_client_proc_t glCompressedTexImage2D; glCompressedTexSubImage2D_client_proc_t glCompressedTexSubImage2D; glCopyTexImage2D_client_proc_t glCopyTexImage2D; glCopyTexSubImage2D_client_proc_t glCopyTexSubImage2D; glCullFace_client_proc_t glCullFace; glDeleteBuffers_client_proc_t glDeleteBuffers; glDeleteTextures_client_proc_t glDeleteTextures; glDepthFunc_client_proc_t glDepthFunc; glDepthMask_client_proc_t glDepthMask; glDepthRangex_client_proc_t glDepthRangex; glDisable_client_proc_t glDisable; glDisableClientState_client_proc_t glDisableClientState; glDrawArrays_client_proc_t glDrawArrays; glDrawElements_client_proc_t glDrawElements; glEnable_client_proc_t glEnable; glEnableClientState_client_proc_t glEnableClientState; glFinish_client_proc_t glFinish; glFlush_client_proc_t glFlush; glFogx_client_proc_t glFogx; glFogxv_client_proc_t glFogxv; glFrontFace_client_proc_t glFrontFace; glFrustumx_client_proc_t glFrustumx; glGetBooleanv_client_proc_t glGetBooleanv; glGetBufferParameteriv_client_proc_t glGetBufferParameteriv; glClipPlanex_client_proc_t glClipPlanex; glGenBuffers_client_proc_t glGenBuffers; glGenTextures_client_proc_t glGenTextures; glGetError_client_proc_t glGetError; glGetFixedv_client_proc_t glGetFixedv; glGetIntegerv_client_proc_t glGetIntegerv; glGetLightxv_client_proc_t glGetLightxv; glGetMaterialxv_client_proc_t glGetMaterialxv; glGetPointerv_client_proc_t glGetPointerv; glGetString_client_proc_t glGetString; glGetTexEnviv_client_proc_t glGetTexEnviv; glGetTexEnvxv_client_proc_t glGetTexEnvxv; glGetTexParameteriv_client_proc_t glGetTexParameteriv; glGetTexParameterxv_client_proc_t glGetTexParameterxv; glHint_client_proc_t glHint; glIsBuffer_client_proc_t glIsBuffer; glIsEnabled_client_proc_t glIsEnabled; glIsTexture_client_proc_t glIsTexture; glLightModelx_client_proc_t glLightModelx; glLightModelxv_client_proc_t glLightModelxv; glLightx_client_proc_t glLightx; glLightxv_client_proc_t glLightxv; glLineWidthx_client_proc_t glLineWidthx; glLoadIdentity_client_proc_t glLoadIdentity; glLoadMatrixx_client_proc_t glLoadMatrixx; glLogicOp_client_proc_t glLogicOp; glMaterialx_client_proc_t glMaterialx; glMaterialxv_client_proc_t glMaterialxv; glMatrixMode_client_proc_t glMatrixMode; glMultMatrixx_client_proc_t glMultMatrixx; glMultiTexCoord4x_client_proc_t glMultiTexCoord4x; glNormal3x_client_proc_t glNormal3x; glNormalPointer_client_proc_t glNormalPointer; glOrthox_client_proc_t glOrthox; glPixelStorei_client_proc_t glPixelStorei; glPointParameterx_client_proc_t glPointParameterx; glPointParameterxv_client_proc_t glPointParameterxv; glPointSizex_client_proc_t glPointSizex; glPolygonOffsetx_client_proc_t glPolygonOffsetx; glPopMatrix_client_proc_t glPopMatrix; glPushMatrix_client_proc_t glPushMatrix; glReadPixels_client_proc_t glReadPixels; glRotatex_client_proc_t glRotatex; glSampleCoverage_client_proc_t glSampleCoverage; glSampleCoveragex_client_proc_t glSampleCoveragex; glScalex_client_proc_t glScalex; glScissor_client_proc_t glScissor; glShadeModel_client_proc_t glShadeModel; glStencilFunc_client_proc_t glStencilFunc; glStencilMask_client_proc_t glStencilMask; glStencilOp_client_proc_t glStencilOp; glTexCoordPointer_client_proc_t glTexCoordPointer; glTexEnvi_client_proc_t glTexEnvi; glTexEnvx_client_proc_t glTexEnvx; glTexEnviv_client_proc_t glTexEnviv; glTexEnvxv_client_proc_t glTexEnvxv; glTexImage2D_client_proc_t glTexImage2D; glTexParameteri_client_proc_t glTexParameteri; glTexParameterx_client_proc_t glTexParameterx; glTexParameteriv_client_proc_t glTexParameteriv; glTexParameterxv_client_proc_t glTexParameterxv; glTexSubImage2D_client_proc_t glTexSubImage2D; glTranslatex_client_proc_t glTranslatex; glVertexPointer_client_proc_t glVertexPointer; glViewport_client_proc_t glViewport; glPointSizePointerOES_client_proc_t glPointSizePointerOES; glVertexPointerOffset_client_proc_t glVertexPointerOffset; glColorPointerOffset_client_proc_t glColorPointerOffset; glNormalPointerOffset_client_proc_t glNormalPointerOffset; glPointSizePointerOffset_client_proc_t glPointSizePointerOffset; glTexCoordPointerOffset_client_proc_t glTexCoordPointerOffset; glWeightPointerOffset_client_proc_t glWeightPointerOffset; glMatrixIndexPointerOffset_client_proc_t glMatrixIndexPointerOffset; glVertexPointerData_client_proc_t glVertexPointerData; glColorPointerData_client_proc_t glColorPointerData; glNormalPointerData_client_proc_t glNormalPointerData; glTexCoordPointerData_client_proc_t glTexCoordPointerData; glPointSizePointerData_client_proc_t glPointSizePointerData; glWeightPointerData_client_proc_t glWeightPointerData; glMatrixIndexPointerData_client_proc_t glMatrixIndexPointerData; glDrawElementsOffset_client_proc_t glDrawElementsOffset; glDrawElementsData_client_proc_t glDrawElementsData; glGetCompressedTextureFormats_client_proc_t glGetCompressedTextureFormats; glFinishRoundTrip_client_proc_t glFinishRoundTrip; glBlendEquationSeparateOES_client_proc_t glBlendEquationSeparateOES; glBlendFuncSeparateOES_client_proc_t glBlendFuncSeparateOES; glBlendEquationOES_client_proc_t glBlendEquationOES; glDrawTexsOES_client_proc_t glDrawTexsOES; glDrawTexiOES_client_proc_t glDrawTexiOES; glDrawTexxOES_client_proc_t glDrawTexxOES; glDrawTexsvOES_client_proc_t glDrawTexsvOES; glDrawTexivOES_client_proc_t glDrawTexivOES; glDrawTexxvOES_client_proc_t glDrawTexxvOES; glDrawTexfOES_client_proc_t glDrawTexfOES; glDrawTexfvOES_client_proc_t glDrawTexfvOES; glEGLImageTargetTexture2DOES_client_proc_t glEGLImageTargetTexture2DOES; glEGLImageTargetRenderbufferStorageOES_client_proc_t glEGLImageTargetRenderbufferStorageOES; glAlphaFuncxOES_client_proc_t glAlphaFuncxOES; glClearColorxOES_client_proc_t glClearColorxOES; glClearDepthxOES_client_proc_t glClearDepthxOES; glClipPlanexOES_client_proc_t glClipPlanexOES; glClipPlanexIMG_client_proc_t glClipPlanexIMG; glColor4xOES_client_proc_t glColor4xOES; glDepthRangexOES_client_proc_t glDepthRangexOES; glFogxOES_client_proc_t glFogxOES; glFogxvOES_client_proc_t glFogxvOES; glFrustumxOES_client_proc_t glFrustumxOES; glGetClipPlanexOES_client_proc_t glGetClipPlanexOES; glGetClipPlanex_client_proc_t glGetClipPlanex; glGetFixedvOES_client_proc_t glGetFixedvOES; glGetLightxvOES_client_proc_t glGetLightxvOES; glGetMaterialxvOES_client_proc_t glGetMaterialxvOES; glGetTexEnvxvOES_client_proc_t glGetTexEnvxvOES; glGetTexParameterxvOES_client_proc_t glGetTexParameterxvOES; glLightModelxOES_client_proc_t glLightModelxOES; glLightModelxvOES_client_proc_t glLightModelxvOES; glLightxOES_client_proc_t glLightxOES; glLightxvOES_client_proc_t glLightxvOES; glLineWidthxOES_client_proc_t glLineWidthxOES; glLoadMatrixxOES_client_proc_t glLoadMatrixxOES; glMaterialxOES_client_proc_t glMaterialxOES; glMaterialxvOES_client_proc_t glMaterialxvOES; glMultMatrixxOES_client_proc_t glMultMatrixxOES; glMultiTexCoord4xOES_client_proc_t glMultiTexCoord4xOES; glNormal3xOES_client_proc_t glNormal3xOES; glOrthoxOES_client_proc_t glOrthoxOES; glPointParameterxOES_client_proc_t glPointParameterxOES; glPointParameterxvOES_client_proc_t glPointParameterxvOES; glPointSizexOES_client_proc_t glPointSizexOES; glPolygonOffsetxOES_client_proc_t glPolygonOffsetxOES; glRotatexOES_client_proc_t glRotatexOES; glSampleCoveragexOES_client_proc_t glSampleCoveragexOES; glScalexOES_client_proc_t glScalexOES; glTexEnvxOES_client_proc_t glTexEnvxOES; glTexEnvxvOES_client_proc_t glTexEnvxvOES; glTexParameterxOES_client_proc_t glTexParameterxOES; glTexParameterxvOES_client_proc_t glTexParameterxvOES; glTranslatexOES_client_proc_t glTranslatexOES; glIsRenderbufferOES_client_proc_t glIsRenderbufferOES; glBindRenderbufferOES_client_proc_t glBindRenderbufferOES; glDeleteRenderbuffersOES_client_proc_t glDeleteRenderbuffersOES; glGenRenderbuffersOES_client_proc_t glGenRenderbuffersOES; glRenderbufferStorageOES_client_proc_t glRenderbufferStorageOES; glGetRenderbufferParameterivOES_client_proc_t glGetRenderbufferParameterivOES; glIsFramebufferOES_client_proc_t glIsFramebufferOES; glBindFramebufferOES_client_proc_t glBindFramebufferOES; glDeleteFramebuffersOES_client_proc_t glDeleteFramebuffersOES; glGenFramebuffersOES_client_proc_t glGenFramebuffersOES; glCheckFramebufferStatusOES_client_proc_t glCheckFramebufferStatusOES; glFramebufferRenderbufferOES_client_proc_t glFramebufferRenderbufferOES; glFramebufferTexture2DOES_client_proc_t glFramebufferTexture2DOES; glGetFramebufferAttachmentParameterivOES_client_proc_t glGetFramebufferAttachmentParameterivOES; glGenerateMipmapOES_client_proc_t glGenerateMipmapOES; glMapBufferOES_client_proc_t glMapBufferOES; glUnmapBufferOES_client_proc_t glUnmapBufferOES; glGetBufferPointervOES_client_proc_t glGetBufferPointervOES; glCurrentPaletteMatrixOES_client_proc_t glCurrentPaletteMatrixOES; glLoadPaletteFromModelViewMatrixOES_client_proc_t glLoadPaletteFromModelViewMatrixOES; glMatrixIndexPointerOES_client_proc_t glMatrixIndexPointerOES; glWeightPointerOES_client_proc_t glWeightPointerOES; glQueryMatrixxOES_client_proc_t glQueryMatrixxOES; glDepthRangefOES_client_proc_t glDepthRangefOES; glFrustumfOES_client_proc_t glFrustumfOES; glOrthofOES_client_proc_t glOrthofOES; glClipPlanefOES_client_proc_t glClipPlanefOES; glClipPlanefIMG_client_proc_t glClipPlanefIMG; glGetClipPlanefOES_client_proc_t glGetClipPlanefOES; glClearDepthfOES_client_proc_t glClearDepthfOES; glTexGenfOES_client_proc_t glTexGenfOES; glTexGenfvOES_client_proc_t glTexGenfvOES; glTexGeniOES_client_proc_t glTexGeniOES; glTexGenivOES_client_proc_t glTexGenivOES; glTexGenxOES_client_proc_t glTexGenxOES; glTexGenxvOES_client_proc_t glTexGenxvOES; glGetTexGenfvOES_client_proc_t glGetTexGenfvOES; glGetTexGenivOES_client_proc_t glGetTexGenivOES; glGetTexGenxvOES_client_proc_t glGetTexGenxvOES; glBindVertexArrayOES_client_proc_t glBindVertexArrayOES; glDeleteVertexArraysOES_client_proc_t glDeleteVertexArraysOES; glGenVertexArraysOES_client_proc_t glGenVertexArraysOES; glIsVertexArrayOES_client_proc_t glIsVertexArrayOES; glDiscardFramebufferEXT_client_proc_t glDiscardFramebufferEXT; glMultiDrawArraysEXT_client_proc_t glMultiDrawArraysEXT; glMultiDrawElementsEXT_client_proc_t glMultiDrawElementsEXT; glMultiDrawArraysSUN_client_proc_t glMultiDrawArraysSUN; glMultiDrawElementsSUN_client_proc_t glMultiDrawElementsSUN; glRenderbufferStorageMultisampleIMG_client_proc_t glRenderbufferStorageMultisampleIMG; glFramebufferTexture2DMultisampleIMG_client_proc_t glFramebufferTexture2DMultisampleIMG; glDeleteFencesNV_client_proc_t glDeleteFencesNV; glGenFencesNV_client_proc_t glGenFencesNV; glIsFenceNV_client_proc_t glIsFenceNV; glTestFenceNV_client_proc_t glTestFenceNV; glGetFenceivNV_client_proc_t glGetFenceivNV; glFinishFenceNV_client_proc_t glFinishFenceNV; glSetFenceNV_client_proc_t glSetFenceNV; glGetDriverControlsQCOM_client_proc_t glGetDriverControlsQCOM; glGetDriverControlStringQCOM_client_proc_t glGetDriverControlStringQCOM; glEnableDriverControlQCOM_client_proc_t glEnableDriverControlQCOM; glDisableDriverControlQCOM_client_proc_t glDisableDriverControlQCOM; glExtGetTexturesQCOM_client_proc_t glExtGetTexturesQCOM; glExtGetBuffersQCOM_client_proc_t glExtGetBuffersQCOM; glExtGetRenderbuffersQCOM_client_proc_t glExtGetRenderbuffersQCOM; glExtGetFramebuffersQCOM_client_proc_t glExtGetFramebuffersQCOM; glExtGetTexLevelParameterivQCOM_client_proc_t glExtGetTexLevelParameterivQCOM; glExtTexObjectStateOverrideiQCOM_client_proc_t glExtTexObjectStateOverrideiQCOM; glExtGetTexSubImageQCOM_client_proc_t glExtGetTexSubImageQCOM; glExtGetBufferPointervQCOM_client_proc_t glExtGetBufferPointervQCOM; glExtGetShadersQCOM_client_proc_t glExtGetShadersQCOM; glExtGetProgramsQCOM_client_proc_t glExtGetProgramsQCOM; glExtIsProgramBinaryQCOM_client_proc_t glExtIsProgramBinaryQCOM; glExtGetProgramBinarySourceQCOM_client_proc_t glExtGetProgramBinarySourceQCOM; glStartTilingQCOM_client_proc_t glStartTilingQCOM; glEndTilingQCOM_client_proc_t glEndTilingQCOM; virtual ~gl_client_context_t() {} typedef gl_client_context_t *CONTEXT_ACCESSOR_TYPE(void); static void setContextAccessor(CONTEXT_ACCESSOR_TYPE *f); int initDispatchByName( void *(*getProc)(const char *name, void *userData), void *userData); virtual void setError(unsigned int error){ (void)error; }; virtual unsigned int getError(){ return 0; }; }; #endif anbox-0.0~git20191115/android/opengl/system/GLESv1_enc/gl_client_proc.h000066400000000000000000000702361356361734700254470ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef __gl_client_proc_t_h #define __gl_client_proc_t_h #include "gl_types.h" #ifndef gl_APIENTRY #define gl_APIENTRY #endif typedef void (gl_APIENTRY *glAlphaFunc_client_proc_t) (void * ctx, GLenum, GLclampf); typedef void (gl_APIENTRY *glClearColor_client_proc_t) (void * ctx, GLclampf, GLclampf, GLclampf, GLclampf); typedef void (gl_APIENTRY *glClearDepthf_client_proc_t) (void * ctx, GLclampf); typedef void (gl_APIENTRY *glClipPlanef_client_proc_t) (void * ctx, GLenum, const GLfloat*); typedef void (gl_APIENTRY *glColor4f_client_proc_t) (void * ctx, GLfloat, GLfloat, GLfloat, GLfloat); typedef void (gl_APIENTRY *glDepthRangef_client_proc_t) (void * ctx, GLclampf, GLclampf); typedef void (gl_APIENTRY *glFogf_client_proc_t) (void * ctx, GLenum, GLfloat); typedef void (gl_APIENTRY *glFogfv_client_proc_t) (void * ctx, GLenum, const GLfloat*); typedef void (gl_APIENTRY *glFrustumf_client_proc_t) (void * ctx, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); typedef void (gl_APIENTRY *glGetClipPlanef_client_proc_t) (void * ctx, GLenum, GLfloat*); typedef void (gl_APIENTRY *glGetFloatv_client_proc_t) (void * ctx, GLenum, GLfloat*); typedef void (gl_APIENTRY *glGetLightfv_client_proc_t) (void * ctx, GLenum, GLenum, GLfloat*); typedef void (gl_APIENTRY *glGetMaterialfv_client_proc_t) (void * ctx, GLenum, GLenum, GLfloat*); typedef void (gl_APIENTRY *glGetTexEnvfv_client_proc_t) (void * ctx, GLenum, GLenum, GLfloat*); typedef void (gl_APIENTRY *glGetTexParameterfv_client_proc_t) (void * ctx, GLenum, GLenum, GLfloat*); typedef void (gl_APIENTRY *glLightModelf_client_proc_t) (void * ctx, GLenum, GLfloat); typedef void (gl_APIENTRY *glLightModelfv_client_proc_t) (void * ctx, GLenum, const GLfloat*); typedef void (gl_APIENTRY *glLightf_client_proc_t) (void * ctx, GLenum, GLenum, GLfloat); typedef void (gl_APIENTRY *glLightfv_client_proc_t) (void * ctx, GLenum, GLenum, const GLfloat*); typedef void (gl_APIENTRY *glLineWidth_client_proc_t) (void * ctx, GLfloat); typedef void (gl_APIENTRY *glLoadMatrixf_client_proc_t) (void * ctx, const GLfloat*); typedef void (gl_APIENTRY *glMaterialf_client_proc_t) (void * ctx, GLenum, GLenum, GLfloat); typedef void (gl_APIENTRY *glMaterialfv_client_proc_t) (void * ctx, GLenum, GLenum, const GLfloat*); typedef void (gl_APIENTRY *glMultMatrixf_client_proc_t) (void * ctx, const GLfloat*); typedef void (gl_APIENTRY *glMultiTexCoord4f_client_proc_t) (void * ctx, GLenum, GLfloat, GLfloat, GLfloat, GLfloat); typedef void (gl_APIENTRY *glNormal3f_client_proc_t) (void * ctx, GLfloat, GLfloat, GLfloat); typedef void (gl_APIENTRY *glOrthof_client_proc_t) (void * ctx, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); typedef void (gl_APIENTRY *glPointParameterf_client_proc_t) (void * ctx, GLenum, GLfloat); typedef void (gl_APIENTRY *glPointParameterfv_client_proc_t) (void * ctx, GLenum, const GLfloat*); typedef void (gl_APIENTRY *glPointSize_client_proc_t) (void * ctx, GLfloat); typedef void (gl_APIENTRY *glPolygonOffset_client_proc_t) (void * ctx, GLfloat, GLfloat); typedef void (gl_APIENTRY *glRotatef_client_proc_t) (void * ctx, GLfloat, GLfloat, GLfloat, GLfloat); typedef void (gl_APIENTRY *glScalef_client_proc_t) (void * ctx, GLfloat, GLfloat, GLfloat); typedef void (gl_APIENTRY *glTexEnvf_client_proc_t) (void * ctx, GLenum, GLenum, GLfloat); typedef void (gl_APIENTRY *glTexEnvfv_client_proc_t) (void * ctx, GLenum, GLenum, const GLfloat*); typedef void (gl_APIENTRY *glTexParameterf_client_proc_t) (void * ctx, GLenum, GLenum, GLfloat); typedef void (gl_APIENTRY *glTexParameterfv_client_proc_t) (void * ctx, GLenum, GLenum, const GLfloat*); typedef void (gl_APIENTRY *glTranslatef_client_proc_t) (void * ctx, GLfloat, GLfloat, GLfloat); typedef void (gl_APIENTRY *glActiveTexture_client_proc_t) (void * ctx, GLenum); typedef void (gl_APIENTRY *glAlphaFuncx_client_proc_t) (void * ctx, GLenum, GLclampx); typedef void (gl_APIENTRY *glBindBuffer_client_proc_t) (void * ctx, GLenum, GLuint); typedef void (gl_APIENTRY *glBindTexture_client_proc_t) (void * ctx, GLenum, GLuint); typedef void (gl_APIENTRY *glBlendFunc_client_proc_t) (void * ctx, GLenum, GLenum); typedef void (gl_APIENTRY *glBufferData_client_proc_t) (void * ctx, GLenum, GLsizeiptr, const GLvoid*, GLenum); typedef void (gl_APIENTRY *glBufferSubData_client_proc_t) (void * ctx, GLenum, GLintptr, GLsizeiptr, const GLvoid*); typedef void (gl_APIENTRY *glClear_client_proc_t) (void * ctx, GLbitfield); typedef void (gl_APIENTRY *glClearColorx_client_proc_t) (void * ctx, GLclampx, GLclampx, GLclampx, GLclampx); typedef void (gl_APIENTRY *glClearDepthx_client_proc_t) (void * ctx, GLclampx); typedef void (gl_APIENTRY *glClearStencil_client_proc_t) (void * ctx, GLint); typedef void (gl_APIENTRY *glClientActiveTexture_client_proc_t) (void * ctx, GLenum); typedef void (gl_APIENTRY *glColor4ub_client_proc_t) (void * ctx, GLubyte, GLubyte, GLubyte, GLubyte); typedef void (gl_APIENTRY *glColor4x_client_proc_t) (void * ctx, GLfixed, GLfixed, GLfixed, GLfixed); typedef void (gl_APIENTRY *glColorMask_client_proc_t) (void * ctx, GLboolean, GLboolean, GLboolean, GLboolean); typedef void (gl_APIENTRY *glColorPointer_client_proc_t) (void * ctx, GLint, GLenum, GLsizei, const GLvoid*); typedef void (gl_APIENTRY *glCompressedTexImage2D_client_proc_t) (void * ctx, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid*); typedef void (gl_APIENTRY *glCompressedTexSubImage2D_client_proc_t) (void * ctx, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid*); typedef void (gl_APIENTRY *glCopyTexImage2D_client_proc_t) (void * ctx, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint); typedef void (gl_APIENTRY *glCopyTexSubImage2D_client_proc_t) (void * ctx, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei); typedef void (gl_APIENTRY *glCullFace_client_proc_t) (void * ctx, GLenum); typedef void (gl_APIENTRY *glDeleteBuffers_client_proc_t) (void * ctx, GLsizei, const GLuint*); typedef void (gl_APIENTRY *glDeleteTextures_client_proc_t) (void * ctx, GLsizei, const GLuint*); typedef void (gl_APIENTRY *glDepthFunc_client_proc_t) (void * ctx, GLenum); typedef void (gl_APIENTRY *glDepthMask_client_proc_t) (void * ctx, GLboolean); typedef void (gl_APIENTRY *glDepthRangex_client_proc_t) (void * ctx, GLclampx, GLclampx); typedef void (gl_APIENTRY *glDisable_client_proc_t) (void * ctx, GLenum); typedef void (gl_APIENTRY *glDisableClientState_client_proc_t) (void * ctx, GLenum); typedef void (gl_APIENTRY *glDrawArrays_client_proc_t) (void * ctx, GLenum, GLint, GLsizei); typedef void (gl_APIENTRY *glDrawElements_client_proc_t) (void * ctx, GLenum, GLsizei, GLenum, const GLvoid*); typedef void (gl_APIENTRY *glEnable_client_proc_t) (void * ctx, GLenum); typedef void (gl_APIENTRY *glEnableClientState_client_proc_t) (void * ctx, GLenum); typedef void (gl_APIENTRY *glFinish_client_proc_t) (void * ctx); typedef void (gl_APIENTRY *glFlush_client_proc_t) (void * ctx); typedef void (gl_APIENTRY *glFogx_client_proc_t) (void * ctx, GLenum, GLfixed); typedef void (gl_APIENTRY *glFogxv_client_proc_t) (void * ctx, GLenum, const GLfixed*); typedef void (gl_APIENTRY *glFrontFace_client_proc_t) (void * ctx, GLenum); typedef void (gl_APIENTRY *glFrustumx_client_proc_t) (void * ctx, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed); typedef void (gl_APIENTRY *glGetBooleanv_client_proc_t) (void * ctx, GLenum, GLboolean*); typedef void (gl_APIENTRY *glGetBufferParameteriv_client_proc_t) (void * ctx, GLenum, GLenum, GLint*); typedef void (gl_APIENTRY *glClipPlanex_client_proc_t) (void * ctx, GLenum, const GLfixed*); typedef void (gl_APIENTRY *glGenBuffers_client_proc_t) (void * ctx, GLsizei, GLuint*); typedef void (gl_APIENTRY *glGenTextures_client_proc_t) (void * ctx, GLsizei, GLuint*); typedef GLenum (gl_APIENTRY *glGetError_client_proc_t) (void * ctx); typedef void (gl_APIENTRY *glGetFixedv_client_proc_t) (void * ctx, GLenum, GLfixed*); typedef void (gl_APIENTRY *glGetIntegerv_client_proc_t) (void * ctx, GLenum, GLint*); typedef void (gl_APIENTRY *glGetLightxv_client_proc_t) (void * ctx, GLenum, GLenum, GLfixed*); typedef void (gl_APIENTRY *glGetMaterialxv_client_proc_t) (void * ctx, GLenum, GLenum, GLfixed*); typedef void (gl_APIENTRY *glGetPointerv_client_proc_t) (void * ctx, GLenum, GLvoid**); typedef const GLubyte* (gl_APIENTRY *glGetString_client_proc_t) (void * ctx, GLenum); typedef void (gl_APIENTRY *glGetTexEnviv_client_proc_t) (void * ctx, GLenum, GLenum, GLint*); typedef void (gl_APIENTRY *glGetTexEnvxv_client_proc_t) (void * ctx, GLenum, GLenum, GLfixed*); typedef void (gl_APIENTRY *glGetTexParameteriv_client_proc_t) (void * ctx, GLenum, GLenum, GLint*); typedef void (gl_APIENTRY *glGetTexParameterxv_client_proc_t) (void * ctx, GLenum, GLenum, GLfixed*); typedef void (gl_APIENTRY *glHint_client_proc_t) (void * ctx, GLenum, GLenum); typedef GLboolean (gl_APIENTRY *glIsBuffer_client_proc_t) (void * ctx, GLuint); typedef GLboolean (gl_APIENTRY *glIsEnabled_client_proc_t) (void * ctx, GLenum); typedef GLboolean (gl_APIENTRY *glIsTexture_client_proc_t) (void * ctx, GLuint); typedef void (gl_APIENTRY *glLightModelx_client_proc_t) (void * ctx, GLenum, GLfixed); typedef void (gl_APIENTRY *glLightModelxv_client_proc_t) (void * ctx, GLenum, const GLfixed*); typedef void (gl_APIENTRY *glLightx_client_proc_t) (void * ctx, GLenum, GLenum, GLfixed); typedef void (gl_APIENTRY *glLightxv_client_proc_t) (void * ctx, GLenum, GLenum, const GLfixed*); typedef void (gl_APIENTRY *glLineWidthx_client_proc_t) (void * ctx, GLfixed); typedef void (gl_APIENTRY *glLoadIdentity_client_proc_t) (void * ctx); typedef void (gl_APIENTRY *glLoadMatrixx_client_proc_t) (void * ctx, const GLfixed*); typedef void (gl_APIENTRY *glLogicOp_client_proc_t) (void * ctx, GLenum); typedef void (gl_APIENTRY *glMaterialx_client_proc_t) (void * ctx, GLenum, GLenum, GLfixed); typedef void (gl_APIENTRY *glMaterialxv_client_proc_t) (void * ctx, GLenum, GLenum, const GLfixed*); typedef void (gl_APIENTRY *glMatrixMode_client_proc_t) (void * ctx, GLenum); typedef void (gl_APIENTRY *glMultMatrixx_client_proc_t) (void * ctx, const GLfixed*); typedef void (gl_APIENTRY *glMultiTexCoord4x_client_proc_t) (void * ctx, GLenum, GLfixed, GLfixed, GLfixed, GLfixed); typedef void (gl_APIENTRY *glNormal3x_client_proc_t) (void * ctx, GLfixed, GLfixed, GLfixed); typedef void (gl_APIENTRY *glNormalPointer_client_proc_t) (void * ctx, GLenum, GLsizei, const GLvoid*); typedef void (gl_APIENTRY *glOrthox_client_proc_t) (void * ctx, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed); typedef void (gl_APIENTRY *glPixelStorei_client_proc_t) (void * ctx, GLenum, GLint); typedef void (gl_APIENTRY *glPointParameterx_client_proc_t) (void * ctx, GLenum, GLfixed); typedef void (gl_APIENTRY *glPointParameterxv_client_proc_t) (void * ctx, GLenum, const GLfixed*); typedef void (gl_APIENTRY *glPointSizex_client_proc_t) (void * ctx, GLfixed); typedef void (gl_APIENTRY *glPolygonOffsetx_client_proc_t) (void * ctx, GLfixed, GLfixed); typedef void (gl_APIENTRY *glPopMatrix_client_proc_t) (void * ctx); typedef void (gl_APIENTRY *glPushMatrix_client_proc_t) (void * ctx); typedef void (gl_APIENTRY *glReadPixels_client_proc_t) (void * ctx, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid*); typedef void (gl_APIENTRY *glRotatex_client_proc_t) (void * ctx, GLfixed, GLfixed, GLfixed, GLfixed); typedef void (gl_APIENTRY *glSampleCoverage_client_proc_t) (void * ctx, GLclampf, GLboolean); typedef void (gl_APIENTRY *glSampleCoveragex_client_proc_t) (void * ctx, GLclampx, GLboolean); typedef void (gl_APIENTRY *glScalex_client_proc_t) (void * ctx, GLfixed, GLfixed, GLfixed); typedef void (gl_APIENTRY *glScissor_client_proc_t) (void * ctx, GLint, GLint, GLsizei, GLsizei); typedef void (gl_APIENTRY *glShadeModel_client_proc_t) (void * ctx, GLenum); typedef void (gl_APIENTRY *glStencilFunc_client_proc_t) (void * ctx, GLenum, GLint, GLuint); typedef void (gl_APIENTRY *glStencilMask_client_proc_t) (void * ctx, GLuint); typedef void (gl_APIENTRY *glStencilOp_client_proc_t) (void * ctx, GLenum, GLenum, GLenum); typedef void (gl_APIENTRY *glTexCoordPointer_client_proc_t) (void * ctx, GLint, GLenum, GLsizei, const GLvoid*); typedef void (gl_APIENTRY *glTexEnvi_client_proc_t) (void * ctx, GLenum, GLenum, GLint); typedef void (gl_APIENTRY *glTexEnvx_client_proc_t) (void * ctx, GLenum, GLenum, GLfixed); typedef void (gl_APIENTRY *glTexEnviv_client_proc_t) (void * ctx, GLenum, GLenum, const GLint*); typedef void (gl_APIENTRY *glTexEnvxv_client_proc_t) (void * ctx, GLenum, GLenum, const GLfixed*); typedef void (gl_APIENTRY *glTexImage2D_client_proc_t) (void * ctx, GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid*); typedef void (gl_APIENTRY *glTexParameteri_client_proc_t) (void * ctx, GLenum, GLenum, GLint); typedef void (gl_APIENTRY *glTexParameterx_client_proc_t) (void * ctx, GLenum, GLenum, GLfixed); typedef void (gl_APIENTRY *glTexParameteriv_client_proc_t) (void * ctx, GLenum, GLenum, const GLint*); typedef void (gl_APIENTRY *glTexParameterxv_client_proc_t) (void * ctx, GLenum, GLenum, const GLfixed*); typedef void (gl_APIENTRY *glTexSubImage2D_client_proc_t) (void * ctx, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid*); typedef void (gl_APIENTRY *glTranslatex_client_proc_t) (void * ctx, GLfixed, GLfixed, GLfixed); typedef void (gl_APIENTRY *glVertexPointer_client_proc_t) (void * ctx, GLint, GLenum, GLsizei, const GLvoid*); typedef void (gl_APIENTRY *glViewport_client_proc_t) (void * ctx, GLint, GLint, GLsizei, GLsizei); typedef void (gl_APIENTRY *glPointSizePointerOES_client_proc_t) (void * ctx, GLenum, GLsizei, const GLvoid*); typedef void (gl_APIENTRY *glVertexPointerOffset_client_proc_t) (void * ctx, GLint, GLenum, GLsizei, GLuint); typedef void (gl_APIENTRY *glColorPointerOffset_client_proc_t) (void * ctx, GLint, GLenum, GLsizei, GLuint); typedef void (gl_APIENTRY *glNormalPointerOffset_client_proc_t) (void * ctx, GLenum, GLsizei, GLuint); typedef void (gl_APIENTRY *glPointSizePointerOffset_client_proc_t) (void * ctx, GLenum, GLsizei, GLuint); typedef void (gl_APIENTRY *glTexCoordPointerOffset_client_proc_t) (void * ctx, GLint, GLenum, GLsizei, GLuint); typedef void (gl_APIENTRY *glWeightPointerOffset_client_proc_t) (void * ctx, GLint, GLenum, GLsizei, GLuint); typedef void (gl_APIENTRY *glMatrixIndexPointerOffset_client_proc_t) (void * ctx, GLint, GLenum, GLsizei, GLuint); typedef void (gl_APIENTRY *glVertexPointerData_client_proc_t) (void * ctx, GLint, GLenum, GLsizei, void*, GLuint); typedef void (gl_APIENTRY *glColorPointerData_client_proc_t) (void * ctx, GLint, GLenum, GLsizei, void*, GLuint); typedef void (gl_APIENTRY *glNormalPointerData_client_proc_t) (void * ctx, GLenum, GLsizei, void*, GLuint); typedef void (gl_APIENTRY *glTexCoordPointerData_client_proc_t) (void * ctx, GLint, GLint, GLenum, GLsizei, void*, GLuint); typedef void (gl_APIENTRY *glPointSizePointerData_client_proc_t) (void * ctx, GLenum, GLsizei, void*, GLuint); typedef void (gl_APIENTRY *glWeightPointerData_client_proc_t) (void * ctx, GLint, GLenum, GLsizei, void*, GLuint); typedef void (gl_APIENTRY *glMatrixIndexPointerData_client_proc_t) (void * ctx, GLint, GLenum, GLsizei, void*, GLuint); typedef void (gl_APIENTRY *glDrawElementsOffset_client_proc_t) (void * ctx, GLenum, GLsizei, GLenum, GLuint); typedef void (gl_APIENTRY *glDrawElementsData_client_proc_t) (void * ctx, GLenum, GLsizei, GLenum, void*, GLuint); typedef void (gl_APIENTRY *glGetCompressedTextureFormats_client_proc_t) (void * ctx, int, GLint*); typedef int (gl_APIENTRY *glFinishRoundTrip_client_proc_t) (void * ctx); typedef void (gl_APIENTRY *glBlendEquationSeparateOES_client_proc_t) (void * ctx, GLenum, GLenum); typedef void (gl_APIENTRY *glBlendFuncSeparateOES_client_proc_t) (void * ctx, GLenum, GLenum, GLenum, GLenum); typedef void (gl_APIENTRY *glBlendEquationOES_client_proc_t) (void * ctx, GLenum); typedef void (gl_APIENTRY *glDrawTexsOES_client_proc_t) (void * ctx, GLshort, GLshort, GLshort, GLshort, GLshort); typedef void (gl_APIENTRY *glDrawTexiOES_client_proc_t) (void * ctx, GLint, GLint, GLint, GLint, GLint); typedef void (gl_APIENTRY *glDrawTexxOES_client_proc_t) (void * ctx, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed); typedef void (gl_APIENTRY *glDrawTexsvOES_client_proc_t) (void * ctx, const GLshort*); typedef void (gl_APIENTRY *glDrawTexivOES_client_proc_t) (void * ctx, const GLint*); typedef void (gl_APIENTRY *glDrawTexxvOES_client_proc_t) (void * ctx, const GLfixed*); typedef void (gl_APIENTRY *glDrawTexfOES_client_proc_t) (void * ctx, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); typedef void (gl_APIENTRY *glDrawTexfvOES_client_proc_t) (void * ctx, const GLfloat*); typedef void (gl_APIENTRY *glEGLImageTargetTexture2DOES_client_proc_t) (void * ctx, GLenum, GLeglImageOES); typedef void (gl_APIENTRY *glEGLImageTargetRenderbufferStorageOES_client_proc_t) (void * ctx, GLenum, GLeglImageOES); typedef void (gl_APIENTRY *glAlphaFuncxOES_client_proc_t) (void * ctx, GLenum, GLclampx); typedef void (gl_APIENTRY *glClearColorxOES_client_proc_t) (void * ctx, GLclampx, GLclampx, GLclampx, GLclampx); typedef void (gl_APIENTRY *glClearDepthxOES_client_proc_t) (void * ctx, GLclampx); typedef void (gl_APIENTRY *glClipPlanexOES_client_proc_t) (void * ctx, GLenum, const GLfixed*); typedef void (gl_APIENTRY *glClipPlanexIMG_client_proc_t) (void * ctx, GLenum, const GLfixed*); typedef void (gl_APIENTRY *glColor4xOES_client_proc_t) (void * ctx, GLfixed, GLfixed, GLfixed, GLfixed); typedef void (gl_APIENTRY *glDepthRangexOES_client_proc_t) (void * ctx, GLclampx, GLclampx); typedef void (gl_APIENTRY *glFogxOES_client_proc_t) (void * ctx, GLenum, GLfixed); typedef void (gl_APIENTRY *glFogxvOES_client_proc_t) (void * ctx, GLenum, const GLfixed*); typedef void (gl_APIENTRY *glFrustumxOES_client_proc_t) (void * ctx, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed); typedef void (gl_APIENTRY *glGetClipPlanexOES_client_proc_t) (void * ctx, GLenum, GLfixed*); typedef void (gl_APIENTRY *glGetClipPlanex_client_proc_t) (void * ctx, GLenum, GLfixed*); typedef void (gl_APIENTRY *glGetFixedvOES_client_proc_t) (void * ctx, GLenum, GLfixed*); typedef void (gl_APIENTRY *glGetLightxvOES_client_proc_t) (void * ctx, GLenum, GLenum, GLfixed*); typedef void (gl_APIENTRY *glGetMaterialxvOES_client_proc_t) (void * ctx, GLenum, GLenum, GLfixed*); typedef void (gl_APIENTRY *glGetTexEnvxvOES_client_proc_t) (void * ctx, GLenum, GLenum, GLfixed*); typedef void (gl_APIENTRY *glGetTexParameterxvOES_client_proc_t) (void * ctx, GLenum, GLenum, GLfixed*); typedef void (gl_APIENTRY *glLightModelxOES_client_proc_t) (void * ctx, GLenum, GLfixed); typedef void (gl_APIENTRY *glLightModelxvOES_client_proc_t) (void * ctx, GLenum, const GLfixed*); typedef void (gl_APIENTRY *glLightxOES_client_proc_t) (void * ctx, GLenum, GLenum, GLfixed); typedef void (gl_APIENTRY *glLightxvOES_client_proc_t) (void * ctx, GLenum, GLenum, const GLfixed*); typedef void (gl_APIENTRY *glLineWidthxOES_client_proc_t) (void * ctx, GLfixed); typedef void (gl_APIENTRY *glLoadMatrixxOES_client_proc_t) (void * ctx, const GLfixed*); typedef void (gl_APIENTRY *glMaterialxOES_client_proc_t) (void * ctx, GLenum, GLenum, GLfixed); typedef void (gl_APIENTRY *glMaterialxvOES_client_proc_t) (void * ctx, GLenum, GLenum, const GLfixed*); typedef void (gl_APIENTRY *glMultMatrixxOES_client_proc_t) (void * ctx, const GLfixed*); typedef void (gl_APIENTRY *glMultiTexCoord4xOES_client_proc_t) (void * ctx, GLenum, GLfixed, GLfixed, GLfixed, GLfixed); typedef void (gl_APIENTRY *glNormal3xOES_client_proc_t) (void * ctx, GLfixed, GLfixed, GLfixed); typedef void (gl_APIENTRY *glOrthoxOES_client_proc_t) (void * ctx, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed); typedef void (gl_APIENTRY *glPointParameterxOES_client_proc_t) (void * ctx, GLenum, GLfixed); typedef void (gl_APIENTRY *glPointParameterxvOES_client_proc_t) (void * ctx, GLenum, const GLfixed*); typedef void (gl_APIENTRY *glPointSizexOES_client_proc_t) (void * ctx, GLfixed); typedef void (gl_APIENTRY *glPolygonOffsetxOES_client_proc_t) (void * ctx, GLfixed, GLfixed); typedef void (gl_APIENTRY *glRotatexOES_client_proc_t) (void * ctx, GLfixed, GLfixed, GLfixed, GLfixed); typedef void (gl_APIENTRY *glSampleCoveragexOES_client_proc_t) (void * ctx, GLclampx, GLboolean); typedef void (gl_APIENTRY *glScalexOES_client_proc_t) (void * ctx, GLfixed, GLfixed, GLfixed); typedef void (gl_APIENTRY *glTexEnvxOES_client_proc_t) (void * ctx, GLenum, GLenum, GLfixed); typedef void (gl_APIENTRY *glTexEnvxvOES_client_proc_t) (void * ctx, GLenum, GLenum, const GLfixed*); typedef void (gl_APIENTRY *glTexParameterxOES_client_proc_t) (void * ctx, GLenum, GLenum, GLfixed); typedef void (gl_APIENTRY *glTexParameterxvOES_client_proc_t) (void * ctx, GLenum, GLenum, const GLfixed*); typedef void (gl_APIENTRY *glTranslatexOES_client_proc_t) (void * ctx, GLfixed, GLfixed, GLfixed); typedef GLboolean (gl_APIENTRY *glIsRenderbufferOES_client_proc_t) (void * ctx, GLuint); typedef void (gl_APIENTRY *glBindRenderbufferOES_client_proc_t) (void * ctx, GLenum, GLuint); typedef void (gl_APIENTRY *glDeleteRenderbuffersOES_client_proc_t) (void * ctx, GLsizei, const GLuint*); typedef void (gl_APIENTRY *glGenRenderbuffersOES_client_proc_t) (void * ctx, GLsizei, GLuint*); typedef void (gl_APIENTRY *glRenderbufferStorageOES_client_proc_t) (void * ctx, GLenum, GLenum, GLsizei, GLsizei); typedef void (gl_APIENTRY *glGetRenderbufferParameterivOES_client_proc_t) (void * ctx, GLenum, GLenum, GLint*); typedef GLboolean (gl_APIENTRY *glIsFramebufferOES_client_proc_t) (void * ctx, GLuint); typedef void (gl_APIENTRY *glBindFramebufferOES_client_proc_t) (void * ctx, GLenum, GLuint); typedef void (gl_APIENTRY *glDeleteFramebuffersOES_client_proc_t) (void * ctx, GLsizei, const GLuint*); typedef void (gl_APIENTRY *glGenFramebuffersOES_client_proc_t) (void * ctx, GLsizei, GLuint*); typedef GLenum (gl_APIENTRY *glCheckFramebufferStatusOES_client_proc_t) (void * ctx, GLenum); typedef void (gl_APIENTRY *glFramebufferRenderbufferOES_client_proc_t) (void * ctx, GLenum, GLenum, GLenum, GLuint); typedef void (gl_APIENTRY *glFramebufferTexture2DOES_client_proc_t) (void * ctx, GLenum, GLenum, GLenum, GLuint, GLint); typedef void (gl_APIENTRY *glGetFramebufferAttachmentParameterivOES_client_proc_t) (void * ctx, GLenum, GLenum, GLenum, GLint*); typedef void (gl_APIENTRY *glGenerateMipmapOES_client_proc_t) (void * ctx, GLenum); typedef void* (gl_APIENTRY *glMapBufferOES_client_proc_t) (void * ctx, GLenum, GLenum); typedef GLboolean (gl_APIENTRY *glUnmapBufferOES_client_proc_t) (void * ctx, GLenum); typedef void (gl_APIENTRY *glGetBufferPointervOES_client_proc_t) (void * ctx, GLenum, GLenum, GLvoid**); typedef void (gl_APIENTRY *glCurrentPaletteMatrixOES_client_proc_t) (void * ctx, GLuint); typedef void (gl_APIENTRY *glLoadPaletteFromModelViewMatrixOES_client_proc_t) (void * ctx); typedef void (gl_APIENTRY *glMatrixIndexPointerOES_client_proc_t) (void * ctx, GLint, GLenum, GLsizei, const GLvoid*); typedef void (gl_APIENTRY *glWeightPointerOES_client_proc_t) (void * ctx, GLint, GLenum, GLsizei, const GLvoid*); typedef GLbitfield (gl_APIENTRY *glQueryMatrixxOES_client_proc_t) (void * ctx, GLfixed*, GLint*); typedef void (gl_APIENTRY *glDepthRangefOES_client_proc_t) (void * ctx, GLclampf, GLclampf); typedef void (gl_APIENTRY *glFrustumfOES_client_proc_t) (void * ctx, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); typedef void (gl_APIENTRY *glOrthofOES_client_proc_t) (void * ctx, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); typedef void (gl_APIENTRY *glClipPlanefOES_client_proc_t) (void * ctx, GLenum, const GLfloat*); typedef void (gl_APIENTRY *glClipPlanefIMG_client_proc_t) (void * ctx, GLenum, const GLfloat*); typedef void (gl_APIENTRY *glGetClipPlanefOES_client_proc_t) (void * ctx, GLenum, GLfloat*); typedef void (gl_APIENTRY *glClearDepthfOES_client_proc_t) (void * ctx, GLclampf); typedef void (gl_APIENTRY *glTexGenfOES_client_proc_t) (void * ctx, GLenum, GLenum, GLfloat); typedef void (gl_APIENTRY *glTexGenfvOES_client_proc_t) (void * ctx, GLenum, GLenum, const GLfloat*); typedef void (gl_APIENTRY *glTexGeniOES_client_proc_t) (void * ctx, GLenum, GLenum, GLint); typedef void (gl_APIENTRY *glTexGenivOES_client_proc_t) (void * ctx, GLenum, GLenum, const GLint*); typedef void (gl_APIENTRY *glTexGenxOES_client_proc_t) (void * ctx, GLenum, GLenum, GLfixed); typedef void (gl_APIENTRY *glTexGenxvOES_client_proc_t) (void * ctx, GLenum, GLenum, const GLfixed*); typedef void (gl_APIENTRY *glGetTexGenfvOES_client_proc_t) (void * ctx, GLenum, GLenum, GLfloat*); typedef void (gl_APIENTRY *glGetTexGenivOES_client_proc_t) (void * ctx, GLenum, GLenum, GLint*); typedef void (gl_APIENTRY *glGetTexGenxvOES_client_proc_t) (void * ctx, GLenum, GLenum, GLfixed*); typedef void (gl_APIENTRY *glBindVertexArrayOES_client_proc_t) (void * ctx, GLuint); typedef void (gl_APIENTRY *glDeleteVertexArraysOES_client_proc_t) (void * ctx, GLsizei, const GLuint*); typedef void (gl_APIENTRY *glGenVertexArraysOES_client_proc_t) (void * ctx, GLsizei, GLuint*); typedef GLboolean (gl_APIENTRY *glIsVertexArrayOES_client_proc_t) (void * ctx, GLuint); typedef void (gl_APIENTRY *glDiscardFramebufferEXT_client_proc_t) (void * ctx, GLenum, GLsizei, const GLenum*); typedef void (gl_APIENTRY *glMultiDrawArraysEXT_client_proc_t) (void * ctx, GLenum, const GLint*, const GLsizei*, GLsizei); typedef void (gl_APIENTRY *glMultiDrawElementsEXT_client_proc_t) (void * ctx, GLenum, const GLsizei*, GLenum, const GLvoid* const*, GLsizei); typedef void (gl_APIENTRY *glMultiDrawArraysSUN_client_proc_t) (void * ctx, GLenum, GLint*, GLsizei*, GLsizei); typedef void (gl_APIENTRY *glMultiDrawElementsSUN_client_proc_t) (void * ctx, GLenum, const GLsizei*, GLenum, const GLvoid**, GLsizei); typedef void (gl_APIENTRY *glRenderbufferStorageMultisampleIMG_client_proc_t) (void * ctx, GLenum, GLsizei, GLenum, GLsizei, GLsizei); typedef void (gl_APIENTRY *glFramebufferTexture2DMultisampleIMG_client_proc_t) (void * ctx, GLenum, GLenum, GLenum, GLuint, GLint, GLsizei); typedef void (gl_APIENTRY *glDeleteFencesNV_client_proc_t) (void * ctx, GLsizei, const GLuint*); typedef void (gl_APIENTRY *glGenFencesNV_client_proc_t) (void * ctx, GLsizei, GLuint*); typedef GLboolean (gl_APIENTRY *glIsFenceNV_client_proc_t) (void * ctx, GLuint); typedef GLboolean (gl_APIENTRY *glTestFenceNV_client_proc_t) (void * ctx, GLuint); typedef void (gl_APIENTRY *glGetFenceivNV_client_proc_t) (void * ctx, GLuint, GLenum, GLint*); typedef void (gl_APIENTRY *glFinishFenceNV_client_proc_t) (void * ctx, GLuint); typedef void (gl_APIENTRY *glSetFenceNV_client_proc_t) (void * ctx, GLuint, GLenum); typedef void (gl_APIENTRY *glGetDriverControlsQCOM_client_proc_t) (void * ctx, GLint*, GLsizei, GLuint*); typedef void (gl_APIENTRY *glGetDriverControlStringQCOM_client_proc_t) (void * ctx, GLuint, GLsizei, GLsizei*, GLchar*); typedef void (gl_APIENTRY *glEnableDriverControlQCOM_client_proc_t) (void * ctx, GLuint); typedef void (gl_APIENTRY *glDisableDriverControlQCOM_client_proc_t) (void * ctx, GLuint); typedef void (gl_APIENTRY *glExtGetTexturesQCOM_client_proc_t) (void * ctx, GLuint*, GLint, GLint*); typedef void (gl_APIENTRY *glExtGetBuffersQCOM_client_proc_t) (void * ctx, GLuint*, GLint, GLint*); typedef void (gl_APIENTRY *glExtGetRenderbuffersQCOM_client_proc_t) (void * ctx, GLuint*, GLint, GLint*); typedef void (gl_APIENTRY *glExtGetFramebuffersQCOM_client_proc_t) (void * ctx, GLuint*, GLint, GLint*); typedef void (gl_APIENTRY *glExtGetTexLevelParameterivQCOM_client_proc_t) (void * ctx, GLuint, GLenum, GLint, GLenum, GLint*); typedef void (gl_APIENTRY *glExtTexObjectStateOverrideiQCOM_client_proc_t) (void * ctx, GLenum, GLenum, GLint); typedef void (gl_APIENTRY *glExtGetTexSubImageQCOM_client_proc_t) (void * ctx, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLvoid*); typedef void (gl_APIENTRY *glExtGetBufferPointervQCOM_client_proc_t) (void * ctx, GLenum, GLvoid**); typedef void (gl_APIENTRY *glExtGetShadersQCOM_client_proc_t) (void * ctx, GLuint*, GLint, GLint*); typedef void (gl_APIENTRY *glExtGetProgramsQCOM_client_proc_t) (void * ctx, GLuint*, GLint, GLint*); typedef GLboolean (gl_APIENTRY *glExtIsProgramBinaryQCOM_client_proc_t) (void * ctx, GLuint); typedef void (gl_APIENTRY *glExtGetProgramBinarySourceQCOM_client_proc_t) (void * ctx, GLuint, GLenum, GLchar*, GLint*); typedef void (gl_APIENTRY *glStartTilingQCOM_client_proc_t) (void * ctx, GLuint, GLuint, GLuint, GLuint, GLbitfield); typedef void (gl_APIENTRY *glEndTilingQCOM_client_proc_t) (void * ctx, GLbitfield); #endif anbox-0.0~git20191115/android/opengl/system/GLESv1_enc/gl_enc.cpp000066400000000000000000011547561356361734700242610ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #include #include #include "gl_opcodes.h" #include "gl_enc.h" #include namespace { void enc_unsupported() { ALOGE("Function is unsupported\n"); } void glAlphaFunc_enc(void *self , GLenum func, GLclampf ref) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glAlphaFunc;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &func, 4); ptr += 4; memcpy(ptr, &ref, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glClearColor_enc(void *self , GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glClearColor;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &red, 4); ptr += 4; memcpy(ptr, &green, 4); ptr += 4; memcpy(ptr, &blue, 4); ptr += 4; memcpy(ptr, &alpha, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glClearDepthf_enc(void *self , GLclampf depth) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glClearDepthf;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &depth, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glClipPlanef_enc(void *self , GLenum plane, const GLfloat* equation) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_equation = (4 * sizeof(float)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_equation + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glClipPlanef;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &plane, 4); ptr += 4; *(unsigned int *)(ptr) = __size_equation; ptr += 4; memcpy(ptr, equation, __size_equation);ptr += __size_equation; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glColor4f_enc(void *self , GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glColor4f;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &red, 4); ptr += 4; memcpy(ptr, &green, 4); ptr += 4; memcpy(ptr, &blue, 4); ptr += 4; memcpy(ptr, &alpha, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDepthRangef_enc(void *self , GLclampf zNear, GLclampf zFar) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDepthRangef;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &zNear, 4); ptr += 4; memcpy(ptr, &zFar, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glFogf_enc(void *self , GLenum pname, GLfloat param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFogf;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glFogfv_enc(void *self , GLenum pname, const GLfloat* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFogfv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glFrustumf_enc(void *self , GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFrustumf;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &left, 4); ptr += 4; memcpy(ptr, &right, 4); ptr += 4; memcpy(ptr, &bottom, 4); ptr += 4; memcpy(ptr, &top, 4); ptr += 4; memcpy(ptr, &zNear, 4); ptr += 4; memcpy(ptr, &zFar, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glGetClipPlanef_enc(void *self , GLenum pname, GLfloat* eqn) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_eqn = (4 * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_eqn + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetClipPlanef;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_eqn; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(eqn, __size_eqn); if (useChecksum) checksumCalculator->addBuffer(eqn, __size_eqn); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetClipPlanef: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetFloatv_enc(void *self , GLenum pname, GLfloat* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetFloatv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetFloatv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetLightfv_enc(void *self , GLenum light, GLenum pname, GLfloat* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetLightfv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &light, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetLightfv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetMaterialfv_enc(void *self , GLenum face, GLenum pname, GLfloat* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetMaterialfv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &face, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetMaterialfv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetTexEnvfv_enc(void *self , GLenum env, GLenum pname, GLfloat* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetTexEnvfv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &env, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetTexEnvfv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetTexParameterfv_enc(void *self , GLenum target, GLenum pname, GLfloat* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetTexParameterfv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetTexParameterfv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glLightModelf_enc(void *self , GLenum pname, GLfloat param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLightModelf;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glLightModelfv_enc(void *self , GLenum pname, const GLfloat* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLightModelfv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glLightf_enc(void *self , GLenum light, GLenum pname, GLfloat param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLightf;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &light, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glLightfv_enc(void *self , GLenum light, GLenum pname, const GLfloat* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLightfv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &light, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glLineWidth_enc(void *self , GLfloat width) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLineWidth;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glLoadMatrixf_enc(void *self , const GLfloat* m) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_m = (16 * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_m + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLoadMatrixf;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_m; ptr += 4; memcpy(ptr, m, __size_m);ptr += __size_m; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glMaterialf_enc(void *self , GLenum face, GLenum pname, GLfloat param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glMaterialf;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &face, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glMaterialfv_enc(void *self , GLenum face, GLenum pname, const GLfloat* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glMaterialfv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &face, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glMultMatrixf_enc(void *self , const GLfloat* m) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_m = (16 * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_m + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glMultMatrixf;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_m; ptr += 4; memcpy(ptr, m, __size_m);ptr += __size_m; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glMultiTexCoord4f_enc(void *self , GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glMultiTexCoord4f;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &s, 4); ptr += 4; memcpy(ptr, &t, 4); ptr += 4; memcpy(ptr, &r, 4); ptr += 4; memcpy(ptr, &q, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glNormal3f_enc(void *self , GLfloat nx, GLfloat ny, GLfloat nz) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glNormal3f;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &nx, 4); ptr += 4; memcpy(ptr, &ny, 4); ptr += 4; memcpy(ptr, &nz, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glOrthof_enc(void *self , GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glOrthof;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &left, 4); ptr += 4; memcpy(ptr, &right, 4); ptr += 4; memcpy(ptr, &bottom, 4); ptr += 4; memcpy(ptr, &top, 4); ptr += 4; memcpy(ptr, &zNear, 4); ptr += 4; memcpy(ptr, &zFar, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glPointParameterf_enc(void *self , GLenum pname, GLfloat param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glPointParameterf;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glPointParameterfv_enc(void *self , GLenum pname, const GLfloat* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glPointParameterfv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glPointSize_enc(void *self , GLfloat size) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glPointSize;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &size, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glPolygonOffset_enc(void *self , GLfloat factor, GLfloat units) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glPolygonOffset;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &factor, 4); ptr += 4; memcpy(ptr, &units, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glRotatef_enc(void *self , GLfloat angle, GLfloat x, GLfloat y, GLfloat z) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glRotatef;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &angle, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &z, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glScalef_enc(void *self , GLfloat x, GLfloat y, GLfloat z) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glScalef;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &z, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexEnvf_enc(void *self , GLenum target, GLenum pname, GLfloat param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexEnvf;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexEnvfv_enc(void *self , GLenum target, GLenum pname, const GLfloat* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexEnvfv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexParameterf_enc(void *self , GLenum target, GLenum pname, GLfloat param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexParameterf;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexParameterfv_enc(void *self , GLenum target, GLenum pname, const GLfloat* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexParameterfv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTranslatef_enc(void *self , GLfloat x, GLfloat y, GLfloat z) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTranslatef;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &z, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glActiveTexture_enc(void *self , GLenum texture) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glActiveTexture;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &texture, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glAlphaFuncx_enc(void *self , GLenum func, GLclampx ref) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glAlphaFuncx;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &func, 4); ptr += 4; memcpy(ptr, &ref, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glBindBuffer_enc(void *self , GLenum target, GLuint buffer) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glBindBuffer;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &buffer, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glBindTexture_enc(void *self , GLenum target, GLuint texture) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glBindTexture;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &texture, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glBlendFunc_enc(void *self , GLenum sfactor, GLenum dfactor) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glBlendFunc;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &sfactor, 4); ptr += 4; memcpy(ptr, &dfactor, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glBufferData_enc(void *self , GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_data = ((data != NULL) ? size : 0); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_data + 4 + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glBufferData;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &size, 4); ptr += 4; *(unsigned int *)(ptr) = __size_data; ptr += 4; if (data != NULL) memcpy(ptr, data, __size_data);ptr += __size_data; memcpy(ptr, &usage, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glBufferSubData_enc(void *self , GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_data = ((data != NULL) ? size : 0); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_data + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glBufferSubData;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &offset, 4); ptr += 4; memcpy(ptr, &size, 4); ptr += 4; *(unsigned int *)(ptr) = __size_data; ptr += 4; if (data != NULL) memcpy(ptr, data, __size_data);ptr += __size_data; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glClear_enc(void *self , GLbitfield mask) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glClear;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &mask, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glClearColorx_enc(void *self , GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glClearColorx;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &red, 4); ptr += 4; memcpy(ptr, &green, 4); ptr += 4; memcpy(ptr, &blue, 4); ptr += 4; memcpy(ptr, &alpha, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glClearDepthx_enc(void *self , GLclampx depth) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glClearDepthx;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &depth, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glClearStencil_enc(void *self , GLint s) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glClearStencil;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &s, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glClientActiveTexture_enc(void *self , GLenum texture) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glClientActiveTexture;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &texture, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glColor4ub_enc(void *self , GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 1 + 1 + 1 + 1; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glColor4ub;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &red, 1); ptr += 1; memcpy(ptr, &green, 1); ptr += 1; memcpy(ptr, &blue, 1); ptr += 1; memcpy(ptr, &alpha, 1); ptr += 1; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glColor4x_enc(void *self , GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glColor4x;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &red, 4); ptr += 4; memcpy(ptr, &green, 4); ptr += 4; memcpy(ptr, &blue, 4); ptr += 4; memcpy(ptr, &alpha, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glColorMask_enc(void *self , GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 1 + 1 + 1 + 1; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glColorMask;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &red, 1); ptr += 1; memcpy(ptr, &green, 1); ptr += 1; memcpy(ptr, &blue, 1); ptr += 1; memcpy(ptr, &alpha, 1); ptr += 1; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glCompressedTexImage2D_enc(void *self , GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_data = ((data != NULL) ? imageSize : 0); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_data + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glCompressedTexImage2D;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; memcpy(ptr, &internalformat, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; memcpy(ptr, &border, 4); ptr += 4; memcpy(ptr, &imageSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_data; ptr += 4; if (data != NULL) memcpy(ptr, data, __size_data);ptr += __size_data; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glCompressedTexSubImage2D_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_data = ((data != NULL) ? imageSize : 0); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_data + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glCompressedTexSubImage2D;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; memcpy(ptr, &xoffset, 4); ptr += 4; memcpy(ptr, &yoffset, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; memcpy(ptr, &format, 4); ptr += 4; memcpy(ptr, &imageSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_data; ptr += 4; if (data != NULL) memcpy(ptr, data, __size_data);ptr += __size_data; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glCopyTexImage2D_enc(void *self , GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glCopyTexImage2D;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; memcpy(ptr, &internalformat, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; memcpy(ptr, &border, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glCopyTexSubImage2D_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glCopyTexSubImage2D;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; memcpy(ptr, &xoffset, 4); ptr += 4; memcpy(ptr, &yoffset, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glCullFace_enc(void *self , GLenum mode) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glCullFace;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &mode, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDeleteBuffers_enc(void *self , GLsizei n, const GLuint* buffers) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_buffers = (n * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_buffers + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDeleteBuffers;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &n, 4); ptr += 4; *(unsigned int *)(ptr) = __size_buffers; ptr += 4; memcpy(ptr, buffers, __size_buffers);ptr += __size_buffers; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDeleteTextures_enc(void *self , GLsizei n, const GLuint* textures) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_textures = (n * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_textures + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDeleteTextures;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &n, 4); ptr += 4; *(unsigned int *)(ptr) = __size_textures; ptr += 4; memcpy(ptr, textures, __size_textures);ptr += __size_textures; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDepthFunc_enc(void *self , GLenum func) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDepthFunc;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &func, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDepthMask_enc(void *self , GLboolean flag) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 1; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDepthMask;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &flag, 1); ptr += 1; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDepthRangex_enc(void *self , GLclampx zNear, GLclampx zFar) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDepthRangex;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &zNear, 4); ptr += 4; memcpy(ptr, &zFar, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDisable_enc(void *self , GLenum cap) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDisable;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &cap, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDisableClientState_enc(void *self , GLenum array) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDisableClientState;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &array, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDrawArrays_enc(void *self , GLenum mode, GLint first, GLsizei count) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDrawArrays;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &mode, 4); ptr += 4; memcpy(ptr, &first, 4); ptr += 4; memcpy(ptr, &count, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glEnable_enc(void *self , GLenum cap) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glEnable;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &cap, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glEnableClientState_enc(void *self , GLenum array) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glEnableClientState;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &array, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glFinish_enc(void *self ) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFinish;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glFlush_enc(void *self ) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFlush;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glFogx_enc(void *self , GLenum pname, GLfixed param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFogx;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glFogxv_enc(void *self , GLenum pname, const GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFogxv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glFrontFace_enc(void *self , GLenum mode) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFrontFace;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &mode, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glFrustumx_enc(void *self , GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFrustumx;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &left, 4); ptr += 4; memcpy(ptr, &right, 4); ptr += 4; memcpy(ptr, &bottom, 4); ptr += 4; memcpy(ptr, &top, 4); ptr += 4; memcpy(ptr, &zNear, 4); ptr += 4; memcpy(ptr, &zFar, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glGetBooleanv_enc(void *self , GLenum pname, GLboolean* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLboolean)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetBooleanv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetBooleanv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetBufferParameteriv_enc(void *self , GLenum target, GLenum pname, GLint* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetBufferParameteriv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetBufferParameteriv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glClipPlanex_enc(void *self , GLenum pname, const GLfixed* eqn) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_eqn = (4 * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_eqn + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glClipPlanex;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_eqn; ptr += 4; memcpy(ptr, eqn, __size_eqn);ptr += __size_eqn; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glGenBuffers_enc(void *self , GLsizei n, GLuint* buffers) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_buffers = (n * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_buffers + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGenBuffers;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &n, 4); ptr += 4; *(unsigned int *)(ptr) = __size_buffers; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(buffers, __size_buffers); if (useChecksum) checksumCalculator->addBuffer(buffers, __size_buffers); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGenBuffers: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGenTextures_enc(void *self , GLsizei n, GLuint* textures) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_textures = (n * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_textures + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGenTextures;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &n, 4); ptr += 4; *(unsigned int *)(ptr) = __size_textures; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(textures, __size_textures); if (useChecksum) checksumCalculator->addBuffer(textures, __size_textures); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGenTextures: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } GLenum glGetError_enc(void *self ) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetError;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLenum retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetError: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void glGetFixedv_enc(void *self , GLenum pname, GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetFixedv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetFixedv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetIntegerv_enc(void *self , GLenum pname, GLint* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetIntegerv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetIntegerv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetLightxv_enc(void *self , GLenum light, GLenum pname, GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetLightxv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &light, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetLightxv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetMaterialxv_enc(void *self , GLenum face, GLenum pname, GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetMaterialxv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &face, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetMaterialxv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetTexEnviv_enc(void *self , GLenum env, GLenum pname, GLint* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetTexEnviv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &env, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetTexEnviv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetTexEnvxv_enc(void *self , GLenum env, GLenum pname, GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetTexEnvxv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &env, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetTexEnvxv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetTexParameteriv_enc(void *self , GLenum target, GLenum pname, GLint* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetTexParameteriv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetTexParameteriv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetTexParameterxv_enc(void *self , GLenum target, GLenum pname, GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetTexParameterxv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetTexParameterxv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glHint_enc(void *self , GLenum target, GLenum mode) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glHint;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &mode, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } GLboolean glIsBuffer_enc(void *self , GLuint buffer) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glIsBuffer;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &buffer, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLboolean retval; stream->readback(&retval, 1); if (useChecksum) checksumCalculator->addBuffer(&retval, 1); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glIsBuffer: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } GLboolean glIsEnabled_enc(void *self , GLenum cap) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glIsEnabled;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &cap, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLboolean retval; stream->readback(&retval, 1); if (useChecksum) checksumCalculator->addBuffer(&retval, 1); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glIsEnabled: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } GLboolean glIsTexture_enc(void *self , GLuint texture) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glIsTexture;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &texture, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLboolean retval; stream->readback(&retval, 1); if (useChecksum) checksumCalculator->addBuffer(&retval, 1); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glIsTexture: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void glLightModelx_enc(void *self , GLenum pname, GLfixed param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLightModelx;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glLightModelxv_enc(void *self , GLenum pname, const GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLightModelxv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glLightx_enc(void *self , GLenum light, GLenum pname, GLfixed param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLightx;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &light, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glLightxv_enc(void *self , GLenum light, GLenum pname, const GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLightxv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &light, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glLineWidthx_enc(void *self , GLfixed width) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLineWidthx;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glLoadIdentity_enc(void *self ) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLoadIdentity;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glLoadMatrixx_enc(void *self , const GLfixed* m) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_m = (16 * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_m + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLoadMatrixx;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_m; ptr += 4; memcpy(ptr, m, __size_m);ptr += __size_m; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glLogicOp_enc(void *self , GLenum opcode) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLogicOp;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &opcode, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glMaterialx_enc(void *self , GLenum face, GLenum pname, GLfixed param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glMaterialx;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &face, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glMaterialxv_enc(void *self , GLenum face, GLenum pname, const GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glMaterialxv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &face, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glMatrixMode_enc(void *self , GLenum mode) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glMatrixMode;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &mode, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glMultMatrixx_enc(void *self , const GLfixed* m) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_m = (16 * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_m + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glMultMatrixx;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_m; ptr += 4; memcpy(ptr, m, __size_m);ptr += __size_m; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glMultiTexCoord4x_enc(void *self , GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glMultiTexCoord4x;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &s, 4); ptr += 4; memcpy(ptr, &t, 4); ptr += 4; memcpy(ptr, &r, 4); ptr += 4; memcpy(ptr, &q, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glNormal3x_enc(void *self , GLfixed nx, GLfixed ny, GLfixed nz) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glNormal3x;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &nx, 4); ptr += 4; memcpy(ptr, &ny, 4); ptr += 4; memcpy(ptr, &nz, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glOrthox_enc(void *self , GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glOrthox;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &left, 4); ptr += 4; memcpy(ptr, &right, 4); ptr += 4; memcpy(ptr, &bottom, 4); ptr += 4; memcpy(ptr, &top, 4); ptr += 4; memcpy(ptr, &zNear, 4); ptr += 4; memcpy(ptr, &zFar, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glPixelStorei_enc(void *self , GLenum pname, GLint param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glPixelStorei;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glPointParameterx_enc(void *self , GLenum pname, GLfixed param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glPointParameterx;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glPointParameterxv_enc(void *self , GLenum pname, const GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glPointParameterxv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glPointSizex_enc(void *self , GLfixed size) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glPointSizex;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &size, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glPolygonOffsetx_enc(void *self , GLfixed factor, GLfixed units) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glPolygonOffsetx;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &factor, 4); ptr += 4; memcpy(ptr, &units, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glPopMatrix_enc(void *self ) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glPopMatrix;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glPushMatrix_enc(void *self ) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glPushMatrix;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glReadPixels_enc(void *self , GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_pixels = glesv1_enc::pixelDataSize(self, width, height, format, type, 1); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glReadPixels;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; memcpy(ptr, &format, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; *(unsigned int *)(ptr) = __size_pixels; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(pixels, __size_pixels); if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glReadPixels: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glRotatex_enc(void *self , GLfixed angle, GLfixed x, GLfixed y, GLfixed z) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glRotatex;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &angle, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &z, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glSampleCoverage_enc(void *self , GLclampf value, GLboolean invert) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 1; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glSampleCoverage;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &value, 4); ptr += 4; memcpy(ptr, &invert, 1); ptr += 1; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glSampleCoveragex_enc(void *self , GLclampx value, GLboolean invert) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 1; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glSampleCoveragex;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &value, 4); ptr += 4; memcpy(ptr, &invert, 1); ptr += 1; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glScalex_enc(void *self , GLfixed x, GLfixed y, GLfixed z) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glScalex;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &z, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glScissor_enc(void *self , GLint x, GLint y, GLsizei width, GLsizei height) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glScissor;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glShadeModel_enc(void *self , GLenum mode) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glShadeModel;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &mode, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glStencilFunc_enc(void *self , GLenum func, GLint ref, GLuint mask) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glStencilFunc;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &func, 4); ptr += 4; memcpy(ptr, &ref, 4); ptr += 4; memcpy(ptr, &mask, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glStencilMask_enc(void *self , GLuint mask) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glStencilMask;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &mask, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glStencilOp_enc(void *self , GLenum fail, GLenum zfail, GLenum zpass) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glStencilOp;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &fail, 4); ptr += 4; memcpy(ptr, &zfail, 4); ptr += 4; memcpy(ptr, &zpass, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexEnvi_enc(void *self , GLenum target, GLenum pname, GLint param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexEnvi;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexEnvx_enc(void *self , GLenum target, GLenum pname, GLfixed param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexEnvx;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexEnviv_enc(void *self , GLenum target, GLenum pname, const GLint* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexEnviv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexEnvxv_enc(void *self , GLenum target, GLenum pname, const GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexEnvxv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexImage2D_enc(void *self , GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_pixels = ((pixels != NULL) ? glesv1_enc::pixelDataSize(self, width, height, format, type, 0) : 0); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4); ptr = buf; int tmp = OP_glTexImage2D;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; memcpy(ptr, &internalformat, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; memcpy(ptr, &border, 4); ptr += 4; memcpy(ptr, &format, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); stream->flush(); stream->writeFully(&__size_pixels,4); if (useChecksum) checksumCalculator->addBuffer(&__size_pixels,4); if (pixels != NULL) { stream->writeFully(pixels, __size_pixels); if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels); } buf = stream->alloc(checksumSize); if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize); } void glTexParameteri_enc(void *self , GLenum target, GLenum pname, GLint param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexParameteri;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexParameterx_enc(void *self , GLenum target, GLenum pname, GLfixed param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexParameterx;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexParameteriv_enc(void *self , GLenum target, GLenum pname, const GLint* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexParameteriv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexParameterxv_enc(void *self , GLenum target, GLenum pname, const GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexParameterxv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexSubImage2D_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_pixels = ((pixels != NULL) ? glesv1_enc::pixelDataSize(self, width, height, format, type, 0) : 0); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4); ptr = buf; int tmp = OP_glTexSubImage2D;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; memcpy(ptr, &xoffset, 4); ptr += 4; memcpy(ptr, &yoffset, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; memcpy(ptr, &format, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); stream->flush(); stream->writeFully(&__size_pixels,4); if (useChecksum) checksumCalculator->addBuffer(&__size_pixels,4); if (pixels != NULL) { stream->writeFully(pixels, __size_pixels); if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels); } buf = stream->alloc(checksumSize); if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize); } void glTranslatex_enc(void *self , GLfixed x, GLfixed y, GLfixed z) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTranslatex;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &z, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glViewport_enc(void *self , GLint x, GLint y, GLsizei width, GLsizei height) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glViewport;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glVertexPointerOffset_enc(void *self , GLint size, GLenum type, GLsizei stride, GLuint offset) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glVertexPointerOffset;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &size, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; memcpy(ptr, &stride, 4); ptr += 4; memcpy(ptr, &offset, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glColorPointerOffset_enc(void *self , GLint size, GLenum type, GLsizei stride, GLuint offset) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glColorPointerOffset;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &size, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; memcpy(ptr, &stride, 4); ptr += 4; memcpy(ptr, &offset, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glNormalPointerOffset_enc(void *self , GLenum type, GLsizei stride, GLuint offset) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glNormalPointerOffset;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; memcpy(ptr, &stride, 4); ptr += 4; memcpy(ptr, &offset, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glPointSizePointerOffset_enc(void *self , GLenum type, GLsizei stride, GLuint offset) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glPointSizePointerOffset;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; memcpy(ptr, &stride, 4); ptr += 4; memcpy(ptr, &offset, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexCoordPointerOffset_enc(void *self , GLint size, GLenum type, GLsizei stride, GLuint offset) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexCoordPointerOffset;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &size, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; memcpy(ptr, &stride, 4); ptr += 4; memcpy(ptr, &offset, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glWeightPointerOffset_enc(void *self , GLint size, GLenum type, GLsizei stride, GLuint offset) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glWeightPointerOffset;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &size, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; memcpy(ptr, &stride, 4); ptr += 4; memcpy(ptr, &offset, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glMatrixIndexPointerOffset_enc(void *self , GLint size, GLenum type, GLsizei stride, GLuint offset) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glMatrixIndexPointerOffset;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &size, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; memcpy(ptr, &stride, 4); ptr += 4; memcpy(ptr, &offset, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glVertexPointerData_enc(void *self , GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_data = datalen; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_data + 4 + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glVertexPointerData;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &size, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; memcpy(ptr, &stride, 4); ptr += 4; *(unsigned int *)(ptr) = __size_data; ptr += 4; glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, size, type, stride, datalen);ptr += __size_data; memcpy(ptr, &datalen, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glColorPointerData_enc(void *self , GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_data = datalen; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_data + 4 + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glColorPointerData;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &size, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; memcpy(ptr, &stride, 4); ptr += 4; *(unsigned int *)(ptr) = __size_data; ptr += 4; glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, size, type, stride, datalen);ptr += __size_data; memcpy(ptr, &datalen, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glNormalPointerData_enc(void *self , GLenum type, GLsizei stride, void* data, GLuint datalen) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_data = datalen; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_data + 4 + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glNormalPointerData;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; memcpy(ptr, &stride, 4); ptr += 4; *(unsigned int *)(ptr) = __size_data; ptr += 4; glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, 3, type, stride, datalen);ptr += __size_data; memcpy(ptr, &datalen, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexCoordPointerData_enc(void *self , GLint unit, GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_data = datalen; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + __size_data + 4 + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexCoordPointerData;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &unit, 4); ptr += 4; memcpy(ptr, &size, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; memcpy(ptr, &stride, 4); ptr += 4; *(unsigned int *)(ptr) = __size_data; ptr += 4; glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, size, type, stride, datalen);ptr += __size_data; memcpy(ptr, &datalen, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glPointSizePointerData_enc(void *self , GLenum type, GLsizei stride, void* data, GLuint datalen) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_data = datalen; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_data + 4 + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glPointSizePointerData;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; memcpy(ptr, &stride, 4); ptr += 4; *(unsigned int *)(ptr) = __size_data; ptr += 4; glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, 1, type, stride, datalen);ptr += __size_data; memcpy(ptr, &datalen, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glWeightPointerData_enc(void *self , GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_data = datalen; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_data + 4 + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glWeightPointerData;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &size, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; memcpy(ptr, &stride, 4); ptr += 4; *(unsigned int *)(ptr) = __size_data; ptr += 4; glUtilsPackPointerData((unsigned char *)ptr, (unsigned char*)data, size, type, stride, datalen);ptr += __size_data; memcpy(ptr, &datalen, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glMatrixIndexPointerData_enc(void *self , GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_data = datalen; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_data + 4 + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glMatrixIndexPointerData;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &size, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; memcpy(ptr, &stride, 4); ptr += 4; *(unsigned int *)(ptr) = __size_data; ptr += 4; glUtilsPackPointerData((unsigned char *)ptr, (unsigned char*)data, size, type, stride, datalen);ptr += __size_data; memcpy(ptr, &datalen, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDrawElementsOffset_enc(void *self , GLenum mode, GLsizei count, GLenum type, GLuint offset) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDrawElementsOffset;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &mode, 4); ptr += 4; memcpy(ptr, &count, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; memcpy(ptr, &offset, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDrawElementsData_enc(void *self , GLenum mode, GLsizei count, GLenum type, void* data, GLuint datalen) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_data = datalen; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_data + 4 + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDrawElementsData;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &mode, 4); ptr += 4; memcpy(ptr, &count, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; *(unsigned int *)(ptr) = __size_data; ptr += 4; memcpy(ptr, data, __size_data);ptr += __size_data; memcpy(ptr, &datalen, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glGetCompressedTextureFormats_enc(void *self , int count, GLint* formats) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_formats = (count * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_formats + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetCompressedTextureFormats;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &count, 4); ptr += 4; *(unsigned int *)(ptr) = __size_formats; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(formats, __size_formats); if (useChecksum) checksumCalculator->addBuffer(formats, __size_formats); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetCompressedTextureFormats: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } int glFinishRoundTrip_enc(void *self ) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFinishRoundTrip;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; int retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glFinishRoundTrip: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void glBlendEquationSeparateOES_enc(void *self , GLenum modeRGB, GLenum modeAlpha) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glBlendEquationSeparateOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &modeRGB, 4); ptr += 4; memcpy(ptr, &modeAlpha, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glBlendFuncSeparateOES_enc(void *self , GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glBlendFuncSeparateOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &srcRGB, 4); ptr += 4; memcpy(ptr, &dstRGB, 4); ptr += 4; memcpy(ptr, &srcAlpha, 4); ptr += 4; memcpy(ptr, &dstAlpha, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glBlendEquationOES_enc(void *self , GLenum mode) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glBlendEquationOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &mode, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDrawTexsOES_enc(void *self , GLshort x, GLshort y, GLshort z, GLshort width, GLshort height) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 2 + 2 + 2 + 2 + 2; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDrawTexsOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &x, 2); ptr += 2; memcpy(ptr, &y, 2); ptr += 2; memcpy(ptr, &z, 2); ptr += 2; memcpy(ptr, &width, 2); ptr += 2; memcpy(ptr, &height, 2); ptr += 2; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDrawTexiOES_enc(void *self , GLint x, GLint y, GLint z, GLint width, GLint height) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDrawTexiOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &z, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDrawTexxOES_enc(void *self , GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDrawTexxOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &z, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDrawTexsvOES_enc(void *self , const GLshort* coords) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_coords = (5 * sizeof(GLshort)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_coords + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDrawTexsvOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_coords; ptr += 4; memcpy(ptr, coords, __size_coords);ptr += __size_coords; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDrawTexivOES_enc(void *self , const GLint* coords) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_coords = (5 * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_coords + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDrawTexivOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_coords; ptr += 4; memcpy(ptr, coords, __size_coords);ptr += __size_coords; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDrawTexxvOES_enc(void *self , const GLfixed* coords) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_coords = (5 * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_coords + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDrawTexxvOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_coords; ptr += 4; memcpy(ptr, coords, __size_coords);ptr += __size_coords; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDrawTexfOES_enc(void *self , GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDrawTexfOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &z, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDrawTexfvOES_enc(void *self , const GLfloat* coords) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_coords = (5 * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_coords + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDrawTexfvOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_coords; ptr += 4; memcpy(ptr, coords, __size_coords);ptr += __size_coords; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glEGLImageTargetTexture2DOES_enc(void *self , GLenum target, GLeglImageOES image) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glEGLImageTargetTexture2DOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &image, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glEGLImageTargetRenderbufferStorageOES_enc(void *self , GLenum target, GLeglImageOES image) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glEGLImageTargetRenderbufferStorageOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &image, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glAlphaFuncxOES_enc(void *self , GLenum func, GLclampx ref) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glAlphaFuncxOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &func, 4); ptr += 4; memcpy(ptr, &ref, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glClearColorxOES_enc(void *self , GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glClearColorxOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &red, 4); ptr += 4; memcpy(ptr, &green, 4); ptr += 4; memcpy(ptr, &blue, 4); ptr += 4; memcpy(ptr, &alpha, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glClearDepthxOES_enc(void *self , GLclampx depth) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glClearDepthxOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &depth, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glClipPlanexOES_enc(void *self , GLenum plane, const GLfixed* equation) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_equation = (4 * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_equation + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glClipPlanexOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &plane, 4); ptr += 4; *(unsigned int *)(ptr) = __size_equation; ptr += 4; memcpy(ptr, equation, __size_equation);ptr += __size_equation; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glClipPlanexIMG_enc(void *self , GLenum plane, const GLfixed* equation) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_equation = (4 * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_equation + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glClipPlanexIMG;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &plane, 4); ptr += 4; *(unsigned int *)(ptr) = __size_equation; ptr += 4; memcpy(ptr, equation, __size_equation);ptr += __size_equation; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glColor4xOES_enc(void *self , GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glColor4xOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &red, 4); ptr += 4; memcpy(ptr, &green, 4); ptr += 4; memcpy(ptr, &blue, 4); ptr += 4; memcpy(ptr, &alpha, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDepthRangexOES_enc(void *self , GLclampx zNear, GLclampx zFar) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDepthRangexOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &zNear, 4); ptr += 4; memcpy(ptr, &zFar, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glFogxOES_enc(void *self , GLenum pname, GLfixed param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFogxOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glFogxvOES_enc(void *self , GLenum pname, const GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFogxvOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glFrustumxOES_enc(void *self , GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFrustumxOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &left, 4); ptr += 4; memcpy(ptr, &right, 4); ptr += 4; memcpy(ptr, &bottom, 4); ptr += 4; memcpy(ptr, &top, 4); ptr += 4; memcpy(ptr, &zNear, 4); ptr += 4; memcpy(ptr, &zFar, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glGetClipPlanexOES_enc(void *self , GLenum pname, GLfixed* eqn) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_eqn = (4 * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_eqn + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetClipPlanexOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_eqn; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(eqn, __size_eqn); if (useChecksum) checksumCalculator->addBuffer(eqn, __size_eqn); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetClipPlanexOES: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetClipPlanex_enc(void *self , GLenum pname, GLfixed* eqn) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_eqn = (4 * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_eqn + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetClipPlanex;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_eqn; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(eqn, __size_eqn); if (useChecksum) checksumCalculator->addBuffer(eqn, __size_eqn); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetClipPlanex: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetFixedvOES_enc(void *self , GLenum pname, GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetFixedvOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetFixedvOES: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetLightxvOES_enc(void *self , GLenum light, GLenum pname, GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetLightxvOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &light, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetLightxvOES: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetMaterialxvOES_enc(void *self , GLenum face, GLenum pname, GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetMaterialxvOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &face, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetMaterialxvOES: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetTexEnvxvOES_enc(void *self , GLenum env, GLenum pname, GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetTexEnvxvOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &env, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetTexEnvxvOES: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetTexParameterxvOES_enc(void *self , GLenum target, GLenum pname, GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetTexParameterxvOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetTexParameterxvOES: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glLightModelxOES_enc(void *self , GLenum pname, GLfixed param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLightModelxOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glLightModelxvOES_enc(void *self , GLenum pname, const GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLightModelxvOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glLightxOES_enc(void *self , GLenum light, GLenum pname, GLfixed param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLightxOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &light, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glLightxvOES_enc(void *self , GLenum light, GLenum pname, const GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLightxvOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &light, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glLineWidthxOES_enc(void *self , GLfixed width) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLineWidthxOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glLoadMatrixxOES_enc(void *self , const GLfixed* m) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_m = (16 * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_m + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLoadMatrixxOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_m; ptr += 4; memcpy(ptr, m, __size_m);ptr += __size_m; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glMaterialxOES_enc(void *self , GLenum face, GLenum pname, GLfixed param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glMaterialxOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &face, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glMaterialxvOES_enc(void *self , GLenum face, GLenum pname, const GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glMaterialxvOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &face, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glMultMatrixxOES_enc(void *self , const GLfixed* m) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_m = (16 * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_m + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glMultMatrixxOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_m; ptr += 4; memcpy(ptr, m, __size_m);ptr += __size_m; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glMultiTexCoord4xOES_enc(void *self , GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glMultiTexCoord4xOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &s, 4); ptr += 4; memcpy(ptr, &t, 4); ptr += 4; memcpy(ptr, &r, 4); ptr += 4; memcpy(ptr, &q, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glNormal3xOES_enc(void *self , GLfixed nx, GLfixed ny, GLfixed nz) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glNormal3xOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &nx, 4); ptr += 4; memcpy(ptr, &ny, 4); ptr += 4; memcpy(ptr, &nz, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glOrthoxOES_enc(void *self , GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glOrthoxOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &left, 4); ptr += 4; memcpy(ptr, &right, 4); ptr += 4; memcpy(ptr, &bottom, 4); ptr += 4; memcpy(ptr, &top, 4); ptr += 4; memcpy(ptr, &zNear, 4); ptr += 4; memcpy(ptr, &zFar, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glPointParameterxOES_enc(void *self , GLenum pname, GLfixed param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glPointParameterxOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glPointParameterxvOES_enc(void *self , GLenum pname, const GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glPointParameterxvOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glPointSizexOES_enc(void *self , GLfixed size) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glPointSizexOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &size, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glPolygonOffsetxOES_enc(void *self , GLfixed factor, GLfixed units) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glPolygonOffsetxOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &factor, 4); ptr += 4; memcpy(ptr, &units, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glRotatexOES_enc(void *self , GLfixed angle, GLfixed x, GLfixed y, GLfixed z) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glRotatexOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &angle, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &z, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glSampleCoveragexOES_enc(void *self , GLclampx value, GLboolean invert) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 1; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glSampleCoveragexOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &value, 4); ptr += 4; memcpy(ptr, &invert, 1); ptr += 1; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glScalexOES_enc(void *self , GLfixed x, GLfixed y, GLfixed z) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glScalexOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &z, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexEnvxOES_enc(void *self , GLenum target, GLenum pname, GLfixed param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexEnvxOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexEnvxvOES_enc(void *self , GLenum target, GLenum pname, const GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexEnvxvOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexParameterxOES_enc(void *self , GLenum target, GLenum pname, GLfixed param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexParameterxOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexParameterxvOES_enc(void *self , GLenum target, GLenum pname, const GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexParameterxvOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTranslatexOES_enc(void *self , GLfixed x, GLfixed y, GLfixed z) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTranslatexOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &z, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } GLboolean glIsRenderbufferOES_enc(void *self , GLuint renderbuffer) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glIsRenderbufferOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &renderbuffer, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLboolean retval; stream->readback(&retval, 1); if (useChecksum) checksumCalculator->addBuffer(&retval, 1); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glIsRenderbufferOES: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void glBindRenderbufferOES_enc(void *self , GLenum target, GLuint renderbuffer) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glBindRenderbufferOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &renderbuffer, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDeleteRenderbuffersOES_enc(void *self , GLsizei n, const GLuint* renderbuffers) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_renderbuffers = (n * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_renderbuffers + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDeleteRenderbuffersOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &n, 4); ptr += 4; *(unsigned int *)(ptr) = __size_renderbuffers; ptr += 4; memcpy(ptr, renderbuffers, __size_renderbuffers);ptr += __size_renderbuffers; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glGenRenderbuffersOES_enc(void *self , GLsizei n, GLuint* renderbuffers) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_renderbuffers = (n * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_renderbuffers + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGenRenderbuffersOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &n, 4); ptr += 4; *(unsigned int *)(ptr) = __size_renderbuffers; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(renderbuffers, __size_renderbuffers); if (useChecksum) checksumCalculator->addBuffer(renderbuffers, __size_renderbuffers); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGenRenderbuffersOES: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glRenderbufferStorageOES_enc(void *self , GLenum target, GLenum internalformat, GLsizei width, GLsizei height) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glRenderbufferStorageOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &internalformat, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glGetRenderbufferParameterivOES_enc(void *self , GLenum target, GLenum pname, GLint* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetRenderbufferParameterivOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetRenderbufferParameterivOES: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } GLboolean glIsFramebufferOES_enc(void *self , GLuint framebuffer) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glIsFramebufferOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &framebuffer, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLboolean retval; stream->readback(&retval, 1); if (useChecksum) checksumCalculator->addBuffer(&retval, 1); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glIsFramebufferOES: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void glBindFramebufferOES_enc(void *self , GLenum target, GLuint framebuffer) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glBindFramebufferOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &framebuffer, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDeleteFramebuffersOES_enc(void *self , GLsizei n, const GLuint* framebuffers) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_framebuffers = (n * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_framebuffers + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDeleteFramebuffersOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &n, 4); ptr += 4; *(unsigned int *)(ptr) = __size_framebuffers; ptr += 4; memcpy(ptr, framebuffers, __size_framebuffers);ptr += __size_framebuffers; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glGenFramebuffersOES_enc(void *self , GLsizei n, GLuint* framebuffers) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_framebuffers = (n * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_framebuffers + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGenFramebuffersOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &n, 4); ptr += 4; *(unsigned int *)(ptr) = __size_framebuffers; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(framebuffers, __size_framebuffers); if (useChecksum) checksumCalculator->addBuffer(framebuffers, __size_framebuffers); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGenFramebuffersOES: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } GLenum glCheckFramebufferStatusOES_enc(void *self , GLenum target) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glCheckFramebufferStatusOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLenum retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glCheckFramebufferStatusOES: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void glFramebufferRenderbufferOES_enc(void *self , GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFramebufferRenderbufferOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &attachment, 4); ptr += 4; memcpy(ptr, &renderbuffertarget, 4); ptr += 4; memcpy(ptr, &renderbuffer, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glFramebufferTexture2DOES_enc(void *self , GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFramebufferTexture2DOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &attachment, 4); ptr += 4; memcpy(ptr, &textarget, 4); ptr += 4; memcpy(ptr, &texture, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glGetFramebufferAttachmentParameterivOES_enc(void *self , GLenum target, GLenum attachment, GLenum pname, GLint* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetFramebufferAttachmentParameterivOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &attachment, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetFramebufferAttachmentParameterivOES: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGenerateMipmapOES_enc(void *self , GLenum target) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGenerateMipmapOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } GLboolean glUnmapBufferOES_enc(void *self , GLenum target) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glUnmapBufferOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLboolean retval; stream->readback(&retval, 1); if (useChecksum) checksumCalculator->addBuffer(&retval, 1); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glUnmapBufferOES: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void glCurrentPaletteMatrixOES_enc(void *self , GLuint matrixpaletteindex) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glCurrentPaletteMatrixOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &matrixpaletteindex, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glLoadPaletteFromModelViewMatrixOES_enc(void *self ) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLoadPaletteFromModelViewMatrixOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } GLbitfield glQueryMatrixxOES_enc(void *self , GLfixed* mantissa, GLint* exponent) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_mantissa = (16 * sizeof(GLfixed)); const unsigned int __size_exponent = (16 * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_mantissa + __size_exponent + 2*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glQueryMatrixxOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_mantissa; ptr += 4; *(unsigned int *)(ptr) = __size_exponent; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(mantissa, __size_mantissa); if (useChecksum) checksumCalculator->addBuffer(mantissa, __size_mantissa); stream->readback(exponent, __size_exponent); if (useChecksum) checksumCalculator->addBuffer(exponent, __size_exponent); GLbitfield retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glQueryMatrixxOES: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void glDepthRangefOES_enc(void *self , GLclampf zNear, GLclampf zFar) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDepthRangefOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &zNear, 4); ptr += 4; memcpy(ptr, &zFar, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glFrustumfOES_enc(void *self , GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFrustumfOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &left, 4); ptr += 4; memcpy(ptr, &right, 4); ptr += 4; memcpy(ptr, &bottom, 4); ptr += 4; memcpy(ptr, &top, 4); ptr += 4; memcpy(ptr, &zNear, 4); ptr += 4; memcpy(ptr, &zFar, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glOrthofOES_enc(void *self , GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glOrthofOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &left, 4); ptr += 4; memcpy(ptr, &right, 4); ptr += 4; memcpy(ptr, &bottom, 4); ptr += 4; memcpy(ptr, &top, 4); ptr += 4; memcpy(ptr, &zNear, 4); ptr += 4; memcpy(ptr, &zFar, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glClipPlanefOES_enc(void *self , GLenum plane, const GLfloat* equation) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_equation = (4 * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_equation + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glClipPlanefOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &plane, 4); ptr += 4; *(unsigned int *)(ptr) = __size_equation; ptr += 4; memcpy(ptr, equation, __size_equation);ptr += __size_equation; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glClipPlanefIMG_enc(void *self , GLenum plane, const GLfloat* equation) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_equation = (4 * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_equation + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glClipPlanefIMG;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &plane, 4); ptr += 4; *(unsigned int *)(ptr) = __size_equation; ptr += 4; memcpy(ptr, equation, __size_equation);ptr += __size_equation; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glGetClipPlanefOES_enc(void *self , GLenum pname, GLfloat* eqn) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_eqn = (4 * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_eqn + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetClipPlanefOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_eqn; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(eqn, __size_eqn); if (useChecksum) checksumCalculator->addBuffer(eqn, __size_eqn); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetClipPlanefOES: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glClearDepthfOES_enc(void *self , GLclampf depth) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glClearDepthfOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &depth, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexGenfOES_enc(void *self , GLenum coord, GLenum pname, GLfloat param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexGenfOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &coord, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexGenfvOES_enc(void *self , GLenum coord, GLenum pname, const GLfloat* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexGenfvOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &coord, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexGeniOES_enc(void *self , GLenum coord, GLenum pname, GLint param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexGeniOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &coord, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexGenivOES_enc(void *self , GLenum coord, GLenum pname, const GLint* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexGenivOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &coord, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexGenxOES_enc(void *self , GLenum coord, GLenum pname, GLfixed param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexGenxOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &coord, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexGenxvOES_enc(void *self , GLenum coord, GLenum pname, const GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexGenxvOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &coord, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glGetTexGenfvOES_enc(void *self , GLenum coord, GLenum pname, GLfloat* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetTexGenfvOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &coord, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glGetTexGenivOES_enc(void *self , GLenum coord, GLenum pname, GLint* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetTexGenivOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &coord, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glGetTexGenxvOES_enc(void *self , GLenum coord, GLenum pname, GLfixed* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfixed)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetTexGenxvOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &coord, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glBindVertexArrayOES_enc(void *self , GLuint array) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glBindVertexArrayOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &array, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDeleteVertexArraysOES_enc(void *self , GLsizei n, const GLuint* arrays) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_arrays = (n * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_arrays + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDeleteVertexArraysOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &n, 4); ptr += 4; *(unsigned int *)(ptr) = __size_arrays; ptr += 4; memcpy(ptr, arrays, __size_arrays);ptr += __size_arrays; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glGenVertexArraysOES_enc(void *self , GLsizei n, GLuint* arrays) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_arrays = (n * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_arrays + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGenVertexArraysOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &n, 4); ptr += 4; *(unsigned int *)(ptr) = __size_arrays; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(arrays, __size_arrays); if (useChecksum) checksumCalculator->addBuffer(arrays, __size_arrays); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGenVertexArraysOES: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } GLboolean glIsVertexArrayOES_enc(void *self , GLuint array) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glIsVertexArrayOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &array, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLboolean retval; stream->readback(&retval, 1); if (useChecksum) checksumCalculator->addBuffer(&retval, 1); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glIsVertexArrayOES: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void glDiscardFramebufferEXT_enc(void *self , GLenum target, GLsizei numAttachments, const GLenum* attachments) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_attachments = (numAttachments * sizeof(const GLenum)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_attachments + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDiscardFramebufferEXT;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &numAttachments, 4); ptr += 4; *(unsigned int *)(ptr) = __size_attachments; ptr += 4; memcpy(ptr, attachments, __size_attachments);ptr += __size_attachments; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glRenderbufferStorageMultisampleIMG_enc(void *self , GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glRenderbufferStorageMultisampleIMG;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &samples, 4); ptr += 4; memcpy(ptr, &internalformat, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glFramebufferTexture2DMultisampleIMG_enc(void *self , GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFramebufferTexture2DMultisampleIMG;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &attachment, 4); ptr += 4; memcpy(ptr, &textarget, 4); ptr += 4; memcpy(ptr, &texture, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; memcpy(ptr, &samples, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDeleteFencesNV_enc(void *self , GLsizei n, const GLuint* fences) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_fences = (n * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_fences + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDeleteFencesNV;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &n, 4); ptr += 4; *(unsigned int *)(ptr) = __size_fences; ptr += 4; memcpy(ptr, fences, __size_fences);ptr += __size_fences; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glGenFencesNV_enc(void *self , GLsizei n, GLuint* fences) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_fences = (n * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_fences + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGenFencesNV;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &n, 4); ptr += 4; *(unsigned int *)(ptr) = __size_fences; ptr += 4; memcpy(ptr, fences, __size_fences);ptr += __size_fences; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } GLboolean glIsFenceNV_enc(void *self , GLuint fence) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glIsFenceNV;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &fence, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLboolean retval; stream->readback(&retval, 1); if (useChecksum) checksumCalculator->addBuffer(&retval, 1); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glIsFenceNV: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } GLboolean glTestFenceNV_enc(void *self , GLuint fence) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTestFenceNV;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &fence, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLboolean retval; stream->readback(&retval, 1); if (useChecksum) checksumCalculator->addBuffer(&retval, 1); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glTestFenceNV: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void glGetFenceivNV_enc(void *self , GLuint fence, GLenum pname, GLint* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetFenceivNV;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &fence, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetFenceivNV: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glFinishFenceNV_enc(void *self , GLuint fence) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFinishFenceNV;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &fence, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glSetFenceNV_enc(void *self , GLuint fence, GLenum condition) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glSetFenceNV;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &fence, 4); ptr += 4; memcpy(ptr, &condition, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glGetDriverControlsQCOM_enc(void *self , GLint* num, GLsizei size, GLuint* driverControls) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_num = (1 * sizeof(GLint)); const unsigned int __size_driverControls = (size * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_num + 4 + __size_driverControls + 2*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetDriverControlsQCOM;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_num; ptr += 4; memcpy(ptr, &size, 4); ptr += 4; *(unsigned int *)(ptr) = __size_driverControls; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(num, __size_num); if (useChecksum) checksumCalculator->addBuffer(num, __size_num); stream->readback(driverControls, __size_driverControls); if (useChecksum) checksumCalculator->addBuffer(driverControls, __size_driverControls); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetDriverControlsQCOM: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetDriverControlStringQCOM_enc(void *self , GLuint driverControl, GLsizei bufSize, GLsizei* length, GLchar* driverControlString) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_length = (1 * sizeof(GLsizei)); const unsigned int __size_driverControlString = (1 * sizeof(GLchar)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_length + __size_driverControlString + 2*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetDriverControlStringQCOM;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &driverControl, 4); ptr += 4; memcpy(ptr, &bufSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_length; ptr += 4; *(unsigned int *)(ptr) = __size_driverControlString; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(length, __size_length); if (useChecksum) checksumCalculator->addBuffer(length, __size_length); stream->readback(driverControlString, __size_driverControlString); if (useChecksum) checksumCalculator->addBuffer(driverControlString, __size_driverControlString); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetDriverControlStringQCOM: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glEnableDriverControlQCOM_enc(void *self , GLuint driverControl) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glEnableDriverControlQCOM;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &driverControl, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDisableDriverControlQCOM_enc(void *self , GLuint driverControl) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDisableDriverControlQCOM;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &driverControl, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glExtGetTexturesQCOM_enc(void *self , GLuint* textures, GLint maxTextures, GLint* numTextures) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_textures = (maxTextures * sizeof(GLuint)); const unsigned int __size_numTextures = (1 * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_textures + 4 + __size_numTextures + 2*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glExtGetTexturesQCOM;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_textures; ptr += 4; memcpy(ptr, &maxTextures, 4); ptr += 4; *(unsigned int *)(ptr) = __size_numTextures; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(textures, __size_textures); if (useChecksum) checksumCalculator->addBuffer(textures, __size_textures); stream->readback(numTextures, __size_numTextures); if (useChecksum) checksumCalculator->addBuffer(numTextures, __size_numTextures); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glExtGetTexturesQCOM: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glExtGetBuffersQCOM_enc(void *self , GLuint* buffers, GLint maxBuffers, GLint* numBuffers) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_buffers = (maxBuffers * sizeof(GLuint)); const unsigned int __size_numBuffers = (1 * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_buffers + 4 + __size_numBuffers + 2*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glExtGetBuffersQCOM;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_buffers; ptr += 4; memcpy(ptr, &maxBuffers, 4); ptr += 4; *(unsigned int *)(ptr) = __size_numBuffers; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(buffers, __size_buffers); if (useChecksum) checksumCalculator->addBuffer(buffers, __size_buffers); stream->readback(numBuffers, __size_numBuffers); if (useChecksum) checksumCalculator->addBuffer(numBuffers, __size_numBuffers); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glExtGetBuffersQCOM: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glExtGetRenderbuffersQCOM_enc(void *self , GLuint* renderbuffers, GLint maxRenderbuffers, GLint* numRenderbuffers) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_renderbuffers = (maxRenderbuffers * sizeof(GLuint)); const unsigned int __size_numRenderbuffers = (1 * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_renderbuffers + 4 + __size_numRenderbuffers + 2*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glExtGetRenderbuffersQCOM;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_renderbuffers; ptr += 4; memcpy(ptr, &maxRenderbuffers, 4); ptr += 4; *(unsigned int *)(ptr) = __size_numRenderbuffers; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(renderbuffers, __size_renderbuffers); if (useChecksum) checksumCalculator->addBuffer(renderbuffers, __size_renderbuffers); stream->readback(numRenderbuffers, __size_numRenderbuffers); if (useChecksum) checksumCalculator->addBuffer(numRenderbuffers, __size_numRenderbuffers); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glExtGetRenderbuffersQCOM: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glExtGetFramebuffersQCOM_enc(void *self , GLuint* framebuffers, GLint maxFramebuffers, GLint* numFramebuffers) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_framebuffers = (maxFramebuffers * sizeof(GLuint)); const unsigned int __size_numFramebuffers = (1 * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_framebuffers + 4 + __size_numFramebuffers + 2*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glExtGetFramebuffersQCOM;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_framebuffers; ptr += 4; memcpy(ptr, &maxFramebuffers, 4); ptr += 4; *(unsigned int *)(ptr) = __size_numFramebuffers; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(framebuffers, __size_framebuffers); if (useChecksum) checksumCalculator->addBuffer(framebuffers, __size_framebuffers); stream->readback(numFramebuffers, __size_numFramebuffers); if (useChecksum) checksumCalculator->addBuffer(numFramebuffers, __size_numFramebuffers); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glExtGetFramebuffersQCOM: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glExtGetTexLevelParameterivQCOM_enc(void *self , GLuint texture, GLenum face, GLint level, GLenum pname, GLint* params) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glExtGetTexLevelParameterivQCOM;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &texture, 4); ptr += 4; memcpy(ptr, &face, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glExtGetTexLevelParameterivQCOM: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glExtTexObjectStateOverrideiQCOM_enc(void *self , GLenum target, GLenum pname, GLint param) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glExtTexObjectStateOverrideiQCOM;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glExtGetTexSubImageQCOM_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid* texels) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_texels = (depth * glesv1_enc::pixelDataSize(self, width, height, format, type, 0)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_texels + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glExtGetTexSubImageQCOM;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; memcpy(ptr, &xoffset, 4); ptr += 4; memcpy(ptr, &yoffset, 4); ptr += 4; memcpy(ptr, &zoffset, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; memcpy(ptr, &depth, 4); ptr += 4; memcpy(ptr, &format, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; *(unsigned int *)(ptr) = __size_texels; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(texels, __size_texels); if (useChecksum) checksumCalculator->addBuffer(texels, __size_texels); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glExtGetTexSubImageQCOM: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glExtGetShadersQCOM_enc(void *self , GLuint* shaders, GLint maxShaders, GLint* numShaders) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_shaders = (maxShaders * sizeof(GLuint)); const unsigned int __size_numShaders = (1 * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_shaders + 4 + __size_numShaders + 2*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glExtGetShadersQCOM;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_shaders; ptr += 4; memcpy(ptr, &maxShaders, 4); ptr += 4; *(unsigned int *)(ptr) = __size_numShaders; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(shaders, __size_shaders); if (useChecksum) checksumCalculator->addBuffer(shaders, __size_shaders); stream->readback(numShaders, __size_numShaders); if (useChecksum) checksumCalculator->addBuffer(numShaders, __size_numShaders); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glExtGetShadersQCOM: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glExtGetProgramsQCOM_enc(void *self , GLuint* programs, GLint maxPrograms, GLint* numPrograms) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_programs = (maxPrograms * sizeof(GLuint)); const unsigned int __size_numPrograms = (1 * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_programs + 4 + __size_numPrograms + 2*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glExtGetProgramsQCOM;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_programs; ptr += 4; memcpy(ptr, &maxPrograms, 4); ptr += 4; *(unsigned int *)(ptr) = __size_numPrograms; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(programs, __size_programs); if (useChecksum) checksumCalculator->addBuffer(programs, __size_programs); stream->readback(numPrograms, __size_numPrograms); if (useChecksum) checksumCalculator->addBuffer(numPrograms, __size_numPrograms); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glExtGetProgramsQCOM: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } GLboolean glExtIsProgramBinaryQCOM_enc(void *self , GLuint program) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glExtIsProgramBinaryQCOM;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &program, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLboolean retval; stream->readback(&retval, 1); if (useChecksum) checksumCalculator->addBuffer(&retval, 1); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glExtIsProgramBinaryQCOM: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void glStartTilingQCOM_enc(void *self , GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glStartTilingQCOM;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; memcpy(ptr, &preserveMask, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glEndTilingQCOM_enc(void *self , GLbitfield preserveMask) { gl_encoder_context_t *ctx = (gl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glEndTilingQCOM;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &preserveMask, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } } // namespace gl_encoder_context_t::gl_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator) { m_stream = stream; m_checksumCalculator = checksumCalculator; this->glAlphaFunc = &glAlphaFunc_enc; this->glClearColor = &glClearColor_enc; this->glClearDepthf = &glClearDepthf_enc; this->glClipPlanef = &glClipPlanef_enc; this->glColor4f = &glColor4f_enc; this->glDepthRangef = &glDepthRangef_enc; this->glFogf = &glFogf_enc; this->glFogfv = &glFogfv_enc; this->glFrustumf = &glFrustumf_enc; this->glGetClipPlanef = &glGetClipPlanef_enc; this->glGetFloatv = &glGetFloatv_enc; this->glGetLightfv = &glGetLightfv_enc; this->glGetMaterialfv = &glGetMaterialfv_enc; this->glGetTexEnvfv = &glGetTexEnvfv_enc; this->glGetTexParameterfv = &glGetTexParameterfv_enc; this->glLightModelf = &glLightModelf_enc; this->glLightModelfv = &glLightModelfv_enc; this->glLightf = &glLightf_enc; this->glLightfv = &glLightfv_enc; this->glLineWidth = &glLineWidth_enc; this->glLoadMatrixf = &glLoadMatrixf_enc; this->glMaterialf = &glMaterialf_enc; this->glMaterialfv = &glMaterialfv_enc; this->glMultMatrixf = &glMultMatrixf_enc; this->glMultiTexCoord4f = &glMultiTexCoord4f_enc; this->glNormal3f = &glNormal3f_enc; this->glOrthof = &glOrthof_enc; this->glPointParameterf = &glPointParameterf_enc; this->glPointParameterfv = &glPointParameterfv_enc; this->glPointSize = &glPointSize_enc; this->glPolygonOffset = &glPolygonOffset_enc; this->glRotatef = &glRotatef_enc; this->glScalef = &glScalef_enc; this->glTexEnvf = &glTexEnvf_enc; this->glTexEnvfv = &glTexEnvfv_enc; this->glTexParameterf = &glTexParameterf_enc; this->glTexParameterfv = &glTexParameterfv_enc; this->glTranslatef = &glTranslatef_enc; this->glActiveTexture = &glActiveTexture_enc; this->glAlphaFuncx = &glAlphaFuncx_enc; this->glBindBuffer = &glBindBuffer_enc; this->glBindTexture = &glBindTexture_enc; this->glBlendFunc = &glBlendFunc_enc; this->glBufferData = &glBufferData_enc; this->glBufferSubData = &glBufferSubData_enc; this->glClear = &glClear_enc; this->glClearColorx = &glClearColorx_enc; this->glClearDepthx = &glClearDepthx_enc; this->glClearStencil = &glClearStencil_enc; this->glClientActiveTexture = &glClientActiveTexture_enc; this->glColor4ub = &glColor4ub_enc; this->glColor4x = &glColor4x_enc; this->glColorMask = &glColorMask_enc; this->glColorPointer = (glColorPointer_client_proc_t) &enc_unsupported; this->glCompressedTexImage2D = &glCompressedTexImage2D_enc; this->glCompressedTexSubImage2D = &glCompressedTexSubImage2D_enc; this->glCopyTexImage2D = &glCopyTexImage2D_enc; this->glCopyTexSubImage2D = &glCopyTexSubImage2D_enc; this->glCullFace = &glCullFace_enc; this->glDeleteBuffers = &glDeleteBuffers_enc; this->glDeleteTextures = &glDeleteTextures_enc; this->glDepthFunc = &glDepthFunc_enc; this->glDepthMask = &glDepthMask_enc; this->glDepthRangex = &glDepthRangex_enc; this->glDisable = &glDisable_enc; this->glDisableClientState = &glDisableClientState_enc; this->glDrawArrays = &glDrawArrays_enc; this->glDrawElements = (glDrawElements_client_proc_t) &enc_unsupported; this->glEnable = &glEnable_enc; this->glEnableClientState = &glEnableClientState_enc; this->glFinish = &glFinish_enc; this->glFlush = &glFlush_enc; this->glFogx = &glFogx_enc; this->glFogxv = &glFogxv_enc; this->glFrontFace = &glFrontFace_enc; this->glFrustumx = &glFrustumx_enc; this->glGetBooleanv = &glGetBooleanv_enc; this->glGetBufferParameteriv = &glGetBufferParameteriv_enc; this->glClipPlanex = &glClipPlanex_enc; this->glGenBuffers = &glGenBuffers_enc; this->glGenTextures = &glGenTextures_enc; this->glGetError = &glGetError_enc; this->glGetFixedv = &glGetFixedv_enc; this->glGetIntegerv = &glGetIntegerv_enc; this->glGetLightxv = &glGetLightxv_enc; this->glGetMaterialxv = &glGetMaterialxv_enc; this->glGetPointerv = (glGetPointerv_client_proc_t) &enc_unsupported; this->glGetString = (glGetString_client_proc_t) &enc_unsupported; this->glGetTexEnviv = &glGetTexEnviv_enc; this->glGetTexEnvxv = &glGetTexEnvxv_enc; this->glGetTexParameteriv = &glGetTexParameteriv_enc; this->glGetTexParameterxv = &glGetTexParameterxv_enc; this->glHint = &glHint_enc; this->glIsBuffer = &glIsBuffer_enc; this->glIsEnabled = &glIsEnabled_enc; this->glIsTexture = &glIsTexture_enc; this->glLightModelx = &glLightModelx_enc; this->glLightModelxv = &glLightModelxv_enc; this->glLightx = &glLightx_enc; this->glLightxv = &glLightxv_enc; this->glLineWidthx = &glLineWidthx_enc; this->glLoadIdentity = &glLoadIdentity_enc; this->glLoadMatrixx = &glLoadMatrixx_enc; this->glLogicOp = &glLogicOp_enc; this->glMaterialx = &glMaterialx_enc; this->glMaterialxv = &glMaterialxv_enc; this->glMatrixMode = &glMatrixMode_enc; this->glMultMatrixx = &glMultMatrixx_enc; this->glMultiTexCoord4x = &glMultiTexCoord4x_enc; this->glNormal3x = &glNormal3x_enc; this->glNormalPointer = (glNormalPointer_client_proc_t) &enc_unsupported; this->glOrthox = &glOrthox_enc; this->glPixelStorei = &glPixelStorei_enc; this->glPointParameterx = &glPointParameterx_enc; this->glPointParameterxv = &glPointParameterxv_enc; this->glPointSizex = &glPointSizex_enc; this->glPolygonOffsetx = &glPolygonOffsetx_enc; this->glPopMatrix = &glPopMatrix_enc; this->glPushMatrix = &glPushMatrix_enc; this->glReadPixels = &glReadPixels_enc; this->glRotatex = &glRotatex_enc; this->glSampleCoverage = &glSampleCoverage_enc; this->glSampleCoveragex = &glSampleCoveragex_enc; this->glScalex = &glScalex_enc; this->glScissor = &glScissor_enc; this->glShadeModel = &glShadeModel_enc; this->glStencilFunc = &glStencilFunc_enc; this->glStencilMask = &glStencilMask_enc; this->glStencilOp = &glStencilOp_enc; this->glTexCoordPointer = (glTexCoordPointer_client_proc_t) &enc_unsupported; this->glTexEnvi = &glTexEnvi_enc; this->glTexEnvx = &glTexEnvx_enc; this->glTexEnviv = &glTexEnviv_enc; this->glTexEnvxv = &glTexEnvxv_enc; this->glTexImage2D = &glTexImage2D_enc; this->glTexParameteri = &glTexParameteri_enc; this->glTexParameterx = &glTexParameterx_enc; this->glTexParameteriv = &glTexParameteriv_enc; this->glTexParameterxv = &glTexParameterxv_enc; this->glTexSubImage2D = &glTexSubImage2D_enc; this->glTranslatex = &glTranslatex_enc; this->glVertexPointer = (glVertexPointer_client_proc_t) &enc_unsupported; this->glViewport = &glViewport_enc; this->glPointSizePointerOES = (glPointSizePointerOES_client_proc_t) &enc_unsupported; this->glVertexPointerOffset = &glVertexPointerOffset_enc; this->glColorPointerOffset = &glColorPointerOffset_enc; this->glNormalPointerOffset = &glNormalPointerOffset_enc; this->glPointSizePointerOffset = &glPointSizePointerOffset_enc; this->glTexCoordPointerOffset = &glTexCoordPointerOffset_enc; this->glWeightPointerOffset = &glWeightPointerOffset_enc; this->glMatrixIndexPointerOffset = &glMatrixIndexPointerOffset_enc; this->glVertexPointerData = &glVertexPointerData_enc; this->glColorPointerData = &glColorPointerData_enc; this->glNormalPointerData = &glNormalPointerData_enc; this->glTexCoordPointerData = &glTexCoordPointerData_enc; this->glPointSizePointerData = &glPointSizePointerData_enc; this->glWeightPointerData = &glWeightPointerData_enc; this->glMatrixIndexPointerData = &glMatrixIndexPointerData_enc; this->glDrawElementsOffset = &glDrawElementsOffset_enc; this->glDrawElementsData = &glDrawElementsData_enc; this->glGetCompressedTextureFormats = &glGetCompressedTextureFormats_enc; this->glFinishRoundTrip = &glFinishRoundTrip_enc; this->glBlendEquationSeparateOES = &glBlendEquationSeparateOES_enc; this->glBlendFuncSeparateOES = &glBlendFuncSeparateOES_enc; this->glBlendEquationOES = &glBlendEquationOES_enc; this->glDrawTexsOES = &glDrawTexsOES_enc; this->glDrawTexiOES = &glDrawTexiOES_enc; this->glDrawTexxOES = &glDrawTexxOES_enc; this->glDrawTexsvOES = &glDrawTexsvOES_enc; this->glDrawTexivOES = &glDrawTexivOES_enc; this->glDrawTexxvOES = &glDrawTexxvOES_enc; this->glDrawTexfOES = &glDrawTexfOES_enc; this->glDrawTexfvOES = &glDrawTexfvOES_enc; this->glEGLImageTargetTexture2DOES = &glEGLImageTargetTexture2DOES_enc; this->glEGLImageTargetRenderbufferStorageOES = &glEGLImageTargetRenderbufferStorageOES_enc; this->glAlphaFuncxOES = &glAlphaFuncxOES_enc; this->glClearColorxOES = &glClearColorxOES_enc; this->glClearDepthxOES = &glClearDepthxOES_enc; this->glClipPlanexOES = &glClipPlanexOES_enc; this->glClipPlanexIMG = &glClipPlanexIMG_enc; this->glColor4xOES = &glColor4xOES_enc; this->glDepthRangexOES = &glDepthRangexOES_enc; this->glFogxOES = &glFogxOES_enc; this->glFogxvOES = &glFogxvOES_enc; this->glFrustumxOES = &glFrustumxOES_enc; this->glGetClipPlanexOES = &glGetClipPlanexOES_enc; this->glGetClipPlanex = &glGetClipPlanex_enc; this->glGetFixedvOES = &glGetFixedvOES_enc; this->glGetLightxvOES = &glGetLightxvOES_enc; this->glGetMaterialxvOES = &glGetMaterialxvOES_enc; this->glGetTexEnvxvOES = &glGetTexEnvxvOES_enc; this->glGetTexParameterxvOES = &glGetTexParameterxvOES_enc; this->glLightModelxOES = &glLightModelxOES_enc; this->glLightModelxvOES = &glLightModelxvOES_enc; this->glLightxOES = &glLightxOES_enc; this->glLightxvOES = &glLightxvOES_enc; this->glLineWidthxOES = &glLineWidthxOES_enc; this->glLoadMatrixxOES = &glLoadMatrixxOES_enc; this->glMaterialxOES = &glMaterialxOES_enc; this->glMaterialxvOES = &glMaterialxvOES_enc; this->glMultMatrixxOES = &glMultMatrixxOES_enc; this->glMultiTexCoord4xOES = &glMultiTexCoord4xOES_enc; this->glNormal3xOES = &glNormal3xOES_enc; this->glOrthoxOES = &glOrthoxOES_enc; this->glPointParameterxOES = &glPointParameterxOES_enc; this->glPointParameterxvOES = &glPointParameterxvOES_enc; this->glPointSizexOES = &glPointSizexOES_enc; this->glPolygonOffsetxOES = &glPolygonOffsetxOES_enc; this->glRotatexOES = &glRotatexOES_enc; this->glSampleCoveragexOES = &glSampleCoveragexOES_enc; this->glScalexOES = &glScalexOES_enc; this->glTexEnvxOES = &glTexEnvxOES_enc; this->glTexEnvxvOES = &glTexEnvxvOES_enc; this->glTexParameterxOES = &glTexParameterxOES_enc; this->glTexParameterxvOES = &glTexParameterxvOES_enc; this->glTranslatexOES = &glTranslatexOES_enc; this->glIsRenderbufferOES = &glIsRenderbufferOES_enc; this->glBindRenderbufferOES = &glBindRenderbufferOES_enc; this->glDeleteRenderbuffersOES = &glDeleteRenderbuffersOES_enc; this->glGenRenderbuffersOES = &glGenRenderbuffersOES_enc; this->glRenderbufferStorageOES = &glRenderbufferStorageOES_enc; this->glGetRenderbufferParameterivOES = &glGetRenderbufferParameterivOES_enc; this->glIsFramebufferOES = &glIsFramebufferOES_enc; this->glBindFramebufferOES = &glBindFramebufferOES_enc; this->glDeleteFramebuffersOES = &glDeleteFramebuffersOES_enc; this->glGenFramebuffersOES = &glGenFramebuffersOES_enc; this->glCheckFramebufferStatusOES = &glCheckFramebufferStatusOES_enc; this->glFramebufferRenderbufferOES = &glFramebufferRenderbufferOES_enc; this->glFramebufferTexture2DOES = &glFramebufferTexture2DOES_enc; this->glGetFramebufferAttachmentParameterivOES = &glGetFramebufferAttachmentParameterivOES_enc; this->glGenerateMipmapOES = &glGenerateMipmapOES_enc; this->glMapBufferOES = (glMapBufferOES_client_proc_t) &enc_unsupported; this->glUnmapBufferOES = &glUnmapBufferOES_enc; this->glGetBufferPointervOES = (glGetBufferPointervOES_client_proc_t) &enc_unsupported; this->glCurrentPaletteMatrixOES = &glCurrentPaletteMatrixOES_enc; this->glLoadPaletteFromModelViewMatrixOES = &glLoadPaletteFromModelViewMatrixOES_enc; this->glMatrixIndexPointerOES = (glMatrixIndexPointerOES_client_proc_t) &enc_unsupported; this->glWeightPointerOES = (glWeightPointerOES_client_proc_t) &enc_unsupported; this->glQueryMatrixxOES = &glQueryMatrixxOES_enc; this->glDepthRangefOES = &glDepthRangefOES_enc; this->glFrustumfOES = &glFrustumfOES_enc; this->glOrthofOES = &glOrthofOES_enc; this->glClipPlanefOES = &glClipPlanefOES_enc; this->glClipPlanefIMG = &glClipPlanefIMG_enc; this->glGetClipPlanefOES = &glGetClipPlanefOES_enc; this->glClearDepthfOES = &glClearDepthfOES_enc; this->glTexGenfOES = &glTexGenfOES_enc; this->glTexGenfvOES = &glTexGenfvOES_enc; this->glTexGeniOES = &glTexGeniOES_enc; this->glTexGenivOES = &glTexGenivOES_enc; this->glTexGenxOES = &glTexGenxOES_enc; this->glTexGenxvOES = &glTexGenxvOES_enc; this->glGetTexGenfvOES = &glGetTexGenfvOES_enc; this->glGetTexGenivOES = &glGetTexGenivOES_enc; this->glGetTexGenxvOES = &glGetTexGenxvOES_enc; this->glBindVertexArrayOES = &glBindVertexArrayOES_enc; this->glDeleteVertexArraysOES = &glDeleteVertexArraysOES_enc; this->glGenVertexArraysOES = &glGenVertexArraysOES_enc; this->glIsVertexArrayOES = &glIsVertexArrayOES_enc; this->glDiscardFramebufferEXT = &glDiscardFramebufferEXT_enc; this->glMultiDrawArraysEXT = (glMultiDrawArraysEXT_client_proc_t) &enc_unsupported; this->glMultiDrawElementsEXT = (glMultiDrawElementsEXT_client_proc_t) &enc_unsupported; this->glMultiDrawArraysSUN = (glMultiDrawArraysSUN_client_proc_t) &enc_unsupported; this->glMultiDrawElementsSUN = (glMultiDrawElementsSUN_client_proc_t) &enc_unsupported; this->glRenderbufferStorageMultisampleIMG = &glRenderbufferStorageMultisampleIMG_enc; this->glFramebufferTexture2DMultisampleIMG = &glFramebufferTexture2DMultisampleIMG_enc; this->glDeleteFencesNV = &glDeleteFencesNV_enc; this->glGenFencesNV = &glGenFencesNV_enc; this->glIsFenceNV = &glIsFenceNV_enc; this->glTestFenceNV = &glTestFenceNV_enc; this->glGetFenceivNV = &glGetFenceivNV_enc; this->glFinishFenceNV = &glFinishFenceNV_enc; this->glSetFenceNV = &glSetFenceNV_enc; this->glGetDriverControlsQCOM = &glGetDriverControlsQCOM_enc; this->glGetDriverControlStringQCOM = &glGetDriverControlStringQCOM_enc; this->glEnableDriverControlQCOM = &glEnableDriverControlQCOM_enc; this->glDisableDriverControlQCOM = &glDisableDriverControlQCOM_enc; this->glExtGetTexturesQCOM = &glExtGetTexturesQCOM_enc; this->glExtGetBuffersQCOM = &glExtGetBuffersQCOM_enc; this->glExtGetRenderbuffersQCOM = &glExtGetRenderbuffersQCOM_enc; this->glExtGetFramebuffersQCOM = &glExtGetFramebuffersQCOM_enc; this->glExtGetTexLevelParameterivQCOM = &glExtGetTexLevelParameterivQCOM_enc; this->glExtTexObjectStateOverrideiQCOM = &glExtTexObjectStateOverrideiQCOM_enc; this->glExtGetTexSubImageQCOM = &glExtGetTexSubImageQCOM_enc; this->glExtGetBufferPointervQCOM = (glExtGetBufferPointervQCOM_client_proc_t) &enc_unsupported; this->glExtGetShadersQCOM = &glExtGetShadersQCOM_enc; this->glExtGetProgramsQCOM = &glExtGetProgramsQCOM_enc; this->glExtIsProgramBinaryQCOM = &glExtIsProgramBinaryQCOM_enc; this->glExtGetProgramBinarySourceQCOM = (glExtGetProgramBinarySourceQCOM_client_proc_t) &enc_unsupported; this->glStartTilingQCOM = &glStartTilingQCOM_enc; this->glEndTilingQCOM = &glEndTilingQCOM_enc; } anbox-0.0~git20191115/android/opengl/system/GLESv1_enc/gl_enc.h000066400000000000000000000010041356361734700236760ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef GUARD_gl_encoder_context_t #define GUARD_gl_encoder_context_t #include "IOStream.h" #include "ChecksumCalculator.h" #include "gl_client_context.h" #include "glUtils.h" #include "GLEncoderUtils.h" struct gl_encoder_context_t : public gl_client_context_t { IOStream *m_stream; ChecksumCalculator *m_checksumCalculator; gl_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator); }; #endif // GUARD_gl_encoder_context_tanbox-0.0~git20191115/android/opengl/system/GLESv1_enc/gl_entry.cpp000066400000000000000000001635051356361734700246440ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #include #include #include "gl_client_context.h" #ifndef GL_TRUE extern "C" { void glAlphaFunc(GLenum func, GLclampf ref); void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); void glClearDepthf(GLclampf depth); void glClipPlanef(GLenum plane, const GLfloat* equation); void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); void glDepthRangef(GLclampf zNear, GLclampf zFar); void glFogf(GLenum pname, GLfloat param); void glFogfv(GLenum pname, const GLfloat* params); void glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar); void glGetClipPlanef(GLenum pname, GLfloat* eqn); void glGetFloatv(GLenum pname, GLfloat* params); void glGetLightfv(GLenum light, GLenum pname, GLfloat* params); void glGetMaterialfv(GLenum face, GLenum pname, GLfloat* params); void glGetTexEnvfv(GLenum env, GLenum pname, GLfloat* params); void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params); void glLightModelf(GLenum pname, GLfloat param); void glLightModelfv(GLenum pname, const GLfloat* params); void glLightf(GLenum light, GLenum pname, GLfloat param); void glLightfv(GLenum light, GLenum pname, const GLfloat* params); void glLineWidth(GLfloat width); void glLoadMatrixf(const GLfloat* m); void glMaterialf(GLenum face, GLenum pname, GLfloat param); void glMaterialfv(GLenum face, GLenum pname, const GLfloat* params); void glMultMatrixf(const GLfloat* m); void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz); void glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar); void glPointParameterf(GLenum pname, GLfloat param); void glPointParameterfv(GLenum pname, const GLfloat* params); void glPointSize(GLfloat size); void glPolygonOffset(GLfloat factor, GLfloat units); void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); void glScalef(GLfloat x, GLfloat y, GLfloat z); void glTexEnvf(GLenum target, GLenum pname, GLfloat param); void glTexEnvfv(GLenum target, GLenum pname, const GLfloat* params); void glTexParameterf(GLenum target, GLenum pname, GLfloat param); void glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params); void glTranslatef(GLfloat x, GLfloat y, GLfloat z); void glActiveTexture(GLenum texture); void glAlphaFuncx(GLenum func, GLclampx ref); void glBindBuffer(GLenum target, GLuint buffer); void glBindTexture(GLenum target, GLuint texture); void glBlendFunc(GLenum sfactor, GLenum dfactor); void glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); void glClear(GLbitfield mask); void glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha); void glClearDepthx(GLclampx depth); void glClearStencil(GLint s); void glClientActiveTexture(GLenum texture); void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); void glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha); void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer); void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); void glCullFace(GLenum mode); void glDeleteBuffers(GLsizei n, const GLuint* buffers); void glDeleteTextures(GLsizei n, const GLuint* textures); void glDepthFunc(GLenum func); void glDepthMask(GLboolean flag); void glDepthRangex(GLclampx zNear, GLclampx zFar); void glDisable(GLenum cap); void glDisableClientState(GLenum array); void glDrawArrays(GLenum mode, GLint first, GLsizei count); void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices); void glEnable(GLenum cap); void glEnableClientState(GLenum array); void glFinish(); void glFlush(); void glFogx(GLenum pname, GLfixed param); void glFogxv(GLenum pname, const GLfixed* params); void glFrontFace(GLenum mode); void glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar); void glGetBooleanv(GLenum pname, GLboolean* params); void glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params); void glClipPlanex(GLenum pname, const GLfixed* eqn); void glGenBuffers(GLsizei n, GLuint* buffers); void glGenTextures(GLsizei n, GLuint* textures); GLenum glGetError(); void glGetFixedv(GLenum pname, GLfixed* params); void glGetIntegerv(GLenum pname, GLint* params); void glGetLightxv(GLenum light, GLenum pname, GLfixed* params); void glGetMaterialxv(GLenum face, GLenum pname, GLfixed* params); void glGetPointerv(GLenum pname, GLvoid** params); const GLubyte* glGetString(GLenum name); void glGetTexEnviv(GLenum env, GLenum pname, GLint* params); void glGetTexEnvxv(GLenum env, GLenum pname, GLfixed* params); void glGetTexParameteriv(GLenum target, GLenum pname, GLint* params); void glGetTexParameterxv(GLenum target, GLenum pname, GLfixed* params); void glHint(GLenum target, GLenum mode); GLboolean glIsBuffer(GLuint buffer); GLboolean glIsEnabled(GLenum cap); GLboolean glIsTexture(GLuint texture); void glLightModelx(GLenum pname, GLfixed param); void glLightModelxv(GLenum pname, const GLfixed* params); void glLightx(GLenum light, GLenum pname, GLfixed param); void glLightxv(GLenum light, GLenum pname, const GLfixed* params); void glLineWidthx(GLfixed width); void glLoadIdentity(); void glLoadMatrixx(const GLfixed* m); void glLogicOp(GLenum opcode); void glMaterialx(GLenum face, GLenum pname, GLfixed param); void glMaterialxv(GLenum face, GLenum pname, const GLfixed* params); void glMatrixMode(GLenum mode); void glMultMatrixx(const GLfixed* m); void glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q); void glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz); void glNormalPointer(GLenum type, GLsizei stride, const GLvoid* pointer); void glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar); void glPixelStorei(GLenum pname, GLint param); void glPointParameterx(GLenum pname, GLfixed param); void glPointParameterxv(GLenum pname, const GLfixed* params); void glPointSizex(GLfixed size); void glPolygonOffsetx(GLfixed factor, GLfixed units); void glPopMatrix(); void glPushMatrix(); void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels); void glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z); void glSampleCoverage(GLclampf value, GLboolean invert); void glSampleCoveragex(GLclampx value, GLboolean invert); void glScalex(GLfixed x, GLfixed y, GLfixed z); void glScissor(GLint x, GLint y, GLsizei width, GLsizei height); void glShadeModel(GLenum mode); void glStencilFunc(GLenum func, GLint ref, GLuint mask); void glStencilMask(GLuint mask); void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass); void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer); void glTexEnvi(GLenum target, GLenum pname, GLint param); void glTexEnvx(GLenum target, GLenum pname, GLfixed param); void glTexEnviv(GLenum target, GLenum pname, const GLint* params); void glTexEnvxv(GLenum target, GLenum pname, const GLfixed* params); void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels); void glTexParameteri(GLenum target, GLenum pname, GLint param); void glTexParameterx(GLenum target, GLenum pname, GLfixed param); void glTexParameteriv(GLenum target, GLenum pname, const GLint* params); void glTexParameterxv(GLenum target, GLenum pname, const GLfixed* params); void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels); void glTranslatex(GLfixed x, GLfixed y, GLfixed z); void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer); void glViewport(GLint x, GLint y, GLsizei width, GLsizei height); void glPointSizePointerOES(GLenum type, GLsizei stride, const GLvoid* pointer); void glVertexPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset); void glColorPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset); void glNormalPointerOffset(GLenum type, GLsizei stride, GLuint offset); void glPointSizePointerOffset(GLenum type, GLsizei stride, GLuint offset); void glTexCoordPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset); void glWeightPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset); void glMatrixIndexPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset); void glVertexPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen); void glColorPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen); void glNormalPointerData(GLenum type, GLsizei stride, void* data, GLuint datalen); void glTexCoordPointerData(GLint unit, GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen); void glPointSizePointerData(GLenum type, GLsizei stride, void* data, GLuint datalen); void glWeightPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen); void glMatrixIndexPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen); void glDrawElementsOffset(GLenum mode, GLsizei count, GLenum type, GLuint offset); void glDrawElementsData(GLenum mode, GLsizei count, GLenum type, void* data, GLuint datalen); void glGetCompressedTextureFormats(int count, GLint* formats); int glFinishRoundTrip(); void glBlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha); void glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); void glBlendEquationOES(GLenum mode); void glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height); void glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height); void glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height); void glDrawTexsvOES(const GLshort* coords); void glDrawTexivOES(const GLint* coords); void glDrawTexxvOES(const GLfixed* coords); void glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height); void glDrawTexfvOES(const GLfloat* coords); void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image); void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image); void glAlphaFuncxOES(GLenum func, GLclampx ref); void glClearColorxOES(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha); void glClearDepthxOES(GLclampx depth); void glClipPlanexOES(GLenum plane, const GLfixed* equation); void glClipPlanexIMG(GLenum plane, const GLfixed* equation); void glColor4xOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha); void glDepthRangexOES(GLclampx zNear, GLclampx zFar); void glFogxOES(GLenum pname, GLfixed param); void glFogxvOES(GLenum pname, const GLfixed* params); void glFrustumxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar); void glGetClipPlanexOES(GLenum pname, GLfixed* eqn); void glGetClipPlanex(GLenum pname, GLfixed* eqn); void glGetFixedvOES(GLenum pname, GLfixed* params); void glGetLightxvOES(GLenum light, GLenum pname, GLfixed* params); void glGetMaterialxvOES(GLenum face, GLenum pname, GLfixed* params); void glGetTexEnvxvOES(GLenum env, GLenum pname, GLfixed* params); void glGetTexParameterxvOES(GLenum target, GLenum pname, GLfixed* params); void glLightModelxOES(GLenum pname, GLfixed param); void glLightModelxvOES(GLenum pname, const GLfixed* params); void glLightxOES(GLenum light, GLenum pname, GLfixed param); void glLightxvOES(GLenum light, GLenum pname, const GLfixed* params); void glLineWidthxOES(GLfixed width); void glLoadMatrixxOES(const GLfixed* m); void glMaterialxOES(GLenum face, GLenum pname, GLfixed param); void glMaterialxvOES(GLenum face, GLenum pname, const GLfixed* params); void glMultMatrixxOES(const GLfixed* m); void glMultiTexCoord4xOES(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q); void glNormal3xOES(GLfixed nx, GLfixed ny, GLfixed nz); void glOrthoxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar); void glPointParameterxOES(GLenum pname, GLfixed param); void glPointParameterxvOES(GLenum pname, const GLfixed* params); void glPointSizexOES(GLfixed size); void glPolygonOffsetxOES(GLfixed factor, GLfixed units); void glRotatexOES(GLfixed angle, GLfixed x, GLfixed y, GLfixed z); void glSampleCoveragexOES(GLclampx value, GLboolean invert); void glScalexOES(GLfixed x, GLfixed y, GLfixed z); void glTexEnvxOES(GLenum target, GLenum pname, GLfixed param); void glTexEnvxvOES(GLenum target, GLenum pname, const GLfixed* params); void glTexParameterxOES(GLenum target, GLenum pname, GLfixed param); void glTexParameterxvOES(GLenum target, GLenum pname, const GLfixed* params); void glTranslatexOES(GLfixed x, GLfixed y, GLfixed z); GLboolean glIsRenderbufferOES(GLuint renderbuffer); void glBindRenderbufferOES(GLenum target, GLuint renderbuffer); void glDeleteRenderbuffersOES(GLsizei n, const GLuint* renderbuffers); void glGenRenderbuffersOES(GLsizei n, GLuint* renderbuffers); void glRenderbufferStorageOES(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); void glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint* params); GLboolean glIsFramebufferOES(GLuint framebuffer); void glBindFramebufferOES(GLenum target, GLuint framebuffer); void glDeleteFramebuffersOES(GLsizei n, const GLuint* framebuffers); void glGenFramebuffersOES(GLsizei n, GLuint* framebuffers); GLenum glCheckFramebufferStatusOES(GLenum target); void glFramebufferRenderbufferOES(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); void glFramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); void glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint* params); void glGenerateMipmapOES(GLenum target); void* glMapBufferOES(GLenum target, GLenum access); GLboolean glUnmapBufferOES(GLenum target); void glGetBufferPointervOES(GLenum target, GLenum pname, GLvoid** params); void glCurrentPaletteMatrixOES(GLuint matrixpaletteindex); void glLoadPaletteFromModelViewMatrixOES(); void glMatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer); void glWeightPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer); GLbitfield glQueryMatrixxOES(GLfixed* mantissa, GLint* exponent); void glDepthRangefOES(GLclampf zNear, GLclampf zFar); void glFrustumfOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar); void glOrthofOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar); void glClipPlanefOES(GLenum plane, const GLfloat* equation); void glClipPlanefIMG(GLenum plane, const GLfloat* equation); void glGetClipPlanefOES(GLenum pname, GLfloat* eqn); void glClearDepthfOES(GLclampf depth); void glTexGenfOES(GLenum coord, GLenum pname, GLfloat param); void glTexGenfvOES(GLenum coord, GLenum pname, const GLfloat* params); void glTexGeniOES(GLenum coord, GLenum pname, GLint param); void glTexGenivOES(GLenum coord, GLenum pname, const GLint* params); void glTexGenxOES(GLenum coord, GLenum pname, GLfixed param); void glTexGenxvOES(GLenum coord, GLenum pname, const GLfixed* params); void glGetTexGenfvOES(GLenum coord, GLenum pname, GLfloat* params); void glGetTexGenivOES(GLenum coord, GLenum pname, GLint* params); void glGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed* params); void glBindVertexArrayOES(GLuint array); void glDeleteVertexArraysOES(GLsizei n, const GLuint* arrays); void glGenVertexArraysOES(GLsizei n, GLuint* arrays); GLboolean glIsVertexArrayOES(GLuint array); void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum* attachments); void glMultiDrawArraysEXT(GLenum mode, const GLint* first, const GLsizei* count, GLsizei primcount); void glMultiDrawElementsEXT(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices, GLsizei primcount); void glMultiDrawArraysSUN(GLenum mode, GLint* first, GLsizei* count, GLsizei primcount); void glMultiDrawElementsSUN(GLenum mode, const GLsizei* count, GLenum type, const GLvoid** indices, GLsizei primcount); void glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); void glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples); void glDeleteFencesNV(GLsizei n, const GLuint* fences); void glGenFencesNV(GLsizei n, GLuint* fences); GLboolean glIsFenceNV(GLuint fence); GLboolean glTestFenceNV(GLuint fence); void glGetFenceivNV(GLuint fence, GLenum pname, GLint* params); void glFinishFenceNV(GLuint fence); void glSetFenceNV(GLuint fence, GLenum condition); void glGetDriverControlsQCOM(GLint* num, GLsizei size, GLuint* driverControls); void glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei* length, GLchar* driverControlString); void glEnableDriverControlQCOM(GLuint driverControl); void glDisableDriverControlQCOM(GLuint driverControl); void glExtGetTexturesQCOM(GLuint* textures, GLint maxTextures, GLint* numTextures); void glExtGetBuffersQCOM(GLuint* buffers, GLint maxBuffers, GLint* numBuffers); void glExtGetRenderbuffersQCOM(GLuint* renderbuffers, GLint maxRenderbuffers, GLint* numRenderbuffers); void glExtGetFramebuffersQCOM(GLuint* framebuffers, GLint maxFramebuffers, GLint* numFramebuffers); void glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint* params); void glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param); void glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid* texels); void glExtGetBufferPointervQCOM(GLenum target, GLvoid** params); void glExtGetShadersQCOM(GLuint* shaders, GLint maxShaders, GLint* numShaders); void glExtGetProgramsQCOM(GLuint* programs, GLint maxPrograms, GLint* numPrograms); GLboolean glExtIsProgramBinaryQCOM(GLuint program); void glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar* source, GLint* length); void glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask); void glEndTilingQCOM(GLbitfield preserveMask); }; #endif #ifndef GET_CONTEXT static gl_client_context_t::CONTEXT_ACCESSOR_TYPE *getCurrentContext = NULL; void gl_client_context_t::setContextAccessor(CONTEXT_ACCESSOR_TYPE *f) { getCurrentContext = f; } #define GET_CONTEXT gl_client_context_t * ctx = getCurrentContext() #endif void glAlphaFunc(GLenum func, GLclampf ref) { GET_CONTEXT; ctx->glAlphaFunc(ctx, func, ref); } void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { GET_CONTEXT; ctx->glClearColor(ctx, red, green, blue, alpha); } void glClearDepthf(GLclampf depth) { GET_CONTEXT; ctx->glClearDepthf(ctx, depth); } void glClipPlanef(GLenum plane, const GLfloat* equation) { GET_CONTEXT; ctx->glClipPlanef(ctx, plane, equation); } void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { GET_CONTEXT; ctx->glColor4f(ctx, red, green, blue, alpha); } void glDepthRangef(GLclampf zNear, GLclampf zFar) { GET_CONTEXT; ctx->glDepthRangef(ctx, zNear, zFar); } void glFogf(GLenum pname, GLfloat param) { GET_CONTEXT; ctx->glFogf(ctx, pname, param); } void glFogfv(GLenum pname, const GLfloat* params) { GET_CONTEXT; ctx->glFogfv(ctx, pname, params); } void glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) { GET_CONTEXT; ctx->glFrustumf(ctx, left, right, bottom, top, zNear, zFar); } void glGetClipPlanef(GLenum pname, GLfloat* eqn) { GET_CONTEXT; ctx->glGetClipPlanef(ctx, pname, eqn); } void glGetFloatv(GLenum pname, GLfloat* params) { GET_CONTEXT; ctx->glGetFloatv(ctx, pname, params); } void glGetLightfv(GLenum light, GLenum pname, GLfloat* params) { GET_CONTEXT; ctx->glGetLightfv(ctx, light, pname, params); } void glGetMaterialfv(GLenum face, GLenum pname, GLfloat* params) { GET_CONTEXT; ctx->glGetMaterialfv(ctx, face, pname, params); } void glGetTexEnvfv(GLenum env, GLenum pname, GLfloat* params) { GET_CONTEXT; ctx->glGetTexEnvfv(ctx, env, pname, params); } void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) { GET_CONTEXT; ctx->glGetTexParameterfv(ctx, target, pname, params); } void glLightModelf(GLenum pname, GLfloat param) { GET_CONTEXT; ctx->glLightModelf(ctx, pname, param); } void glLightModelfv(GLenum pname, const GLfloat* params) { GET_CONTEXT; ctx->glLightModelfv(ctx, pname, params); } void glLightf(GLenum light, GLenum pname, GLfloat param) { GET_CONTEXT; ctx->glLightf(ctx, light, pname, param); } void glLightfv(GLenum light, GLenum pname, const GLfloat* params) { GET_CONTEXT; ctx->glLightfv(ctx, light, pname, params); } void glLineWidth(GLfloat width) { GET_CONTEXT; ctx->glLineWidth(ctx, width); } void glLoadMatrixf(const GLfloat* m) { GET_CONTEXT; ctx->glLoadMatrixf(ctx, m); } void glMaterialf(GLenum face, GLenum pname, GLfloat param) { GET_CONTEXT; ctx->glMaterialf(ctx, face, pname, param); } void glMaterialfv(GLenum face, GLenum pname, const GLfloat* params) { GET_CONTEXT; ctx->glMaterialfv(ctx, face, pname, params); } void glMultMatrixf(const GLfloat* m) { GET_CONTEXT; ctx->glMultMatrixf(ctx, m); } void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) { GET_CONTEXT; ctx->glMultiTexCoord4f(ctx, target, s, t, r, q); } void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) { GET_CONTEXT; ctx->glNormal3f(ctx, nx, ny, nz); } void glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) { GET_CONTEXT; ctx->glOrthof(ctx, left, right, bottom, top, zNear, zFar); } void glPointParameterf(GLenum pname, GLfloat param) { GET_CONTEXT; ctx->glPointParameterf(ctx, pname, param); } void glPointParameterfv(GLenum pname, const GLfloat* params) { GET_CONTEXT; ctx->glPointParameterfv(ctx, pname, params); } void glPointSize(GLfloat size) { GET_CONTEXT; ctx->glPointSize(ctx, size); } void glPolygonOffset(GLfloat factor, GLfloat units) { GET_CONTEXT; ctx->glPolygonOffset(ctx, factor, units); } void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) { GET_CONTEXT; ctx->glRotatef(ctx, angle, x, y, z); } void glScalef(GLfloat x, GLfloat y, GLfloat z) { GET_CONTEXT; ctx->glScalef(ctx, x, y, z); } void glTexEnvf(GLenum target, GLenum pname, GLfloat param) { GET_CONTEXT; ctx->glTexEnvf(ctx, target, pname, param); } void glTexEnvfv(GLenum target, GLenum pname, const GLfloat* params) { GET_CONTEXT; ctx->glTexEnvfv(ctx, target, pname, params); } void glTexParameterf(GLenum target, GLenum pname, GLfloat param) { GET_CONTEXT; ctx->glTexParameterf(ctx, target, pname, param); } void glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params) { GET_CONTEXT; ctx->glTexParameterfv(ctx, target, pname, params); } void glTranslatef(GLfloat x, GLfloat y, GLfloat z) { GET_CONTEXT; ctx->glTranslatef(ctx, x, y, z); } void glActiveTexture(GLenum texture) { GET_CONTEXT; ctx->glActiveTexture(ctx, texture); } void glAlphaFuncx(GLenum func, GLclampx ref) { GET_CONTEXT; ctx->glAlphaFuncx(ctx, func, ref); } void glBindBuffer(GLenum target, GLuint buffer) { GET_CONTEXT; ctx->glBindBuffer(ctx, target, buffer); } void glBindTexture(GLenum target, GLuint texture) { GET_CONTEXT; ctx->glBindTexture(ctx, target, texture); } void glBlendFunc(GLenum sfactor, GLenum dfactor) { GET_CONTEXT; ctx->glBlendFunc(ctx, sfactor, dfactor); } void glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) { GET_CONTEXT; ctx->glBufferData(ctx, target, size, data, usage); } void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) { GET_CONTEXT; ctx->glBufferSubData(ctx, target, offset, size, data); } void glClear(GLbitfield mask) { GET_CONTEXT; ctx->glClear(ctx, mask); } void glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) { GET_CONTEXT; ctx->glClearColorx(ctx, red, green, blue, alpha); } void glClearDepthx(GLclampx depth) { GET_CONTEXT; ctx->glClearDepthx(ctx, depth); } void glClearStencil(GLint s) { GET_CONTEXT; ctx->glClearStencil(ctx, s); } void glClientActiveTexture(GLenum texture) { GET_CONTEXT; ctx->glClientActiveTexture(ctx, texture); } void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) { GET_CONTEXT; ctx->glColor4ub(ctx, red, green, blue, alpha); } void glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) { GET_CONTEXT; ctx->glColor4x(ctx, red, green, blue, alpha); } void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) { GET_CONTEXT; ctx->glColorMask(ctx, red, green, blue, alpha); } void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) { GET_CONTEXT; ctx->glColorPointer(ctx, size, type, stride, pointer); } void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) { GET_CONTEXT; ctx->glCompressedTexImage2D(ctx, target, level, internalformat, width, height, border, imageSize, data); } void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) { GET_CONTEXT; ctx->glCompressedTexSubImage2D(ctx, target, level, xoffset, yoffset, width, height, format, imageSize, data); } void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { GET_CONTEXT; ctx->glCopyTexImage2D(ctx, target, level, internalformat, x, y, width, height, border); } void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { GET_CONTEXT; ctx->glCopyTexSubImage2D(ctx, target, level, xoffset, yoffset, x, y, width, height); } void glCullFace(GLenum mode) { GET_CONTEXT; ctx->glCullFace(ctx, mode); } void glDeleteBuffers(GLsizei n, const GLuint* buffers) { GET_CONTEXT; if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } ctx->glDeleteBuffers(ctx, n, buffers); } void glDeleteTextures(GLsizei n, const GLuint* textures) { GET_CONTEXT; if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } ctx->glDeleteTextures(ctx, n, textures); } void glDepthFunc(GLenum func) { GET_CONTEXT; ctx->glDepthFunc(ctx, func); } void glDepthMask(GLboolean flag) { GET_CONTEXT; ctx->glDepthMask(ctx, flag); } void glDepthRangex(GLclampx zNear, GLclampx zFar) { GET_CONTEXT; ctx->glDepthRangex(ctx, zNear, zFar); } void glDisable(GLenum cap) { GET_CONTEXT; ctx->glDisable(ctx, cap); } void glDisableClientState(GLenum array) { GET_CONTEXT; ctx->glDisableClientState(ctx, array); } void glDrawArrays(GLenum mode, GLint first, GLsizei count) { GET_CONTEXT; ctx->glDrawArrays(ctx, mode, first, count); } void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices) { GET_CONTEXT; ctx->glDrawElements(ctx, mode, count, type, indices); } void glEnable(GLenum cap) { GET_CONTEXT; ctx->glEnable(ctx, cap); } void glEnableClientState(GLenum array) { GET_CONTEXT; ctx->glEnableClientState(ctx, array); } void glFinish() { GET_CONTEXT; ctx->glFinish(ctx); } void glFlush() { GET_CONTEXT; ctx->glFlush(ctx); } void glFogx(GLenum pname, GLfixed param) { GET_CONTEXT; ctx->glFogx(ctx, pname, param); } void glFogxv(GLenum pname, const GLfixed* params) { GET_CONTEXT; ctx->glFogxv(ctx, pname, params); } void glFrontFace(GLenum mode) { GET_CONTEXT; ctx->glFrontFace(ctx, mode); } void glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) { GET_CONTEXT; ctx->glFrustumx(ctx, left, right, bottom, top, zNear, zFar); } void glGetBooleanv(GLenum pname, GLboolean* params) { GET_CONTEXT; ctx->glGetBooleanv(ctx, pname, params); } void glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params) { GET_CONTEXT; ctx->glGetBufferParameteriv(ctx, target, pname, params); } void glClipPlanex(GLenum pname, const GLfixed* eqn) { GET_CONTEXT; ctx->glClipPlanex(ctx, pname, eqn); } void glGenBuffers(GLsizei n, GLuint* buffers) { GET_CONTEXT; if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } ctx->glGenBuffers(ctx, n, buffers); } void glGenTextures(GLsizei n, GLuint* textures) { GET_CONTEXT; if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } ctx->glGenTextures(ctx, n, textures); } GLenum glGetError() { GET_CONTEXT; return ctx->glGetError(ctx); } void glGetFixedv(GLenum pname, GLfixed* params) { GET_CONTEXT; ctx->glGetFixedv(ctx, pname, params); } void glGetIntegerv(GLenum pname, GLint* params) { GET_CONTEXT; ctx->glGetIntegerv(ctx, pname, params); } void glGetLightxv(GLenum light, GLenum pname, GLfixed* params) { GET_CONTEXT; ctx->glGetLightxv(ctx, light, pname, params); } void glGetMaterialxv(GLenum face, GLenum pname, GLfixed* params) { GET_CONTEXT; ctx->glGetMaterialxv(ctx, face, pname, params); } void glGetPointerv(GLenum pname, GLvoid** params) { GET_CONTEXT; ctx->glGetPointerv(ctx, pname, params); } const GLubyte* glGetString(GLenum name) { GET_CONTEXT; return ctx->glGetString(ctx, name); } void glGetTexEnviv(GLenum env, GLenum pname, GLint* params) { GET_CONTEXT; ctx->glGetTexEnviv(ctx, env, pname, params); } void glGetTexEnvxv(GLenum env, GLenum pname, GLfixed* params) { GET_CONTEXT; ctx->glGetTexEnvxv(ctx, env, pname, params); } void glGetTexParameteriv(GLenum target, GLenum pname, GLint* params) { GET_CONTEXT; ctx->glGetTexParameteriv(ctx, target, pname, params); } void glGetTexParameterxv(GLenum target, GLenum pname, GLfixed* params) { GET_CONTEXT; ctx->glGetTexParameterxv(ctx, target, pname, params); } void glHint(GLenum target, GLenum mode) { GET_CONTEXT; ctx->glHint(ctx, target, mode); } GLboolean glIsBuffer(GLuint buffer) { GET_CONTEXT; return ctx->glIsBuffer(ctx, buffer); } GLboolean glIsEnabled(GLenum cap) { GET_CONTEXT; return ctx->glIsEnabled(ctx, cap); } GLboolean glIsTexture(GLuint texture) { GET_CONTEXT; return ctx->glIsTexture(ctx, texture); } void glLightModelx(GLenum pname, GLfixed param) { GET_CONTEXT; ctx->glLightModelx(ctx, pname, param); } void glLightModelxv(GLenum pname, const GLfixed* params) { GET_CONTEXT; ctx->glLightModelxv(ctx, pname, params); } void glLightx(GLenum light, GLenum pname, GLfixed param) { GET_CONTEXT; ctx->glLightx(ctx, light, pname, param); } void glLightxv(GLenum light, GLenum pname, const GLfixed* params) { GET_CONTEXT; ctx->glLightxv(ctx, light, pname, params); } void glLineWidthx(GLfixed width) { GET_CONTEXT; ctx->glLineWidthx(ctx, width); } void glLoadIdentity() { GET_CONTEXT; ctx->glLoadIdentity(ctx); } void glLoadMatrixx(const GLfixed* m) { GET_CONTEXT; ctx->glLoadMatrixx(ctx, m); } void glLogicOp(GLenum opcode) { GET_CONTEXT; ctx->glLogicOp(ctx, opcode); } void glMaterialx(GLenum face, GLenum pname, GLfixed param) { GET_CONTEXT; ctx->glMaterialx(ctx, face, pname, param); } void glMaterialxv(GLenum face, GLenum pname, const GLfixed* params) { GET_CONTEXT; ctx->glMaterialxv(ctx, face, pname, params); } void glMatrixMode(GLenum mode) { GET_CONTEXT; ctx->glMatrixMode(ctx, mode); } void glMultMatrixx(const GLfixed* m) { GET_CONTEXT; ctx->glMultMatrixx(ctx, m); } void glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q) { GET_CONTEXT; ctx->glMultiTexCoord4x(ctx, target, s, t, r, q); } void glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz) { GET_CONTEXT; ctx->glNormal3x(ctx, nx, ny, nz); } void glNormalPointer(GLenum type, GLsizei stride, const GLvoid* pointer) { GET_CONTEXT; ctx->glNormalPointer(ctx, type, stride, pointer); } void glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) { GET_CONTEXT; ctx->glOrthox(ctx, left, right, bottom, top, zNear, zFar); } void glPixelStorei(GLenum pname, GLint param) { GET_CONTEXT; ctx->glPixelStorei(ctx, pname, param); } void glPointParameterx(GLenum pname, GLfixed param) { GET_CONTEXT; ctx->glPointParameterx(ctx, pname, param); } void glPointParameterxv(GLenum pname, const GLfixed* params) { GET_CONTEXT; ctx->glPointParameterxv(ctx, pname, params); } void glPointSizex(GLfixed size) { GET_CONTEXT; ctx->glPointSizex(ctx, size); } void glPolygonOffsetx(GLfixed factor, GLfixed units) { GET_CONTEXT; ctx->glPolygonOffsetx(ctx, factor, units); } void glPopMatrix() { GET_CONTEXT; ctx->glPopMatrix(ctx); } void glPushMatrix() { GET_CONTEXT; ctx->glPushMatrix(ctx); } void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels) { GET_CONTEXT; ctx->glReadPixels(ctx, x, y, width, height, format, type, pixels); } void glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z) { GET_CONTEXT; ctx->glRotatex(ctx, angle, x, y, z); } void glSampleCoverage(GLclampf value, GLboolean invert) { GET_CONTEXT; ctx->glSampleCoverage(ctx, value, invert); } void glSampleCoveragex(GLclampx value, GLboolean invert) { GET_CONTEXT; ctx->glSampleCoveragex(ctx, value, invert); } void glScalex(GLfixed x, GLfixed y, GLfixed z) { GET_CONTEXT; ctx->glScalex(ctx, x, y, z); } void glScissor(GLint x, GLint y, GLsizei width, GLsizei height) { GET_CONTEXT; ctx->glScissor(ctx, x, y, width, height); } void glShadeModel(GLenum mode) { GET_CONTEXT; ctx->glShadeModel(ctx, mode); } void glStencilFunc(GLenum func, GLint ref, GLuint mask) { GET_CONTEXT; ctx->glStencilFunc(ctx, func, ref, mask); } void glStencilMask(GLuint mask) { GET_CONTEXT; ctx->glStencilMask(ctx, mask); } void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) { GET_CONTEXT; ctx->glStencilOp(ctx, fail, zfail, zpass); } void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) { GET_CONTEXT; ctx->glTexCoordPointer(ctx, size, type, stride, pointer); } void glTexEnvi(GLenum target, GLenum pname, GLint param) { GET_CONTEXT; ctx->glTexEnvi(ctx, target, pname, param); } void glTexEnvx(GLenum target, GLenum pname, GLfixed param) { GET_CONTEXT; ctx->glTexEnvx(ctx, target, pname, param); } void glTexEnviv(GLenum target, GLenum pname, const GLint* params) { GET_CONTEXT; ctx->glTexEnviv(ctx, target, pname, params); } void glTexEnvxv(GLenum target, GLenum pname, const GLfixed* params) { GET_CONTEXT; ctx->glTexEnvxv(ctx, target, pname, params); } void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels) { GET_CONTEXT; ctx->glTexImage2D(ctx, target, level, internalformat, width, height, border, format, type, pixels); } void glTexParameteri(GLenum target, GLenum pname, GLint param) { GET_CONTEXT; ctx->glTexParameteri(ctx, target, pname, param); } void glTexParameterx(GLenum target, GLenum pname, GLfixed param) { GET_CONTEXT; ctx->glTexParameterx(ctx, target, pname, param); } void glTexParameteriv(GLenum target, GLenum pname, const GLint* params) { GET_CONTEXT; ctx->glTexParameteriv(ctx, target, pname, params); } void glTexParameterxv(GLenum target, GLenum pname, const GLfixed* params) { GET_CONTEXT; ctx->glTexParameterxv(ctx, target, pname, params); } void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels) { GET_CONTEXT; ctx->glTexSubImage2D(ctx, target, level, xoffset, yoffset, width, height, format, type, pixels); } void glTranslatex(GLfixed x, GLfixed y, GLfixed z) { GET_CONTEXT; ctx->glTranslatex(ctx, x, y, z); } void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) { GET_CONTEXT; ctx->glVertexPointer(ctx, size, type, stride, pointer); } void glViewport(GLint x, GLint y, GLsizei width, GLsizei height) { GET_CONTEXT; ctx->glViewport(ctx, x, y, width, height); } void glPointSizePointerOES(GLenum type, GLsizei stride, const GLvoid* pointer) { GET_CONTEXT; ctx->glPointSizePointerOES(ctx, type, stride, pointer); } void glVertexPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset) { GET_CONTEXT; ctx->glVertexPointerOffset(ctx, size, type, stride, offset); } void glColorPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset) { GET_CONTEXT; ctx->glColorPointerOffset(ctx, size, type, stride, offset); } void glNormalPointerOffset(GLenum type, GLsizei stride, GLuint offset) { GET_CONTEXT; ctx->glNormalPointerOffset(ctx, type, stride, offset); } void glPointSizePointerOffset(GLenum type, GLsizei stride, GLuint offset) { GET_CONTEXT; ctx->glPointSizePointerOffset(ctx, type, stride, offset); } void glTexCoordPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset) { GET_CONTEXT; ctx->glTexCoordPointerOffset(ctx, size, type, stride, offset); } void glWeightPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset) { GET_CONTEXT; ctx->glWeightPointerOffset(ctx, size, type, stride, offset); } void glMatrixIndexPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset) { GET_CONTEXT; ctx->glMatrixIndexPointerOffset(ctx, size, type, stride, offset); } void glVertexPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen) { GET_CONTEXT; ctx->glVertexPointerData(ctx, size, type, stride, data, datalen); } void glColorPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen) { GET_CONTEXT; ctx->glColorPointerData(ctx, size, type, stride, data, datalen); } void glNormalPointerData(GLenum type, GLsizei stride, void* data, GLuint datalen) { GET_CONTEXT; ctx->glNormalPointerData(ctx, type, stride, data, datalen); } void glTexCoordPointerData(GLint unit, GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen) { GET_CONTEXT; ctx->glTexCoordPointerData(ctx, unit, size, type, stride, data, datalen); } void glPointSizePointerData(GLenum type, GLsizei stride, void* data, GLuint datalen) { GET_CONTEXT; ctx->glPointSizePointerData(ctx, type, stride, data, datalen); } void glWeightPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen) { GET_CONTEXT; ctx->glWeightPointerData(ctx, size, type, stride, data, datalen); } void glMatrixIndexPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen) { GET_CONTEXT; ctx->glMatrixIndexPointerData(ctx, size, type, stride, data, datalen); } void glDrawElementsOffset(GLenum mode, GLsizei count, GLenum type, GLuint offset) { GET_CONTEXT; ctx->glDrawElementsOffset(ctx, mode, count, type, offset); } void glDrawElementsData(GLenum mode, GLsizei count, GLenum type, void* data, GLuint datalen) { GET_CONTEXT; ctx->glDrawElementsData(ctx, mode, count, type, data, datalen); } void glGetCompressedTextureFormats(int count, GLint* formats) { GET_CONTEXT; ctx->glGetCompressedTextureFormats(ctx, count, formats); } int glFinishRoundTrip() { GET_CONTEXT; return ctx->glFinishRoundTrip(ctx); } void glBlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha) { GET_CONTEXT; ctx->glBlendEquationSeparateOES(ctx, modeRGB, modeAlpha); } void glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) { GET_CONTEXT; ctx->glBlendFuncSeparateOES(ctx, srcRGB, dstRGB, srcAlpha, dstAlpha); } void glBlendEquationOES(GLenum mode) { GET_CONTEXT; ctx->glBlendEquationOES(ctx, mode); } void glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height) { GET_CONTEXT; ctx->glDrawTexsOES(ctx, x, y, z, width, height); } void glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height) { GET_CONTEXT; ctx->glDrawTexiOES(ctx, x, y, z, width, height); } void glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height) { GET_CONTEXT; ctx->glDrawTexxOES(ctx, x, y, z, width, height); } void glDrawTexsvOES(const GLshort* coords) { GET_CONTEXT; ctx->glDrawTexsvOES(ctx, coords); } void glDrawTexivOES(const GLint* coords) { GET_CONTEXT; ctx->glDrawTexivOES(ctx, coords); } void glDrawTexxvOES(const GLfixed* coords) { GET_CONTEXT; ctx->glDrawTexxvOES(ctx, coords); } void glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height) { GET_CONTEXT; ctx->glDrawTexfOES(ctx, x, y, z, width, height); } void glDrawTexfvOES(const GLfloat* coords) { GET_CONTEXT; ctx->glDrawTexfvOES(ctx, coords); } void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image) { GET_CONTEXT; ctx->glEGLImageTargetTexture2DOES(ctx, target, image); } void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image) { GET_CONTEXT; ctx->glEGLImageTargetRenderbufferStorageOES(ctx, target, image); } void glAlphaFuncxOES(GLenum func, GLclampx ref) { GET_CONTEXT; ctx->glAlphaFuncxOES(ctx, func, ref); } void glClearColorxOES(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) { GET_CONTEXT; ctx->glClearColorxOES(ctx, red, green, blue, alpha); } void glClearDepthxOES(GLclampx depth) { GET_CONTEXT; ctx->glClearDepthxOES(ctx, depth); } void glClipPlanexOES(GLenum plane, const GLfixed* equation) { GET_CONTEXT; ctx->glClipPlanexOES(ctx, plane, equation); } void glClipPlanexIMG(GLenum plane, const GLfixed* equation) { GET_CONTEXT; ctx->glClipPlanexIMG(ctx, plane, equation); } void glColor4xOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) { GET_CONTEXT; ctx->glColor4xOES(ctx, red, green, blue, alpha); } void glDepthRangexOES(GLclampx zNear, GLclampx zFar) { GET_CONTEXT; ctx->glDepthRangexOES(ctx, zNear, zFar); } void glFogxOES(GLenum pname, GLfixed param) { GET_CONTEXT; ctx->glFogxOES(ctx, pname, param); } void glFogxvOES(GLenum pname, const GLfixed* params) { GET_CONTEXT; ctx->glFogxvOES(ctx, pname, params); } void glFrustumxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) { GET_CONTEXT; ctx->glFrustumxOES(ctx, left, right, bottom, top, zNear, zFar); } void glGetClipPlanexOES(GLenum pname, GLfixed* eqn) { GET_CONTEXT; ctx->glGetClipPlanexOES(ctx, pname, eqn); } void glGetClipPlanex(GLenum pname, GLfixed* eqn) { GET_CONTEXT; ctx->glGetClipPlanex(ctx, pname, eqn); } void glGetFixedvOES(GLenum pname, GLfixed* params) { GET_CONTEXT; ctx->glGetFixedvOES(ctx, pname, params); } void glGetLightxvOES(GLenum light, GLenum pname, GLfixed* params) { GET_CONTEXT; ctx->glGetLightxvOES(ctx, light, pname, params); } void glGetMaterialxvOES(GLenum face, GLenum pname, GLfixed* params) { GET_CONTEXT; ctx->glGetMaterialxvOES(ctx, face, pname, params); } void glGetTexEnvxvOES(GLenum env, GLenum pname, GLfixed* params) { GET_CONTEXT; ctx->glGetTexEnvxvOES(ctx, env, pname, params); } void glGetTexParameterxvOES(GLenum target, GLenum pname, GLfixed* params) { GET_CONTEXT; ctx->glGetTexParameterxvOES(ctx, target, pname, params); } void glLightModelxOES(GLenum pname, GLfixed param) { GET_CONTEXT; ctx->glLightModelxOES(ctx, pname, param); } void glLightModelxvOES(GLenum pname, const GLfixed* params) { GET_CONTEXT; ctx->glLightModelxvOES(ctx, pname, params); } void glLightxOES(GLenum light, GLenum pname, GLfixed param) { GET_CONTEXT; ctx->glLightxOES(ctx, light, pname, param); } void glLightxvOES(GLenum light, GLenum pname, const GLfixed* params) { GET_CONTEXT; ctx->glLightxvOES(ctx, light, pname, params); } void glLineWidthxOES(GLfixed width) { GET_CONTEXT; ctx->glLineWidthxOES(ctx, width); } void glLoadMatrixxOES(const GLfixed* m) { GET_CONTEXT; ctx->glLoadMatrixxOES(ctx, m); } void glMaterialxOES(GLenum face, GLenum pname, GLfixed param) { GET_CONTEXT; ctx->glMaterialxOES(ctx, face, pname, param); } void glMaterialxvOES(GLenum face, GLenum pname, const GLfixed* params) { GET_CONTEXT; ctx->glMaterialxvOES(ctx, face, pname, params); } void glMultMatrixxOES(const GLfixed* m) { GET_CONTEXT; ctx->glMultMatrixxOES(ctx, m); } void glMultiTexCoord4xOES(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q) { GET_CONTEXT; ctx->glMultiTexCoord4xOES(ctx, target, s, t, r, q); } void glNormal3xOES(GLfixed nx, GLfixed ny, GLfixed nz) { GET_CONTEXT; ctx->glNormal3xOES(ctx, nx, ny, nz); } void glOrthoxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) { GET_CONTEXT; ctx->glOrthoxOES(ctx, left, right, bottom, top, zNear, zFar); } void glPointParameterxOES(GLenum pname, GLfixed param) { GET_CONTEXT; ctx->glPointParameterxOES(ctx, pname, param); } void glPointParameterxvOES(GLenum pname, const GLfixed* params) { GET_CONTEXT; ctx->glPointParameterxvOES(ctx, pname, params); } void glPointSizexOES(GLfixed size) { GET_CONTEXT; ctx->glPointSizexOES(ctx, size); } void glPolygonOffsetxOES(GLfixed factor, GLfixed units) { GET_CONTEXT; ctx->glPolygonOffsetxOES(ctx, factor, units); } void glRotatexOES(GLfixed angle, GLfixed x, GLfixed y, GLfixed z) { GET_CONTEXT; ctx->glRotatexOES(ctx, angle, x, y, z); } void glSampleCoveragexOES(GLclampx value, GLboolean invert) { GET_CONTEXT; ctx->glSampleCoveragexOES(ctx, value, invert); } void glScalexOES(GLfixed x, GLfixed y, GLfixed z) { GET_CONTEXT; ctx->glScalexOES(ctx, x, y, z); } void glTexEnvxOES(GLenum target, GLenum pname, GLfixed param) { GET_CONTEXT; ctx->glTexEnvxOES(ctx, target, pname, param); } void glTexEnvxvOES(GLenum target, GLenum pname, const GLfixed* params) { GET_CONTEXT; ctx->glTexEnvxvOES(ctx, target, pname, params); } void glTexParameterxOES(GLenum target, GLenum pname, GLfixed param) { GET_CONTEXT; ctx->glTexParameterxOES(ctx, target, pname, param); } void glTexParameterxvOES(GLenum target, GLenum pname, const GLfixed* params) { GET_CONTEXT; ctx->glTexParameterxvOES(ctx, target, pname, params); } void glTranslatexOES(GLfixed x, GLfixed y, GLfixed z) { GET_CONTEXT; ctx->glTranslatexOES(ctx, x, y, z); } GLboolean glIsRenderbufferOES(GLuint renderbuffer) { GET_CONTEXT; return ctx->glIsRenderbufferOES(ctx, renderbuffer); } void glBindRenderbufferOES(GLenum target, GLuint renderbuffer) { GET_CONTEXT; ctx->glBindRenderbufferOES(ctx, target, renderbuffer); } void glDeleteRenderbuffersOES(GLsizei n, const GLuint* renderbuffers) { GET_CONTEXT; if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } ctx->glDeleteRenderbuffersOES(ctx, n, renderbuffers); } void glGenRenderbuffersOES(GLsizei n, GLuint* renderbuffers) { GET_CONTEXT; if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } ctx->glGenRenderbuffersOES(ctx, n, renderbuffers); } void glRenderbufferStorageOES(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) { GET_CONTEXT; ctx->glRenderbufferStorageOES(ctx, target, internalformat, width, height); } void glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint* params) { GET_CONTEXT; ctx->glGetRenderbufferParameterivOES(ctx, target, pname, params); } GLboolean glIsFramebufferOES(GLuint framebuffer) { GET_CONTEXT; return ctx->glIsFramebufferOES(ctx, framebuffer); } void glBindFramebufferOES(GLenum target, GLuint framebuffer) { GET_CONTEXT; ctx->glBindFramebufferOES(ctx, target, framebuffer); } void glDeleteFramebuffersOES(GLsizei n, const GLuint* framebuffers) { GET_CONTEXT; if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } ctx->glDeleteFramebuffersOES(ctx, n, framebuffers); } void glGenFramebuffersOES(GLsizei n, GLuint* framebuffers) { GET_CONTEXT; if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } ctx->glGenFramebuffersOES(ctx, n, framebuffers); } GLenum glCheckFramebufferStatusOES(GLenum target) { GET_CONTEXT; return ctx->glCheckFramebufferStatusOES(ctx, target); } void glFramebufferRenderbufferOES(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) { GET_CONTEXT; ctx->glFramebufferRenderbufferOES(ctx, target, attachment, renderbuffertarget, renderbuffer); } void glFramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { GET_CONTEXT; ctx->glFramebufferTexture2DOES(ctx, target, attachment, textarget, texture, level); } void glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint* params) { GET_CONTEXT; ctx->glGetFramebufferAttachmentParameterivOES(ctx, target, attachment, pname, params); } void glGenerateMipmapOES(GLenum target) { GET_CONTEXT; ctx->glGenerateMipmapOES(ctx, target); } void* glMapBufferOES(GLenum target, GLenum access) { GET_CONTEXT; return ctx->glMapBufferOES(ctx, target, access); } GLboolean glUnmapBufferOES(GLenum target) { GET_CONTEXT; return ctx->glUnmapBufferOES(ctx, target); } void glGetBufferPointervOES(GLenum target, GLenum pname, GLvoid** params) { GET_CONTEXT; ctx->glGetBufferPointervOES(ctx, target, pname, params); } void glCurrentPaletteMatrixOES(GLuint matrixpaletteindex) { GET_CONTEXT; ctx->glCurrentPaletteMatrixOES(ctx, matrixpaletteindex); } void glLoadPaletteFromModelViewMatrixOES() { GET_CONTEXT; ctx->glLoadPaletteFromModelViewMatrixOES(ctx); } void glMatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) { GET_CONTEXT; ctx->glMatrixIndexPointerOES(ctx, size, type, stride, pointer); } void glWeightPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) { GET_CONTEXT; ctx->glWeightPointerOES(ctx, size, type, stride, pointer); } GLbitfield glQueryMatrixxOES(GLfixed* mantissa, GLint* exponent) { GET_CONTEXT; return ctx->glQueryMatrixxOES(ctx, mantissa, exponent); } void glDepthRangefOES(GLclampf zNear, GLclampf zFar) { GET_CONTEXT; ctx->glDepthRangefOES(ctx, zNear, zFar); } void glFrustumfOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) { GET_CONTEXT; ctx->glFrustumfOES(ctx, left, right, bottom, top, zNear, zFar); } void glOrthofOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) { GET_CONTEXT; ctx->glOrthofOES(ctx, left, right, bottom, top, zNear, zFar); } void glClipPlanefOES(GLenum plane, const GLfloat* equation) { GET_CONTEXT; ctx->glClipPlanefOES(ctx, plane, equation); } void glClipPlanefIMG(GLenum plane, const GLfloat* equation) { GET_CONTEXT; ctx->glClipPlanefIMG(ctx, plane, equation); } void glGetClipPlanefOES(GLenum pname, GLfloat* eqn) { GET_CONTEXT; ctx->glGetClipPlanefOES(ctx, pname, eqn); } void glClearDepthfOES(GLclampf depth) { GET_CONTEXT; ctx->glClearDepthfOES(ctx, depth); } void glTexGenfOES(GLenum coord, GLenum pname, GLfloat param) { GET_CONTEXT; ctx->glTexGenfOES(ctx, coord, pname, param); } void glTexGenfvOES(GLenum coord, GLenum pname, const GLfloat* params) { GET_CONTEXT; ctx->glTexGenfvOES(ctx, coord, pname, params); } void glTexGeniOES(GLenum coord, GLenum pname, GLint param) { GET_CONTEXT; ctx->glTexGeniOES(ctx, coord, pname, param); } void glTexGenivOES(GLenum coord, GLenum pname, const GLint* params) { GET_CONTEXT; ctx->glTexGenivOES(ctx, coord, pname, params); } void glTexGenxOES(GLenum coord, GLenum pname, GLfixed param) { GET_CONTEXT; ctx->glTexGenxOES(ctx, coord, pname, param); } void glTexGenxvOES(GLenum coord, GLenum pname, const GLfixed* params) { GET_CONTEXT; ctx->glTexGenxvOES(ctx, coord, pname, params); } void glGetTexGenfvOES(GLenum coord, GLenum pname, GLfloat* params) { GET_CONTEXT; ctx->glGetTexGenfvOES(ctx, coord, pname, params); } void glGetTexGenivOES(GLenum coord, GLenum pname, GLint* params) { GET_CONTEXT; ctx->glGetTexGenivOES(ctx, coord, pname, params); } void glGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed* params) { GET_CONTEXT; ctx->glGetTexGenxvOES(ctx, coord, pname, params); } void glBindVertexArrayOES(GLuint array) { GET_CONTEXT; ctx->glBindVertexArrayOES(ctx, array); } void glDeleteVertexArraysOES(GLsizei n, const GLuint* arrays) { GET_CONTEXT; if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } ctx->glDeleteVertexArraysOES(ctx, n, arrays); } void glGenVertexArraysOES(GLsizei n, GLuint* arrays) { GET_CONTEXT; if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } ctx->glGenVertexArraysOES(ctx, n, arrays); } GLboolean glIsVertexArrayOES(GLuint array) { GET_CONTEXT; return ctx->glIsVertexArrayOES(ctx, array); } void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum* attachments) { GET_CONTEXT; ctx->glDiscardFramebufferEXT(ctx, target, numAttachments, attachments); } void glMultiDrawArraysEXT(GLenum mode, const GLint* first, const GLsizei* count, GLsizei primcount) { GET_CONTEXT; ctx->glMultiDrawArraysEXT(ctx, mode, first, count, primcount); } void glMultiDrawElementsEXT(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices, GLsizei primcount) { GET_CONTEXT; ctx->glMultiDrawElementsEXT(ctx, mode, count, type, indices, primcount); } void glMultiDrawArraysSUN(GLenum mode, GLint* first, GLsizei* count, GLsizei primcount) { GET_CONTEXT; ctx->glMultiDrawArraysSUN(ctx, mode, first, count, primcount); } void glMultiDrawElementsSUN(GLenum mode, const GLsizei* count, GLenum type, const GLvoid** indices, GLsizei primcount) { GET_CONTEXT; ctx->glMultiDrawElementsSUN(ctx, mode, count, type, indices, primcount); } void glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) { GET_CONTEXT; ctx->glRenderbufferStorageMultisampleIMG(ctx, target, samples, internalformat, width, height); } void glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples) { GET_CONTEXT; ctx->glFramebufferTexture2DMultisampleIMG(ctx, target, attachment, textarget, texture, level, samples); } void glDeleteFencesNV(GLsizei n, const GLuint* fences) { GET_CONTEXT; if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } ctx->glDeleteFencesNV(ctx, n, fences); } void glGenFencesNV(GLsizei n, GLuint* fences) { GET_CONTEXT; if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } ctx->glGenFencesNV(ctx, n, fences); } GLboolean glIsFenceNV(GLuint fence) { GET_CONTEXT; return ctx->glIsFenceNV(ctx, fence); } GLboolean glTestFenceNV(GLuint fence) { GET_CONTEXT; return ctx->glTestFenceNV(ctx, fence); } void glGetFenceivNV(GLuint fence, GLenum pname, GLint* params) { GET_CONTEXT; ctx->glGetFenceivNV(ctx, fence, pname, params); } void glFinishFenceNV(GLuint fence) { GET_CONTEXT; ctx->glFinishFenceNV(ctx, fence); } void glSetFenceNV(GLuint fence, GLenum condition) { GET_CONTEXT; ctx->glSetFenceNV(ctx, fence, condition); } void glGetDriverControlsQCOM(GLint* num, GLsizei size, GLuint* driverControls) { GET_CONTEXT; ctx->glGetDriverControlsQCOM(ctx, num, size, driverControls); } void glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei* length, GLchar* driverControlString) { GET_CONTEXT; ctx->glGetDriverControlStringQCOM(ctx, driverControl, bufSize, length, driverControlString); } void glEnableDriverControlQCOM(GLuint driverControl) { GET_CONTEXT; ctx->glEnableDriverControlQCOM(ctx, driverControl); } void glDisableDriverControlQCOM(GLuint driverControl) { GET_CONTEXT; ctx->glDisableDriverControlQCOM(ctx, driverControl); } void glExtGetTexturesQCOM(GLuint* textures, GLint maxTextures, GLint* numTextures) { GET_CONTEXT; ctx->glExtGetTexturesQCOM(ctx, textures, maxTextures, numTextures); } void glExtGetBuffersQCOM(GLuint* buffers, GLint maxBuffers, GLint* numBuffers) { GET_CONTEXT; ctx->glExtGetBuffersQCOM(ctx, buffers, maxBuffers, numBuffers); } void glExtGetRenderbuffersQCOM(GLuint* renderbuffers, GLint maxRenderbuffers, GLint* numRenderbuffers) { GET_CONTEXT; ctx->glExtGetRenderbuffersQCOM(ctx, renderbuffers, maxRenderbuffers, numRenderbuffers); } void glExtGetFramebuffersQCOM(GLuint* framebuffers, GLint maxFramebuffers, GLint* numFramebuffers) { GET_CONTEXT; ctx->glExtGetFramebuffersQCOM(ctx, framebuffers, maxFramebuffers, numFramebuffers); } void glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint* params) { GET_CONTEXT; ctx->glExtGetTexLevelParameterivQCOM(ctx, texture, face, level, pname, params); } void glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param) { GET_CONTEXT; ctx->glExtTexObjectStateOverrideiQCOM(ctx, target, pname, param); } void glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid* texels) { GET_CONTEXT; ctx->glExtGetTexSubImageQCOM(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels); } void glExtGetBufferPointervQCOM(GLenum target, GLvoid** params) { GET_CONTEXT; ctx->glExtGetBufferPointervQCOM(ctx, target, params); } void glExtGetShadersQCOM(GLuint* shaders, GLint maxShaders, GLint* numShaders) { GET_CONTEXT; ctx->glExtGetShadersQCOM(ctx, shaders, maxShaders, numShaders); } void glExtGetProgramsQCOM(GLuint* programs, GLint maxPrograms, GLint* numPrograms) { GET_CONTEXT; ctx->glExtGetProgramsQCOM(ctx, programs, maxPrograms, numPrograms); } GLboolean glExtIsProgramBinaryQCOM(GLuint program) { GET_CONTEXT; return ctx->glExtIsProgramBinaryQCOM(ctx, program); } void glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar* source, GLint* length) { GET_CONTEXT; ctx->glExtGetProgramBinarySourceQCOM(ctx, program, shadertype, source, length); } void glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask) { GET_CONTEXT; ctx->glStartTilingQCOM(ctx, x, y, width, height, preserveMask); } void glEndTilingQCOM(GLbitfield preserveMask) { GET_CONTEXT; ctx->glEndTilingQCOM(ctx, preserveMask); } anbox-0.0~git20191115/android/opengl/system/GLESv1_enc/gl_ftable.h000066400000000000000000000315221356361734700243760ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef __gl_client_ftable_t_h #define __gl_client_ftable_t_h static const struct _gl_funcs_by_name { const char *name; void *proc; } gl_funcs_by_name[] = { {"glAlphaFunc", (void*)glAlphaFunc}, {"glClearColor", (void*)glClearColor}, {"glClearDepthf", (void*)glClearDepthf}, {"glClipPlanef", (void*)glClipPlanef}, {"glColor4f", (void*)glColor4f}, {"glDepthRangef", (void*)glDepthRangef}, {"glFogf", (void*)glFogf}, {"glFogfv", (void*)glFogfv}, {"glFrustumf", (void*)glFrustumf}, {"glGetClipPlanef", (void*)glGetClipPlanef}, {"glGetFloatv", (void*)glGetFloatv}, {"glGetLightfv", (void*)glGetLightfv}, {"glGetMaterialfv", (void*)glGetMaterialfv}, {"glGetTexEnvfv", (void*)glGetTexEnvfv}, {"glGetTexParameterfv", (void*)glGetTexParameterfv}, {"glLightModelf", (void*)glLightModelf}, {"glLightModelfv", (void*)glLightModelfv}, {"glLightf", (void*)glLightf}, {"glLightfv", (void*)glLightfv}, {"glLineWidth", (void*)glLineWidth}, {"glLoadMatrixf", (void*)glLoadMatrixf}, {"glMaterialf", (void*)glMaterialf}, {"glMaterialfv", (void*)glMaterialfv}, {"glMultMatrixf", (void*)glMultMatrixf}, {"glMultiTexCoord4f", (void*)glMultiTexCoord4f}, {"glNormal3f", (void*)glNormal3f}, {"glOrthof", (void*)glOrthof}, {"glPointParameterf", (void*)glPointParameterf}, {"glPointParameterfv", (void*)glPointParameterfv}, {"glPointSize", (void*)glPointSize}, {"glPolygonOffset", (void*)glPolygonOffset}, {"glRotatef", (void*)glRotatef}, {"glScalef", (void*)glScalef}, {"glTexEnvf", (void*)glTexEnvf}, {"glTexEnvfv", (void*)glTexEnvfv}, {"glTexParameterf", (void*)glTexParameterf}, {"glTexParameterfv", (void*)glTexParameterfv}, {"glTranslatef", (void*)glTranslatef}, {"glActiveTexture", (void*)glActiveTexture}, {"glAlphaFuncx", (void*)glAlphaFuncx}, {"glBindBuffer", (void*)glBindBuffer}, {"glBindTexture", (void*)glBindTexture}, {"glBlendFunc", (void*)glBlendFunc}, {"glBufferData", (void*)glBufferData}, {"glBufferSubData", (void*)glBufferSubData}, {"glClear", (void*)glClear}, {"glClearColorx", (void*)glClearColorx}, {"glClearDepthx", (void*)glClearDepthx}, {"glClearStencil", (void*)glClearStencil}, {"glClientActiveTexture", (void*)glClientActiveTexture}, {"glColor4ub", (void*)glColor4ub}, {"glColor4x", (void*)glColor4x}, {"glColorMask", (void*)glColorMask}, {"glColorPointer", (void*)glColorPointer}, {"glCompressedTexImage2D", (void*)glCompressedTexImage2D}, {"glCompressedTexSubImage2D", (void*)glCompressedTexSubImage2D}, {"glCopyTexImage2D", (void*)glCopyTexImage2D}, {"glCopyTexSubImage2D", (void*)glCopyTexSubImage2D}, {"glCullFace", (void*)glCullFace}, {"glDeleteBuffers", (void*)glDeleteBuffers}, {"glDeleteTextures", (void*)glDeleteTextures}, {"glDepthFunc", (void*)glDepthFunc}, {"glDepthMask", (void*)glDepthMask}, {"glDepthRangex", (void*)glDepthRangex}, {"glDisable", (void*)glDisable}, {"glDisableClientState", (void*)glDisableClientState}, {"glDrawArrays", (void*)glDrawArrays}, {"glDrawElements", (void*)glDrawElements}, {"glEnable", (void*)glEnable}, {"glEnableClientState", (void*)glEnableClientState}, {"glFinish", (void*)glFinish}, {"glFlush", (void*)glFlush}, {"glFogx", (void*)glFogx}, {"glFogxv", (void*)glFogxv}, {"glFrontFace", (void*)glFrontFace}, {"glFrustumx", (void*)glFrustumx}, {"glGetBooleanv", (void*)glGetBooleanv}, {"glGetBufferParameteriv", (void*)glGetBufferParameteriv}, {"glClipPlanex", (void*)glClipPlanex}, {"glGenBuffers", (void*)glGenBuffers}, {"glGenTextures", (void*)glGenTextures}, {"glGetError", (void*)glGetError}, {"glGetFixedv", (void*)glGetFixedv}, {"glGetIntegerv", (void*)glGetIntegerv}, {"glGetLightxv", (void*)glGetLightxv}, {"glGetMaterialxv", (void*)glGetMaterialxv}, {"glGetPointerv", (void*)glGetPointerv}, {"glGetString", (void*)glGetString}, {"glGetTexEnviv", (void*)glGetTexEnviv}, {"glGetTexEnvxv", (void*)glGetTexEnvxv}, {"glGetTexParameteriv", (void*)glGetTexParameteriv}, {"glGetTexParameterxv", (void*)glGetTexParameterxv}, {"glHint", (void*)glHint}, {"glIsBuffer", (void*)glIsBuffer}, {"glIsEnabled", (void*)glIsEnabled}, {"glIsTexture", (void*)glIsTexture}, {"glLightModelx", (void*)glLightModelx}, {"glLightModelxv", (void*)glLightModelxv}, {"glLightx", (void*)glLightx}, {"glLightxv", (void*)glLightxv}, {"glLineWidthx", (void*)glLineWidthx}, {"glLoadIdentity", (void*)glLoadIdentity}, {"glLoadMatrixx", (void*)glLoadMatrixx}, {"glLogicOp", (void*)glLogicOp}, {"glMaterialx", (void*)glMaterialx}, {"glMaterialxv", (void*)glMaterialxv}, {"glMatrixMode", (void*)glMatrixMode}, {"glMultMatrixx", (void*)glMultMatrixx}, {"glMultiTexCoord4x", (void*)glMultiTexCoord4x}, {"glNormal3x", (void*)glNormal3x}, {"glNormalPointer", (void*)glNormalPointer}, {"glOrthox", (void*)glOrthox}, {"glPixelStorei", (void*)glPixelStorei}, {"glPointParameterx", (void*)glPointParameterx}, {"glPointParameterxv", (void*)glPointParameterxv}, {"glPointSizex", (void*)glPointSizex}, {"glPolygonOffsetx", (void*)glPolygonOffsetx}, {"glPopMatrix", (void*)glPopMatrix}, {"glPushMatrix", (void*)glPushMatrix}, {"glReadPixels", (void*)glReadPixels}, {"glRotatex", (void*)glRotatex}, {"glSampleCoverage", (void*)glSampleCoverage}, {"glSampleCoveragex", (void*)glSampleCoveragex}, {"glScalex", (void*)glScalex}, {"glScissor", (void*)glScissor}, {"glShadeModel", (void*)glShadeModel}, {"glStencilFunc", (void*)glStencilFunc}, {"glStencilMask", (void*)glStencilMask}, {"glStencilOp", (void*)glStencilOp}, {"glTexCoordPointer", (void*)glTexCoordPointer}, {"glTexEnvi", (void*)glTexEnvi}, {"glTexEnvx", (void*)glTexEnvx}, {"glTexEnviv", (void*)glTexEnviv}, {"glTexEnvxv", (void*)glTexEnvxv}, {"glTexImage2D", (void*)glTexImage2D}, {"glTexParameteri", (void*)glTexParameteri}, {"glTexParameterx", (void*)glTexParameterx}, {"glTexParameteriv", (void*)glTexParameteriv}, {"glTexParameterxv", (void*)glTexParameterxv}, {"glTexSubImage2D", (void*)glTexSubImage2D}, {"glTranslatex", (void*)glTranslatex}, {"glVertexPointer", (void*)glVertexPointer}, {"glViewport", (void*)glViewport}, {"glPointSizePointerOES", (void*)glPointSizePointerOES}, {"glBlendEquationSeparateOES", (void*)glBlendEquationSeparateOES}, {"glBlendFuncSeparateOES", (void*)glBlendFuncSeparateOES}, {"glBlendEquationOES", (void*)glBlendEquationOES}, {"glDrawTexsOES", (void*)glDrawTexsOES}, {"glDrawTexiOES", (void*)glDrawTexiOES}, {"glDrawTexxOES", (void*)glDrawTexxOES}, {"glDrawTexsvOES", (void*)glDrawTexsvOES}, {"glDrawTexivOES", (void*)glDrawTexivOES}, {"glDrawTexxvOES", (void*)glDrawTexxvOES}, {"glDrawTexfOES", (void*)glDrawTexfOES}, {"glDrawTexfvOES", (void*)glDrawTexfvOES}, {"glEGLImageTargetTexture2DOES", (void*)glEGLImageTargetTexture2DOES}, {"glEGLImageTargetRenderbufferStorageOES", (void*)glEGLImageTargetRenderbufferStorageOES}, {"glAlphaFuncxOES", (void*)glAlphaFuncxOES}, {"glClearColorxOES", (void*)glClearColorxOES}, {"glClearDepthxOES", (void*)glClearDepthxOES}, {"glClipPlanexOES", (void*)glClipPlanexOES}, {"glClipPlanexIMG", (void*)glClipPlanexIMG}, {"glColor4xOES", (void*)glColor4xOES}, {"glDepthRangexOES", (void*)glDepthRangexOES}, {"glFogxOES", (void*)glFogxOES}, {"glFogxvOES", (void*)glFogxvOES}, {"glFrustumxOES", (void*)glFrustumxOES}, {"glGetClipPlanexOES", (void*)glGetClipPlanexOES}, {"glGetClipPlanex", (void*)glGetClipPlanex}, {"glGetFixedvOES", (void*)glGetFixedvOES}, {"glGetLightxvOES", (void*)glGetLightxvOES}, {"glGetMaterialxvOES", (void*)glGetMaterialxvOES}, {"glGetTexEnvxvOES", (void*)glGetTexEnvxvOES}, {"glGetTexParameterxvOES", (void*)glGetTexParameterxvOES}, {"glLightModelxOES", (void*)glLightModelxOES}, {"glLightModelxvOES", (void*)glLightModelxvOES}, {"glLightxOES", (void*)glLightxOES}, {"glLightxvOES", (void*)glLightxvOES}, {"glLineWidthxOES", (void*)glLineWidthxOES}, {"glLoadMatrixxOES", (void*)glLoadMatrixxOES}, {"glMaterialxOES", (void*)glMaterialxOES}, {"glMaterialxvOES", (void*)glMaterialxvOES}, {"glMultMatrixxOES", (void*)glMultMatrixxOES}, {"glMultiTexCoord4xOES", (void*)glMultiTexCoord4xOES}, {"glNormal3xOES", (void*)glNormal3xOES}, {"glOrthoxOES", (void*)glOrthoxOES}, {"glPointParameterxOES", (void*)glPointParameterxOES}, {"glPointParameterxvOES", (void*)glPointParameterxvOES}, {"glPointSizexOES", (void*)glPointSizexOES}, {"glPolygonOffsetxOES", (void*)glPolygonOffsetxOES}, {"glRotatexOES", (void*)glRotatexOES}, {"glSampleCoveragexOES", (void*)glSampleCoveragexOES}, {"glScalexOES", (void*)glScalexOES}, {"glTexEnvxOES", (void*)glTexEnvxOES}, {"glTexEnvxvOES", (void*)glTexEnvxvOES}, {"glTexParameterxOES", (void*)glTexParameterxOES}, {"glTexParameterxvOES", (void*)glTexParameterxvOES}, {"glTranslatexOES", (void*)glTranslatexOES}, {"glIsRenderbufferOES", (void*)glIsRenderbufferOES}, {"glBindRenderbufferOES", (void*)glBindRenderbufferOES}, {"glDeleteRenderbuffersOES", (void*)glDeleteRenderbuffersOES}, {"glGenRenderbuffersOES", (void*)glGenRenderbuffersOES}, {"glRenderbufferStorageOES", (void*)glRenderbufferStorageOES}, {"glGetRenderbufferParameterivOES", (void*)glGetRenderbufferParameterivOES}, {"glIsFramebufferOES", (void*)glIsFramebufferOES}, {"glBindFramebufferOES", (void*)glBindFramebufferOES}, {"glDeleteFramebuffersOES", (void*)glDeleteFramebuffersOES}, {"glGenFramebuffersOES", (void*)glGenFramebuffersOES}, {"glCheckFramebufferStatusOES", (void*)glCheckFramebufferStatusOES}, {"glFramebufferRenderbufferOES", (void*)glFramebufferRenderbufferOES}, {"glFramebufferTexture2DOES", (void*)glFramebufferTexture2DOES}, {"glGetFramebufferAttachmentParameterivOES", (void*)glGetFramebufferAttachmentParameterivOES}, {"glGenerateMipmapOES", (void*)glGenerateMipmapOES}, {"glMapBufferOES", (void*)glMapBufferOES}, {"glUnmapBufferOES", (void*)glUnmapBufferOES}, {"glGetBufferPointervOES", (void*)glGetBufferPointervOES}, {"glCurrentPaletteMatrixOES", (void*)glCurrentPaletteMatrixOES}, {"glLoadPaletteFromModelViewMatrixOES", (void*)glLoadPaletteFromModelViewMatrixOES}, {"glMatrixIndexPointerOES", (void*)glMatrixIndexPointerOES}, {"glWeightPointerOES", (void*)glWeightPointerOES}, {"glQueryMatrixxOES", (void*)glQueryMatrixxOES}, {"glDepthRangefOES", (void*)glDepthRangefOES}, {"glFrustumfOES", (void*)glFrustumfOES}, {"glOrthofOES", (void*)glOrthofOES}, {"glClipPlanefOES", (void*)glClipPlanefOES}, {"glClipPlanefIMG", (void*)glClipPlanefIMG}, {"glGetClipPlanefOES", (void*)glGetClipPlanefOES}, {"glClearDepthfOES", (void*)glClearDepthfOES}, {"glTexGenfOES", (void*)glTexGenfOES}, {"glTexGenfvOES", (void*)glTexGenfvOES}, {"glTexGeniOES", (void*)glTexGeniOES}, {"glTexGenivOES", (void*)glTexGenivOES}, {"glTexGenxOES", (void*)glTexGenxOES}, {"glTexGenxvOES", (void*)glTexGenxvOES}, {"glGetTexGenfvOES", (void*)glGetTexGenfvOES}, {"glGetTexGenivOES", (void*)glGetTexGenivOES}, {"glGetTexGenxvOES", (void*)glGetTexGenxvOES}, {"glBindVertexArrayOES", (void*)glBindVertexArrayOES}, {"glDeleteVertexArraysOES", (void*)glDeleteVertexArraysOES}, {"glGenVertexArraysOES", (void*)glGenVertexArraysOES}, {"glIsVertexArrayOES", (void*)glIsVertexArrayOES}, {"glDiscardFramebufferEXT", (void*)glDiscardFramebufferEXT}, {"glMultiDrawArraysEXT", (void*)glMultiDrawArraysEXT}, {"glMultiDrawElementsEXT", (void*)glMultiDrawElementsEXT}, {"glMultiDrawArraysSUN", (void*)glMultiDrawArraysSUN}, {"glMultiDrawElementsSUN", (void*)glMultiDrawElementsSUN}, {"glRenderbufferStorageMultisampleIMG", (void*)glRenderbufferStorageMultisampleIMG}, {"glFramebufferTexture2DMultisampleIMG", (void*)glFramebufferTexture2DMultisampleIMG}, {"glDeleteFencesNV", (void*)glDeleteFencesNV}, {"glGenFencesNV", (void*)glGenFencesNV}, {"glIsFenceNV", (void*)glIsFenceNV}, {"glTestFenceNV", (void*)glTestFenceNV}, {"glGetFenceivNV", (void*)glGetFenceivNV}, {"glFinishFenceNV", (void*)glFinishFenceNV}, {"glSetFenceNV", (void*)glSetFenceNV}, {"glGetDriverControlsQCOM", (void*)glGetDriverControlsQCOM}, {"glGetDriverControlStringQCOM", (void*)glGetDriverControlStringQCOM}, {"glEnableDriverControlQCOM", (void*)glEnableDriverControlQCOM}, {"glDisableDriverControlQCOM", (void*)glDisableDriverControlQCOM}, {"glExtGetTexturesQCOM", (void*)glExtGetTexturesQCOM}, {"glExtGetBuffersQCOM", (void*)glExtGetBuffersQCOM}, {"glExtGetRenderbuffersQCOM", (void*)glExtGetRenderbuffersQCOM}, {"glExtGetFramebuffersQCOM", (void*)glExtGetFramebuffersQCOM}, {"glExtGetTexLevelParameterivQCOM", (void*)glExtGetTexLevelParameterivQCOM}, {"glExtTexObjectStateOverrideiQCOM", (void*)glExtTexObjectStateOverrideiQCOM}, {"glExtGetTexSubImageQCOM", (void*)glExtGetTexSubImageQCOM}, {"glExtGetBufferPointervQCOM", (void*)glExtGetBufferPointervQCOM}, {"glExtGetShadersQCOM", (void*)glExtGetShadersQCOM}, {"glExtGetProgramsQCOM", (void*)glExtGetProgramsQCOM}, {"glExtIsProgramBinaryQCOM", (void*)glExtIsProgramBinaryQCOM}, {"glExtGetProgramBinarySourceQCOM", (void*)glExtGetProgramBinarySourceQCOM}, {"glStartTilingQCOM", (void*)glStartTilingQCOM}, {"glEndTilingQCOM", (void*)glEndTilingQCOM}, }; static const int gl_num_funcs = sizeof(gl_funcs_by_name) / sizeof(struct _gl_funcs_by_name); #endif anbox-0.0~git20191115/android/opengl/system/GLESv1_enc/gl_opcodes.h000066400000000000000000000256321356361734700246020ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef __GUARD_gl_opcodes_h_ #define __GUARD_gl_opcodes_h_ #define OP_glAlphaFunc 1024 #define OP_glClearColor 1025 #define OP_glClearDepthf 1026 #define OP_glClipPlanef 1027 #define OP_glColor4f 1028 #define OP_glDepthRangef 1029 #define OP_glFogf 1030 #define OP_glFogfv 1031 #define OP_glFrustumf 1032 #define OP_glGetClipPlanef 1033 #define OP_glGetFloatv 1034 #define OP_glGetLightfv 1035 #define OP_glGetMaterialfv 1036 #define OP_glGetTexEnvfv 1037 #define OP_glGetTexParameterfv 1038 #define OP_glLightModelf 1039 #define OP_glLightModelfv 1040 #define OP_glLightf 1041 #define OP_glLightfv 1042 #define OP_glLineWidth 1043 #define OP_glLoadMatrixf 1044 #define OP_glMaterialf 1045 #define OP_glMaterialfv 1046 #define OP_glMultMatrixf 1047 #define OP_glMultiTexCoord4f 1048 #define OP_glNormal3f 1049 #define OP_glOrthof 1050 #define OP_glPointParameterf 1051 #define OP_glPointParameterfv 1052 #define OP_glPointSize 1053 #define OP_glPolygonOffset 1054 #define OP_glRotatef 1055 #define OP_glScalef 1056 #define OP_glTexEnvf 1057 #define OP_glTexEnvfv 1058 #define OP_glTexParameterf 1059 #define OP_glTexParameterfv 1060 #define OP_glTranslatef 1061 #define OP_glActiveTexture 1062 #define OP_glAlphaFuncx 1063 #define OP_glBindBuffer 1064 #define OP_glBindTexture 1065 #define OP_glBlendFunc 1066 #define OP_glBufferData 1067 #define OP_glBufferSubData 1068 #define OP_glClear 1069 #define OP_glClearColorx 1070 #define OP_glClearDepthx 1071 #define OP_glClearStencil 1072 #define OP_glClientActiveTexture 1073 #define OP_glColor4ub 1074 #define OP_glColor4x 1075 #define OP_glColorMask 1076 #define OP_glColorPointer 1077 #define OP_glCompressedTexImage2D 1078 #define OP_glCompressedTexSubImage2D 1079 #define OP_glCopyTexImage2D 1080 #define OP_glCopyTexSubImage2D 1081 #define OP_glCullFace 1082 #define OP_glDeleteBuffers 1083 #define OP_glDeleteTextures 1084 #define OP_glDepthFunc 1085 #define OP_glDepthMask 1086 #define OP_glDepthRangex 1087 #define OP_glDisable 1088 #define OP_glDisableClientState 1089 #define OP_glDrawArrays 1090 #define OP_glDrawElements 1091 #define OP_glEnable 1092 #define OP_glEnableClientState 1093 #define OP_glFinish 1094 #define OP_glFlush 1095 #define OP_glFogx 1096 #define OP_glFogxv 1097 #define OP_glFrontFace 1098 #define OP_glFrustumx 1099 #define OP_glGetBooleanv 1100 #define OP_glGetBufferParameteriv 1101 #define OP_glClipPlanex 1102 #define OP_glGenBuffers 1103 #define OP_glGenTextures 1104 #define OP_glGetError 1105 #define OP_glGetFixedv 1106 #define OP_glGetIntegerv 1107 #define OP_glGetLightxv 1108 #define OP_glGetMaterialxv 1109 #define OP_glGetPointerv 1110 #define OP_glGetString 1111 #define OP_glGetTexEnviv 1112 #define OP_glGetTexEnvxv 1113 #define OP_glGetTexParameteriv 1114 #define OP_glGetTexParameterxv 1115 #define OP_glHint 1116 #define OP_glIsBuffer 1117 #define OP_glIsEnabled 1118 #define OP_glIsTexture 1119 #define OP_glLightModelx 1120 #define OP_glLightModelxv 1121 #define OP_glLightx 1122 #define OP_glLightxv 1123 #define OP_glLineWidthx 1124 #define OP_glLoadIdentity 1125 #define OP_glLoadMatrixx 1126 #define OP_glLogicOp 1127 #define OP_glMaterialx 1128 #define OP_glMaterialxv 1129 #define OP_glMatrixMode 1130 #define OP_glMultMatrixx 1131 #define OP_glMultiTexCoord4x 1132 #define OP_glNormal3x 1133 #define OP_glNormalPointer 1134 #define OP_glOrthox 1135 #define OP_glPixelStorei 1136 #define OP_glPointParameterx 1137 #define OP_glPointParameterxv 1138 #define OP_glPointSizex 1139 #define OP_glPolygonOffsetx 1140 #define OP_glPopMatrix 1141 #define OP_glPushMatrix 1142 #define OP_glReadPixels 1143 #define OP_glRotatex 1144 #define OP_glSampleCoverage 1145 #define OP_glSampleCoveragex 1146 #define OP_glScalex 1147 #define OP_glScissor 1148 #define OP_glShadeModel 1149 #define OP_glStencilFunc 1150 #define OP_glStencilMask 1151 #define OP_glStencilOp 1152 #define OP_glTexCoordPointer 1153 #define OP_glTexEnvi 1154 #define OP_glTexEnvx 1155 #define OP_glTexEnviv 1156 #define OP_glTexEnvxv 1157 #define OP_glTexImage2D 1158 #define OP_glTexParameteri 1159 #define OP_glTexParameterx 1160 #define OP_glTexParameteriv 1161 #define OP_glTexParameterxv 1162 #define OP_glTexSubImage2D 1163 #define OP_glTranslatex 1164 #define OP_glVertexPointer 1165 #define OP_glViewport 1166 #define OP_glPointSizePointerOES 1167 #define OP_glVertexPointerOffset 1168 #define OP_glColorPointerOffset 1169 #define OP_glNormalPointerOffset 1170 #define OP_glPointSizePointerOffset 1171 #define OP_glTexCoordPointerOffset 1172 #define OP_glWeightPointerOffset 1173 #define OP_glMatrixIndexPointerOffset 1174 #define OP_glVertexPointerData 1175 #define OP_glColorPointerData 1176 #define OP_glNormalPointerData 1177 #define OP_glTexCoordPointerData 1178 #define OP_glPointSizePointerData 1179 #define OP_glWeightPointerData 1180 #define OP_glMatrixIndexPointerData 1181 #define OP_glDrawElementsOffset 1182 #define OP_glDrawElementsData 1183 #define OP_glGetCompressedTextureFormats 1184 #define OP_glFinishRoundTrip 1185 #define OP_glBlendEquationSeparateOES 1186 #define OP_glBlendFuncSeparateOES 1187 #define OP_glBlendEquationOES 1188 #define OP_glDrawTexsOES 1189 #define OP_glDrawTexiOES 1190 #define OP_glDrawTexxOES 1191 #define OP_glDrawTexsvOES 1192 #define OP_glDrawTexivOES 1193 #define OP_glDrawTexxvOES 1194 #define OP_glDrawTexfOES 1195 #define OP_glDrawTexfvOES 1196 #define OP_glEGLImageTargetTexture2DOES 1197 #define OP_glEGLImageTargetRenderbufferStorageOES 1198 #define OP_glAlphaFuncxOES 1199 #define OP_glClearColorxOES 1200 #define OP_glClearDepthxOES 1201 #define OP_glClipPlanexOES 1202 #define OP_glClipPlanexIMG 1203 #define OP_glColor4xOES 1204 #define OP_glDepthRangexOES 1205 #define OP_glFogxOES 1206 #define OP_glFogxvOES 1207 #define OP_glFrustumxOES 1208 #define OP_glGetClipPlanexOES 1209 #define OP_glGetClipPlanex 1210 #define OP_glGetFixedvOES 1211 #define OP_glGetLightxvOES 1212 #define OP_glGetMaterialxvOES 1213 #define OP_glGetTexEnvxvOES 1214 #define OP_glGetTexParameterxvOES 1215 #define OP_glLightModelxOES 1216 #define OP_glLightModelxvOES 1217 #define OP_glLightxOES 1218 #define OP_glLightxvOES 1219 #define OP_glLineWidthxOES 1220 #define OP_glLoadMatrixxOES 1221 #define OP_glMaterialxOES 1222 #define OP_glMaterialxvOES 1223 #define OP_glMultMatrixxOES 1224 #define OP_glMultiTexCoord4xOES 1225 #define OP_glNormal3xOES 1226 #define OP_glOrthoxOES 1227 #define OP_glPointParameterxOES 1228 #define OP_glPointParameterxvOES 1229 #define OP_glPointSizexOES 1230 #define OP_glPolygonOffsetxOES 1231 #define OP_glRotatexOES 1232 #define OP_glSampleCoveragexOES 1233 #define OP_glScalexOES 1234 #define OP_glTexEnvxOES 1235 #define OP_glTexEnvxvOES 1236 #define OP_glTexParameterxOES 1237 #define OP_glTexParameterxvOES 1238 #define OP_glTranslatexOES 1239 #define OP_glIsRenderbufferOES 1240 #define OP_glBindRenderbufferOES 1241 #define OP_glDeleteRenderbuffersOES 1242 #define OP_glGenRenderbuffersOES 1243 #define OP_glRenderbufferStorageOES 1244 #define OP_glGetRenderbufferParameterivOES 1245 #define OP_glIsFramebufferOES 1246 #define OP_glBindFramebufferOES 1247 #define OP_glDeleteFramebuffersOES 1248 #define OP_glGenFramebuffersOES 1249 #define OP_glCheckFramebufferStatusOES 1250 #define OP_glFramebufferRenderbufferOES 1251 #define OP_glFramebufferTexture2DOES 1252 #define OP_glGetFramebufferAttachmentParameterivOES 1253 #define OP_glGenerateMipmapOES 1254 #define OP_glMapBufferOES 1255 #define OP_glUnmapBufferOES 1256 #define OP_glGetBufferPointervOES 1257 #define OP_glCurrentPaletteMatrixOES 1258 #define OP_glLoadPaletteFromModelViewMatrixOES 1259 #define OP_glMatrixIndexPointerOES 1260 #define OP_glWeightPointerOES 1261 #define OP_glQueryMatrixxOES 1262 #define OP_glDepthRangefOES 1263 #define OP_glFrustumfOES 1264 #define OP_glOrthofOES 1265 #define OP_glClipPlanefOES 1266 #define OP_glClipPlanefIMG 1267 #define OP_glGetClipPlanefOES 1268 #define OP_glClearDepthfOES 1269 #define OP_glTexGenfOES 1270 #define OP_glTexGenfvOES 1271 #define OP_glTexGeniOES 1272 #define OP_glTexGenivOES 1273 #define OP_glTexGenxOES 1274 #define OP_glTexGenxvOES 1275 #define OP_glGetTexGenfvOES 1276 #define OP_glGetTexGenivOES 1277 #define OP_glGetTexGenxvOES 1278 #define OP_glBindVertexArrayOES 1279 #define OP_glDeleteVertexArraysOES 1280 #define OP_glGenVertexArraysOES 1281 #define OP_glIsVertexArrayOES 1282 #define OP_glDiscardFramebufferEXT 1283 #define OP_glMultiDrawArraysEXT 1284 #define OP_glMultiDrawElementsEXT 1285 #define OP_glMultiDrawArraysSUN 1286 #define OP_glMultiDrawElementsSUN 1287 #define OP_glRenderbufferStorageMultisampleIMG 1288 #define OP_glFramebufferTexture2DMultisampleIMG 1289 #define OP_glDeleteFencesNV 1290 #define OP_glGenFencesNV 1291 #define OP_glIsFenceNV 1292 #define OP_glTestFenceNV 1293 #define OP_glGetFenceivNV 1294 #define OP_glFinishFenceNV 1295 #define OP_glSetFenceNV 1296 #define OP_glGetDriverControlsQCOM 1297 #define OP_glGetDriverControlStringQCOM 1298 #define OP_glEnableDriverControlQCOM 1299 #define OP_glDisableDriverControlQCOM 1300 #define OP_glExtGetTexturesQCOM 1301 #define OP_glExtGetBuffersQCOM 1302 #define OP_glExtGetRenderbuffersQCOM 1303 #define OP_glExtGetFramebuffersQCOM 1304 #define OP_glExtGetTexLevelParameterivQCOM 1305 #define OP_glExtTexObjectStateOverrideiQCOM 1306 #define OP_glExtGetTexSubImageQCOM 1307 #define OP_glExtGetBufferPointervQCOM 1308 #define OP_glExtGetShadersQCOM 1309 #define OP_glExtGetProgramsQCOM 1310 #define OP_glExtIsProgramBinaryQCOM 1311 #define OP_glExtGetProgramBinarySourceQCOM 1312 #define OP_glStartTilingQCOM 1313 #define OP_glEndTilingQCOM 1314 #define OP_last 1315 #endif anbox-0.0~git20191115/android/opengl/system/GLESv1_enc/gl_types.h000066400000000000000000000012501356361734700243000ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __GL_TYPES__H #define __GL_TYPES__H #include "gl_base_types.h" #endif anbox-0.0~git20191115/android/opengl/system/GLESv2/000077500000000000000000000000001356361734700214575ustar00rootroot00000000000000anbox-0.0~git20191115/android/opengl/system/GLESv2/Android.mk000066400000000000000000000006101356361734700233650ustar00rootroot00000000000000LOCAL_PATH := $(call my-dir) ### GLESv2 implementation ########################################### $(call emugl-begin-shared-library,libGLESv2_emulation) $(call emugl-import,libOpenglSystemCommon libGLESv2_enc lib_renderControl_enc) LOCAL_CFLAGS += -DLOG_TAG=\"GLESv2_emulation\" -DGL_GLEXT_PROTOTYPES LOCAL_SRC_FILES := gl2.cpp LOCAL_MODULE_RELATIVE_PATH := egl $(call emugl-end-module) anbox-0.0~git20191115/android/opengl/system/GLESv2/gl2.cpp000066400000000000000000000116531356361734700226550ustar00rootroot00000000000000/* * Copyright 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "EGLClientIface.h" #include "HostConnection.h" #include "GL2Encoder.h" #include "GLES/gl.h" #include "GLES/glext.h" #include "ErrorLog.h" #include "gralloc_cb.h" #include "ThreadInfo.h" #include "EGLImage.h" //XXX: fix this macro to get the context from fast tls path #define GET_CONTEXT GL2Encoder * ctx = getEGLThreadInfo()->hostConn->gl2Encoder(); #include "gl2_entry.cpp" //The functions table #include "gl2_ftable.h" static EGLClient_eglInterface * s_egl = NULL; static EGLClient_glesInterface * s_gl = NULL; #define DEFINE_AND_VALIDATE_HOST_CONNECTION(ret) \ HostConnection *hostCon = HostConnection::get(); \ if (!hostCon) { \ ALOGE("egl: Failed to get host connection\n"); \ return ret; \ } \ renderControl_encoder_context_t *rcEnc = hostCon->rcEncoder(); \ if (!rcEnc) { \ ALOGE("egl: Failed to get renderControl encoder context\n"); \ return ret; \ } //GL extensions void glEGLImageTargetTexture2DOES(void * self, GLenum target, GLeglImageOES img) { (void)self; (void)target; DBG("glEGLImageTargetTexture2DOES v2 target=%#x img=%p\n", target, img); EGLImage_t *image = (EGLImage_t*)img; if (image->target == EGL_NATIVE_BUFFER_ANDROID) { //TODO: check error - we don't have a way to set gl error android_native_buffer_t* native_buffer = image->native_buffer; if (native_buffer->common.magic != ANDROID_NATIVE_BUFFER_MAGIC) { return; } if (native_buffer->common.version != sizeof(android_native_buffer_t)) { return; } GET_CONTEXT; DEFINE_AND_VALIDATE_HOST_CONNECTION(); ctx->override2DTextureTarget(target); rcEnc->rcBindTexture(rcEnc, ((cb_handle_t *)(native_buffer->handle))->hostHandle); ctx->restore2DTextureTarget(); } else if (image->target == EGL_GL_TEXTURE_2D_KHR) { GET_CONTEXT; ctx->override2DTextureTarget(target); GLeglImageOES hostImage = reinterpret_cast((intptr_t)image->host_egl_image); ctx->m_glEGLImageTargetTexture2DOES_enc(self, target, hostImage); ctx->restore2DTextureTarget(); } } void glEGLImageTargetRenderbufferStorageOES(void *self, GLenum target, GLeglImageOES image) { (void)self; (void)target; DBG("glEGLImageTargetRenderbufferStorageOES v2 image=%p\n", image); //TODO: check error - we don't have a way to set gl error android_native_buffer_t* native_buffer = (android_native_buffer_t*)image; if (native_buffer->common.magic != ANDROID_NATIVE_BUFFER_MAGIC) { return; } if (native_buffer->common.version != sizeof(android_native_buffer_t)) { return; } DEFINE_AND_VALIDATE_HOST_CONNECTION(); rcEnc->rcBindRenderbuffer(rcEnc, ((cb_handle_t *)(native_buffer->handle))->hostHandle); return; } void * getProcAddress(const char * procname) { // search in GL function table for (int i=0; igetGLString(name); } break; default: GET_CONTEXT; ctx->setError(GL_INVALID_ENUM); break; } return NULL; } void init() { GET_CONTEXT; ctx->m_glEGLImageTargetTexture2DOES_enc = ctx->glEGLImageTargetTexture2DOES; ctx->glEGLImageTargetTexture2DOES = &glEGLImageTargetTexture2DOES; ctx->glEGLImageTargetRenderbufferStorageOES = &glEGLImageTargetRenderbufferStorageOES; ctx->glGetString = &my_glGetString; } extern "C" { EGLClient_glesInterface * init_emul_gles(EGLClient_eglInterface *eglIface) { s_egl = eglIface; if (!s_gl) { s_gl = new EGLClient_glesInterface(); s_gl->getProcAddress = getProcAddress; s_gl->finish = finish; s_gl->init = init; } return s_gl; } } //extern anbox-0.0~git20191115/android/opengl/system/GLESv2_enc/000077500000000000000000000000001356361734700223045ustar00rootroot00000000000000anbox-0.0~git20191115/android/opengl/system/GLESv2_enc/Android.mk000066400000000000000000000006741356361734700242240ustar00rootroot00000000000000LOCAL_PATH := $(call my-dir) ### GLESv2_enc Encoder ########################################### $(call emugl-begin-shared-library,libGLESv2_enc) LOCAL_SRC_FILES := \ GL2EncoderUtils.cpp \ GL2Encoder.cpp \ gl2_client_context.cpp \ gl2_enc.cpp \ gl2_entry.cpp LOCAL_CFLAGS += -DLOG_TAG=\"emuglGLESv2_enc\" $(call emugl-export,C_INCLUDES,$(LOCAL_PATH)) $(call emugl-import,libOpenglCodecCommon) $(call emugl-end-module) anbox-0.0~git20191115/android/opengl/system/GLESv2_enc/GL2Encoder.cpp000077500000000000000000001425271356361734700247120ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "GL2Encoder.h" #include #include #include #ifndef MIN #define MIN(a, b) ((a) < (b) ? (a) : (b)) #endif static GLubyte *gVendorString= (GLubyte *) "Android"; static GLubyte *gRendererString= (GLubyte *) "Android HW-GLES 2.0"; static GLubyte *gVersionString= (GLubyte *) "OpenGL ES 2.0"; static GLubyte *gExtensionsString= (GLubyte *) "GL_OES_EGL_image_external "; #define SET_ERROR_IF(condition,err) if((condition)) { \ ALOGE("%s:%s:%d GL error 0x%x\n", __FILE__, __FUNCTION__, __LINE__, err); \ ctx->setError(err); \ return; \ } #define RET_AND_SET_ERROR_IF(condition,err,ret) if((condition)) { \ ALOGE("%s:%s:%d GL error 0x%x\n", __FILE__, __FUNCTION__, __LINE__, err); \ ctx->setError(err); \ return ret; \ } GL2Encoder::GL2Encoder(IOStream *stream, ChecksumCalculator *protocol) : gl2_encoder_context_t(stream, protocol) { m_initialized = false; m_state = NULL; m_error = GL_NO_ERROR; m_num_compressedTextureFormats = 0; m_max_cubeMapTextureSize = 0; m_max_renderBufferSize = 0; m_max_textureSize = 0; m_compressedTextureFormats = NULL; //overrides #define OVERRIDE(name) m_##name##_enc = this-> name ; this-> name = &s_##name OVERRIDE(glFlush); OVERRIDE(glPixelStorei); OVERRIDE(glGetString); OVERRIDE(glBindBuffer); OVERRIDE(glBufferData); OVERRIDE(glBufferSubData); OVERRIDE(glDeleteBuffers); OVERRIDE(glDrawArrays); OVERRIDE(glDrawElements); OVERRIDE(glGetIntegerv); OVERRIDE(glGetFloatv); OVERRIDE(glGetBooleanv); OVERRIDE(glVertexAttribPointer); OVERRIDE(glEnableVertexAttribArray); OVERRIDE(glDisableVertexAttribArray); OVERRIDE(glGetVertexAttribiv); OVERRIDE(glGetVertexAttribfv); OVERRIDE(glGetVertexAttribPointerv); this->glShaderBinary = &s_glShaderBinary; this->glShaderSource = &s_glShaderSource; this->glFinish = &s_glFinish; OVERRIDE(glGetError); OVERRIDE(glLinkProgram); OVERRIDE(glDeleteProgram); OVERRIDE(glGetUniformiv); OVERRIDE(glGetUniformfv); OVERRIDE(glCreateProgram); OVERRIDE(glCreateShader); OVERRIDE(glDeleteShader); OVERRIDE(glAttachShader); OVERRIDE(glDetachShader); OVERRIDE(glGetAttachedShaders); OVERRIDE(glGetShaderSource); OVERRIDE(glGetShaderInfoLog); OVERRIDE(glGetProgramInfoLog); OVERRIDE(glGetUniformLocation); OVERRIDE(glUseProgram); OVERRIDE(glUniform1f); OVERRIDE(glUniform1fv); OVERRIDE(glUniform1i); OVERRIDE(glUniform1iv); OVERRIDE(glUniform2f); OVERRIDE(glUniform2fv); OVERRIDE(glUniform2i); OVERRIDE(glUniform2iv); OVERRIDE(glUniform3f); OVERRIDE(glUniform3fv); OVERRIDE(glUniform3i); OVERRIDE(glUniform3iv); OVERRIDE(glUniform4f); OVERRIDE(glUniform4fv); OVERRIDE(glUniform4i); OVERRIDE(glUniform4iv); OVERRIDE(glUniformMatrix2fv); OVERRIDE(glUniformMatrix3fv); OVERRIDE(glUniformMatrix4fv); OVERRIDE(glActiveTexture); OVERRIDE(glBindTexture); OVERRIDE(glDeleteTextures); OVERRIDE(glGetTexParameterfv); OVERRIDE(glGetTexParameteriv); OVERRIDE(glTexParameterf); OVERRIDE(glTexParameterfv); OVERRIDE(glTexParameteri); OVERRIDE(glTexParameteriv); OVERRIDE(glTexImage2D); OVERRIDE(glTexSubImage2D); } GL2Encoder::~GL2Encoder() { delete m_compressedTextureFormats; } GLenum GL2Encoder::s_glGetError(void * self) { GL2Encoder *ctx = (GL2Encoder *)self; GLenum err = ctx->getError(); if(err != GL_NO_ERROR) { ctx->setError(GL_NO_ERROR); return err; } return ctx->m_glGetError_enc(self); } void GL2Encoder::s_glFlush(void *self) { GL2Encoder *ctx = (GL2Encoder *) self; ctx->m_glFlush_enc(self); ctx->m_stream->flush(); } const GLubyte *GL2Encoder::s_glGetString(void *self, GLenum name) { (void)self; GLubyte *retval = (GLubyte *) ""; switch(name) { case GL_VENDOR: retval = gVendorString; break; case GL_RENDERER: retval = gRendererString; break; case GL_VERSION: retval = gVersionString; break; case GL_EXTENSIONS: retval = gExtensionsString; break; } return retval; } void GL2Encoder::s_glPixelStorei(void *self, GLenum param, GLint value) { GL2Encoder *ctx = (GL2Encoder *)self; ctx->m_glPixelStorei_enc(ctx, param, value); assert(ctx->m_state != NULL); ctx->m_state->setPixelStore(param, value); } void GL2Encoder::s_glBindBuffer(void *self, GLenum target, GLuint id) { GL2Encoder *ctx = (GL2Encoder *) self; assert(ctx->m_state != NULL); ctx->m_state->bindBuffer(target, id); // TODO set error state if needed; ctx->m_glBindBuffer_enc(self, target, id); } void GL2Encoder::s_glBufferData(void * self, GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage) { GL2Encoder *ctx = (GL2Encoder *) self; SET_ERROR_IF(!(target == GL_ARRAY_BUFFER || target == GL_ELEMENT_ARRAY_BUFFER), GL_INVALID_ENUM); GLuint bufferId = ctx->m_state->getBuffer(target); SET_ERROR_IF(bufferId==0, GL_INVALID_OPERATION); SET_ERROR_IF(size<0, GL_INVALID_VALUE); ctx->m_shared->updateBufferData(bufferId, size, (void*)data); ctx->m_glBufferData_enc(self, target, size, data, usage); } void GL2Encoder::s_glBufferSubData(void * self, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data) { GL2Encoder *ctx = (GL2Encoder *) self; SET_ERROR_IF(!(target == GL_ARRAY_BUFFER || target == GL_ELEMENT_ARRAY_BUFFER), GL_INVALID_ENUM); GLuint bufferId = ctx->m_state->getBuffer(target); SET_ERROR_IF(bufferId==0, GL_INVALID_OPERATION); GLenum res = ctx->m_shared->subUpdateBufferData(bufferId, offset, size, (void*)data); SET_ERROR_IF(res, res); ctx->m_glBufferSubData_enc(self, target, offset, size, data); } void GL2Encoder::s_glDeleteBuffers(void * self, GLsizei n, const GLuint * buffers) { GL2Encoder *ctx = (GL2Encoder *) self; SET_ERROR_IF(n<0, GL_INVALID_VALUE); for (int i=0; im_shared->deleteBufferData(buffers[i]); ctx->m_state->unBindBuffer(buffers[i]); ctx->m_glDeleteBuffers_enc(self,1,&buffers[i]); } } void GL2Encoder::s_glVertexAttribPointer(void *self, GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * ptr) { GL2Encoder *ctx = (GL2Encoder *)self; assert(ctx->m_state != NULL); ctx->m_state->setState(indx, size, type, normalized, stride, ptr); } void GL2Encoder::s_glGetIntegerv(void *self, GLenum param, GLint *ptr) { GL2Encoder *ctx = (GL2Encoder *) self; assert(ctx->m_state != NULL); GLClientState* state = ctx->m_state; switch (param) { case GL_NUM_SHADER_BINARY_FORMATS: *ptr = 0; break; case GL_SHADER_BINARY_FORMATS: // do nothing break; case GL_COMPRESSED_TEXTURE_FORMATS: { GLint *compressedTextureFormats = ctx->getCompressedTextureFormats(); if (ctx->m_num_compressedTextureFormats > 0 && compressedTextureFormats != NULL) { memcpy(ptr, compressedTextureFormats, ctx->m_num_compressedTextureFormats * sizeof(GLint)); } break; } case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS: case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS: case GL_MAX_TEXTURE_IMAGE_UNITS: ctx->m_glGetIntegerv_enc(self, param, ptr); *ptr = MIN(*ptr, GLClientState::MAX_TEXTURE_UNITS); break; case GL_TEXTURE_BINDING_2D: *ptr = state->getBoundTexture(GL_TEXTURE_2D); break; case GL_TEXTURE_BINDING_EXTERNAL_OES: *ptr = state->getBoundTexture(GL_TEXTURE_EXTERNAL_OES); break; case GL_MAX_CUBE_MAP_TEXTURE_SIZE: if (ctx->m_max_cubeMapTextureSize != 0) { *ptr = ctx->m_max_cubeMapTextureSize; } else { ctx->m_glGetIntegerv_enc(self, param, ptr); ctx->m_max_cubeMapTextureSize = *ptr; } break; case GL_MAX_RENDERBUFFER_SIZE: if (ctx->m_max_renderBufferSize != 0) { *ptr = ctx->m_max_renderBufferSize; } else { ctx->m_glGetIntegerv_enc(self, param, ptr); ctx->m_max_renderBufferSize = *ptr; } break; case GL_MAX_TEXTURE_SIZE: if (ctx->m_max_textureSize != 0) { *ptr = ctx->m_max_textureSize; } else { ctx->m_glGetIntegerv_enc(self, param, ptr); ctx->m_max_textureSize = *ptr; } break; case GL_MAX_VERTEX_ATTRIBS: if (!ctx->m_state->getClientStateParameter(param, ptr)) { ctx->m_glGetIntegerv_enc(self, param, ptr); ctx->m_state->setMaxVertexAttribs(*ptr); } break; default: if (!ctx->m_state->getClientStateParameter(param, ptr)) { ctx->m_glGetIntegerv_enc(self, param, ptr); } break; } } void GL2Encoder::s_glGetFloatv(void *self, GLenum param, GLfloat *ptr) { GL2Encoder *ctx = (GL2Encoder *)self; assert(ctx->m_state != NULL); GLClientState* state = ctx->m_state; switch (param) { case GL_NUM_SHADER_BINARY_FORMATS: *ptr = 0; break; case GL_SHADER_BINARY_FORMATS: // do nothing break; case GL_COMPRESSED_TEXTURE_FORMATS: { GLint *compressedTextureFormats = ctx->getCompressedTextureFormats(); if (ctx->m_num_compressedTextureFormats > 0 && compressedTextureFormats != NULL) { for (int i = 0; i < ctx->m_num_compressedTextureFormats; i++) { ptr[i] = (GLfloat) compressedTextureFormats[i]; } } break; } case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS: case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS: case GL_MAX_TEXTURE_IMAGE_UNITS: ctx->m_glGetFloatv_enc(self, param, ptr); *ptr = MIN(*ptr, (GLfloat)GLClientState::MAX_TEXTURE_UNITS); break; case GL_TEXTURE_BINDING_2D: *ptr = (GLfloat)state->getBoundTexture(GL_TEXTURE_2D); break; case GL_TEXTURE_BINDING_EXTERNAL_OES: *ptr = (GLfloat)state->getBoundTexture(GL_TEXTURE_EXTERNAL_OES); break; default: if (!ctx->m_state->getClientStateParameter(param, ptr)) { ctx->m_glGetFloatv_enc(self, param, ptr); } break; } } void GL2Encoder::s_glGetBooleanv(void *self, GLenum param, GLboolean *ptr) { GL2Encoder *ctx = (GL2Encoder *)self; assert(ctx->m_state != NULL); GLClientState* state = ctx->m_state; switch (param) { case GL_NUM_SHADER_BINARY_FORMATS: *ptr = GL_FALSE; break; case GL_SHADER_BINARY_FORMATS: // do nothing break; case GL_COMPRESSED_TEXTURE_FORMATS: { GLint *compressedTextureFormats = ctx->getCompressedTextureFormats(); if (ctx->m_num_compressedTextureFormats > 0 && compressedTextureFormats != NULL) { for (int i = 0; i < ctx->m_num_compressedTextureFormats; i++) { ptr[i] = compressedTextureFormats[i] != 0 ? GL_TRUE : GL_FALSE; } } break; } case GL_TEXTURE_BINDING_2D: *ptr = state->getBoundTexture(GL_TEXTURE_2D) != 0 ? GL_TRUE : GL_FALSE; break; case GL_TEXTURE_BINDING_EXTERNAL_OES: *ptr = state->getBoundTexture(GL_TEXTURE_EXTERNAL_OES) != 0 ? GL_TRUE : GL_FALSE; break; default: if (!ctx->m_state->getClientStateParameter(param, ptr)) { ctx->m_glGetBooleanv_enc(self, param, ptr); } *ptr = (*ptr != 0) ? GL_TRUE : GL_FALSE; break; } } void GL2Encoder::s_glEnableVertexAttribArray(void *self, GLuint index) { GL2Encoder *ctx = (GL2Encoder *)self; assert(ctx->m_state); GLint maxIndex; ctx->glGetIntegerv(self, GL_MAX_VERTEX_ATTRIBS, &maxIndex); SET_ERROR_IF(!(index < maxIndex), GL_INVALID_VALUE); ctx->m_state->enable(index, 1); } void GL2Encoder::s_glDisableVertexAttribArray(void *self, GLuint index) { GL2Encoder *ctx = (GL2Encoder *)self; assert(ctx->m_state); GLint maxIndex; ctx->glGetIntegerv(self, GL_MAX_VERTEX_ATTRIBS, &maxIndex); SET_ERROR_IF(!(index < maxIndex), GL_INVALID_VALUE); ctx->m_state->enable(index, 0); } void GL2Encoder::s_glGetVertexAttribiv(void *self, GLuint index, GLenum pname, GLint *params) { GL2Encoder *ctx = (GL2Encoder *)self; assert(ctx->m_state); GLint maxIndex; ctx->glGetIntegerv(self, GL_MAX_VERTEX_ATTRIBS, &maxIndex); SET_ERROR_IF(!(index < maxIndex), GL_INVALID_VALUE); if (!ctx->m_state->getVertexAttribParameter(index, pname, params)) { ctx->m_glGetVertexAttribiv_enc(self, index, pname, params); } } void GL2Encoder::s_glGetVertexAttribfv(void *self, GLuint index, GLenum pname, GLfloat *params) { GL2Encoder *ctx = (GL2Encoder *)self; assert(ctx->m_state); GLint maxIndex; ctx->glGetIntegerv(self, GL_MAX_VERTEX_ATTRIBS, &maxIndex); SET_ERROR_IF(!(index < maxIndex), GL_INVALID_VALUE); if (!ctx->m_state->getVertexAttribParameter(index, pname, params)) { ctx->m_glGetVertexAttribfv_enc(self, index, pname, params); } } void GL2Encoder::s_glGetVertexAttribPointerv(void *self, GLuint index, GLenum pname, GLvoid **pointer) { GL2Encoder *ctx = (GL2Encoder *)self; if (ctx->m_state == NULL) return; GLint maxIndex; ctx->glGetIntegerv(self, GL_MAX_VERTEX_ATTRIBS, &maxIndex); SET_ERROR_IF(!(index < maxIndex), GL_INVALID_VALUE); SET_ERROR_IF(pname != GL_VERTEX_ATTRIB_ARRAY_POINTER, GL_INVALID_ENUM); (void)pname; const GLClientState::VertexAttribState *va_state = ctx->m_state->getState(index); if (va_state != NULL) { *pointer = va_state->data; } } void GL2Encoder::sendVertexAttributes(GLint first, GLsizei count) { assert(m_state); for (int i = 0; i < m_state->nLocations(); i++) { bool enableDirty; const GLClientState::VertexAttribState *state = m_state->getStateAndEnableDirty(i, &enableDirty); if (!state) { continue; } if (!enableDirty && !state->enabled) { continue; } if (state->enabled) { m_glEnableVertexAttribArray_enc(this, i); unsigned int datalen = state->elementSize * count; int stride = state->stride == 0 ? state->elementSize : state->stride; int firstIndex = stride * first; this->m_glBindBuffer_enc(this, GL_ARRAY_BUFFER, state->bufferObject); if (state->bufferObject == 0) { this->glVertexAttribPointerData(this, i, state->size, state->type, state->normalized, state->stride, (unsigned char *)state->data + firstIndex, datalen); } else { this->glVertexAttribPointerOffset(this, i, state->size, state->type, state->normalized, state->stride, (uintptr_t) state->data + firstIndex); } this->m_glBindBuffer_enc(this, GL_ARRAY_BUFFER, m_state->currentArrayVbo()); } else { this->m_glDisableVertexAttribArray_enc(this, i); } } } static bool isValidDrawMode(GLenum mode) { switch(mode) { case GL_POINTS: case GL_LINE_STRIP: case GL_LINE_LOOP: case GL_LINES: case GL_TRIANGLE_STRIP: case GL_TRIANGLE_FAN: case GL_TRIANGLES: return true; } return false; } static bool isValidDrawType(GLenum mode) { return mode == GL_UNSIGNED_BYTE || mode == GL_UNSIGNED_SHORT || mode == GL_UNSIGNED_INT; } void GL2Encoder::s_glDrawArrays(void *self, GLenum mode, GLint first, GLsizei count) { GL2Encoder *ctx = (GL2Encoder *)self; SET_ERROR_IF(!isValidDrawMode(mode), GL_INVALID_ENUM); SET_ERROR_IF(count<0, GL_INVALID_VALUE); bool has_arrays = false; int nLocations = ctx->m_state->nLocations(); for (int i = 0; i < nLocations; i++) { const GLClientState::VertexAttribState *state = ctx->m_state->getState(i); if (state->enabled) { if (state->bufferObject || state->data) { has_arrays = true; } else { ALOGE("glDrawArrays: a vertex attribute array is enabled with no data bound\n"); ctx->setError(GL_INVALID_OPERATION); return; } } } if (!has_arrays) { ALOGE("glDrawArrays: no data bound to the command - ignoring\n"); return; } ctx->sendVertexAttributes(first, count); ctx->m_glDrawArrays_enc(ctx, mode, 0, count); } void GL2Encoder::s_glDrawElements(void *self, GLenum mode, GLsizei count, GLenum type, const void *indices) { GL2Encoder *ctx = (GL2Encoder *)self; assert(ctx->m_state != NULL); SET_ERROR_IF(!(isValidDrawMode(mode) && isValidDrawType(type)),GL_INVALID_ENUM); SET_ERROR_IF(count<0, GL_INVALID_VALUE); bool has_immediate_arrays = false; bool has_indirect_arrays = false; int nLocations = ctx->m_state->nLocations(); for (int i = 0; i < nLocations; i++) { const GLClientState::VertexAttribState *state = ctx->m_state->getState(i); if (state->enabled) { if (state->bufferObject != 0) { has_indirect_arrays = true; } else if (state->data) { has_immediate_arrays = true; } else { ALOGW("glDrawElements: a vertex attribute array is enabled with no data bound\n"); ctx->setError(GL_INVALID_OPERATION); return; } } } if (!has_immediate_arrays && !has_indirect_arrays) { ALOGE("glDrawElements: no data bound to the command - ignoring\n"); return; } bool adjustIndices = true; if (ctx->m_state->currentIndexVbo() != 0) { if (!has_immediate_arrays) { ctx->sendVertexAttributes(0, count); ctx->m_glBindBuffer_enc(self, GL_ELEMENT_ARRAY_BUFFER, ctx->m_state->currentIndexVbo()); ctx->glDrawElementsOffset(ctx, mode, count, type, (uintptr_t)indices); adjustIndices = false; } else { BufferData * buf = ctx->m_shared->getBufferData(ctx->m_state->currentIndexVbo()); ctx->m_glBindBuffer_enc(self, GL_ELEMENT_ARRAY_BUFFER, 0); indices = (void*)((GLintptr)buf->m_fixedBuffer.ptr() + (GLintptr)indices); } } if (adjustIndices) { void *adjustedIndices = (void*)indices; int minIndex = 0, maxIndex = 0; switch(type) { case GL_BYTE: case GL_UNSIGNED_BYTE: GLUtils::minmax((unsigned char *)indices, count, &minIndex, &maxIndex); if (minIndex != 0) { adjustedIndices = ctx->m_fixedBuffer.alloc(glSizeof(type) * count); GLUtils::shiftIndices((unsigned char *)indices, (unsigned char *)adjustedIndices, count, -minIndex); } break; case GL_SHORT: case GL_UNSIGNED_SHORT: GLUtils::minmax((unsigned short *)indices, count, &minIndex, &maxIndex); if (minIndex != 0) { adjustedIndices = ctx->m_fixedBuffer.alloc(glSizeof(type) * count); GLUtils::shiftIndices((unsigned short *)indices, (unsigned short *)adjustedIndices, count, -minIndex); } break; case GL_INT: case GL_UNSIGNED_INT: GLUtils::minmax((unsigned int *)indices, count, &minIndex, &maxIndex); if (minIndex != 0) { adjustedIndices = ctx->m_fixedBuffer.alloc(glSizeof(type) * count); GLUtils::shiftIndices((unsigned int *)indices, (unsigned int *)adjustedIndices, count, -minIndex); } break; default: ALOGE("unsupported index buffer type %d\n", type); } if (has_indirect_arrays || 1) { ctx->sendVertexAttributes(minIndex, maxIndex - minIndex + 1); ctx->glDrawElementsData(ctx, mode, count, type, adjustedIndices, count * glSizeof(type)); // XXX - OPTIMIZATION (see the other else branch) should be implemented if(!has_indirect_arrays) { //ALOGD("unoptimized drawelements !!!\n"); } } else { // we are all direct arrays and immidate mode index array - // rebuild the arrays and the index array; ALOGE("glDrawElements: direct index & direct buffer data - will be implemented in later versions;\n"); } } } GLint * GL2Encoder::getCompressedTextureFormats() { if (m_compressedTextureFormats == NULL) { this->glGetIntegerv(this, GL_NUM_COMPRESSED_TEXTURE_FORMATS, &m_num_compressedTextureFormats); if (m_num_compressedTextureFormats > 0) { // get number of texture formats; m_compressedTextureFormats = new GLint[m_num_compressedTextureFormats]; this->glGetCompressedTextureFormats(this, m_num_compressedTextureFormats, m_compressedTextureFormats); } } return m_compressedTextureFormats; } // Replace uses of samplerExternalOES with sampler2D, recording the names of // modified shaders in data. Also remove // #extension GL_OES_EGL_image_external : require // statements. // // This implementation assumes the input has already been pre-processed. If not, // a few cases will be mishandled: // // 1. "mySampler" will be incorrectly recorded as being a samplerExternalOES in // the following code: // #if 1 // uniform sampler2D mySampler; // #else // uniform samplerExternalOES mySampler; // #endif // // 2. Comments that look like sampler declarations will be incorrectly modified // and recorded: // // samplerExternalOES hahaFooledYou // // 3. However, GLSL ES does not have a concatentation operator, so things like // this (valid in C) are invalid and not a problem: // #define SAMPLER(TYPE, NAME) uniform sampler#TYPE NAME // SAMPLER(ExternalOES, mySampler); // static bool replaceSamplerExternalWith2D(char* const str, ShaderData* const data) { static const char STR_HASH_EXTENSION[] = "#extension"; static const char STR_GL_OES_EGL_IMAGE_EXTERNAL[] = "GL_OES_EGL_image_external"; static const char STR_SAMPLER_EXTERNAL_OES[] = "samplerExternalOES"; static const char STR_SAMPLER2D_SPACE[] = "sampler2D "; // -- overwrite all "#extension GL_OES_EGL_image_external : xxx" statements char* c = str; while ((c = strstr(c, STR_HASH_EXTENSION))) { char* start = c; c += sizeof(STR_HASH_EXTENSION)-1; while (isspace(*c) && *c != '\0') { c++; } if (strncmp(c, STR_GL_OES_EGL_IMAGE_EXTERNAL, sizeof(STR_GL_OES_EGL_IMAGE_EXTERNAL)-1) == 0) { // #extension statements are terminated by end of line c = start; while (*c != '\0' && *c != '\r' && *c != '\n') { *c++ = ' '; } } } // -- replace "samplerExternalOES" with "sampler2D" and record name c = str; while ((c = strstr(c, STR_SAMPLER_EXTERNAL_OES))) { // Make sure "samplerExternalOES" isn't a substring of a larger token if (c == str || !isspace(*(c-1))) { c++; continue; } char* sampler_start = c; c += sizeof(STR_SAMPLER_EXTERNAL_OES)-1; if (!isspace(*c) && *c != '\0') { continue; } // capture sampler name while (isspace(*c) && *c != '\0') { c++; } if (!isalpha(*c) && *c != '_') { // not an identifier return false; } char* name_start = c; do { c++; } while (isalnum(*c) || *c == '_'); data->samplerExternalNames.push_back( android::String8(name_start, c - name_start)); // memcpy instead of strcpy since we don't want the NUL terminator memcpy(sampler_start, STR_SAMPLER2D_SPACE, sizeof(STR_SAMPLER2D_SPACE)-1); } return true; } void GL2Encoder::s_glShaderBinary(void *self, GLsizei n, const GLuint *shaders, GLenum binaryformat, const void* binary, GLsizei length) { GL2Encoder* ctx = (GL2Encoder*)self; // Although it is not supported, need to set proper error code. SET_ERROR_IF(1, GL_INVALID_ENUM); } void GL2Encoder::s_glShaderSource(void *self, GLuint shader, GLsizei count, const GLchar * const *string, const GLint *length) { GL2Encoder* ctx = (GL2Encoder*)self; ShaderData* shaderData = ctx->m_shared->getShaderData(shader); SET_ERROR_IF(!ctx->m_shared->isObject(shader), GL_INVALID_VALUE); SET_ERROR_IF(!shaderData, GL_INVALID_OPERATION); SET_ERROR_IF((count<0), GL_INVALID_VALUE); int len = glUtilsCalcShaderSourceLen((char**)string, (GLint*)length, count); char *str = new char[len + 1]; glUtilsPackStrings(str, (char**)string, (GLint*)length, count); // TODO: pre-process str before calling replaceSamplerExternalWith2D(). // Perhaps we can borrow Mesa's pre-processor? if (!replaceSamplerExternalWith2D(str, shaderData)) { delete str; ctx->setError(GL_OUT_OF_MEMORY); return; } ctx->glShaderString(ctx, shader, str, len + 1); delete str; } void GL2Encoder::s_glFinish(void *self) { GL2Encoder *ctx = (GL2Encoder *)self; ctx->glFinishRoundTrip(self); } void GL2Encoder::s_glLinkProgram(void * self, GLuint program) { GL2Encoder *ctx = (GL2Encoder *)self; ctx->m_glLinkProgram_enc(self, program); GLint linkStatus = 0; ctx->glGetProgramiv(self,program,GL_LINK_STATUS,&linkStatus); if (!linkStatus) return; //get number of active uniforms in the program GLint numUniforms=0; ctx->glGetProgramiv(self, program, GL_ACTIVE_UNIFORMS, &numUniforms); ctx->m_shared->initProgramData(program,numUniforms); //get the length of the longest uniform name GLint maxLength=0; ctx->glGetProgramiv(self, program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxLength); GLint size; GLenum type; GLchar *name = new GLchar[maxLength+1]; GLint location; //for each active uniform, get its size and starting location. for (GLint i=0 ; iglGetActiveUniform(self, program, i, maxLength, NULL, &size, &type, name); location = ctx->m_glGetUniformLocation_enc(self, program, name); ctx->m_shared->setProgramIndexInfo(program, i, location, size, type, name); } ctx->m_shared->setupLocationShiftWAR(program); delete[] name; } void GL2Encoder::s_glDeleteProgram(void *self, GLuint program) { GL2Encoder *ctx = (GL2Encoder*)self; ctx->m_glDeleteProgram_enc(self, program); ctx->m_shared->deleteProgramData(program); } void GL2Encoder::s_glGetUniformiv(void *self, GLuint program, GLint location, GLint* params) { GL2Encoder *ctx = (GL2Encoder*)self; SET_ERROR_IF(!ctx->m_shared->isObject(program), GL_INVALID_VALUE); SET_ERROR_IF(!ctx->m_shared->isProgram(program), GL_INVALID_OPERATION); SET_ERROR_IF(!ctx->m_shared->isProgramInitialized(program), GL_INVALID_OPERATION); GLint hostLoc = ctx->m_shared->locationWARAppToHost(program, location); SET_ERROR_IF(ctx->m_shared->getProgramUniformType(program,hostLoc)==0, GL_INVALID_OPERATION); ctx->m_glGetUniformiv_enc(self, program, hostLoc, params); } void GL2Encoder::s_glGetUniformfv(void *self, GLuint program, GLint location, GLfloat* params) { GL2Encoder *ctx = (GL2Encoder*)self; SET_ERROR_IF(!ctx->m_shared->isObject(program), GL_INVALID_VALUE); SET_ERROR_IF(!ctx->m_shared->isProgram(program), GL_INVALID_OPERATION); SET_ERROR_IF(!ctx->m_shared->isProgramInitialized(program), GL_INVALID_OPERATION); GLint hostLoc = ctx->m_shared->locationWARAppToHost(program,location); SET_ERROR_IF(ctx->m_shared->getProgramUniformType(program,hostLoc)==0, GL_INVALID_OPERATION); ctx->m_glGetUniformfv_enc(self, program, hostLoc, params); } GLuint GL2Encoder::s_glCreateProgram(void * self) { GL2Encoder *ctx = (GL2Encoder*)self; GLuint program = ctx->m_glCreateProgram_enc(self); if (program!=0) ctx->m_shared->addProgramData(program); return program; } GLuint GL2Encoder::s_glCreateShader(void *self, GLenum shaderType) { GL2Encoder *ctx = (GL2Encoder*)self; RET_AND_SET_ERROR_IF(((shaderType != GL_VERTEX_SHADER) && (shaderType != GL_FRAGMENT_SHADER)), GL_INVALID_ENUM, 0); GLuint shader = ctx->m_glCreateShader_enc(self, shaderType); if (shader != 0) { if (!ctx->m_shared->addShaderData(shader)) { ctx->m_glDeleteShader_enc(self, shader); return 0; } } return shader; } void GL2Encoder::s_glGetAttachedShaders(void *self, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* shaders) { GL2Encoder *ctx = (GL2Encoder*)self; SET_ERROR_IF(maxCount < 0, GL_INVALID_VALUE); ctx->m_glGetAttachedShaders_enc(self, program, maxCount, count, shaders); } void GL2Encoder::s_glGetShaderSource(void *self, GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source) { GL2Encoder *ctx = (GL2Encoder*)self; SET_ERROR_IF(bufsize < 0, GL_INVALID_VALUE); ctx->m_glGetShaderSource_enc(self, shader, bufsize, length, source); } void GL2Encoder::s_glGetShaderInfoLog(void *self, GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog) { GL2Encoder *ctx = (GL2Encoder*)self; SET_ERROR_IF(bufsize < 0, GL_INVALID_VALUE); ctx->m_glGetShaderInfoLog_enc(self, shader, bufsize, length, infolog); } void GL2Encoder::s_glGetProgramInfoLog(void *self, GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog) { GL2Encoder *ctx = (GL2Encoder*)self; SET_ERROR_IF(bufsize < 0, GL_INVALID_VALUE); ctx->m_glGetProgramInfoLog_enc(self, program, bufsize, length, infolog); } void GL2Encoder::s_glDeleteShader(void *self, GLenum shader) { GL2Encoder *ctx = (GL2Encoder*)self; ctx->m_glDeleteShader_enc(self,shader); ctx->m_shared->unrefShaderData(shader); } void GL2Encoder::s_glAttachShader(void *self, GLuint program, GLuint shader) { GL2Encoder *ctx = (GL2Encoder*)self; ctx->m_glAttachShader_enc(self, program, shader); ctx->m_shared->attachShader(program, shader); } void GL2Encoder::s_glDetachShader(void *self, GLuint program, GLuint shader) { GL2Encoder *ctx = (GL2Encoder*)self; ctx->m_glDetachShader_enc(self, program, shader); ctx->m_shared->detachShader(program, shader); } int GL2Encoder::s_glGetUniformLocation(void *self, GLuint program, const GLchar *name) { if (!name) return -1; GL2Encoder *ctx = (GL2Encoder*)self; // if we need the uniform location WAR // parse array index from the end of the name string int arrIndex = 0; bool needLocationWAR = ctx->m_shared->needUniformLocationWAR(program); if (needLocationWAR) { int namelen = strlen(name); if (name[namelen-1] == ']') { char *brace = strrchr(name,'['); if (!brace || sscanf(brace+1,"%d",&arrIndex) != 1) { return -1; } } } int hostLoc = ctx->m_glGetUniformLocation_enc(self, program, name); if (hostLoc >= 0 && needLocationWAR) { return ctx->m_shared->locationWARHostToApp(program, hostLoc, arrIndex); } return hostLoc; } bool GL2Encoder::updateHostTexture2DBinding(GLenum texUnit, GLenum newTarget) { if (newTarget != GL_TEXTURE_2D && newTarget != GL_TEXTURE_EXTERNAL_OES) return false; m_state->setActiveTextureUnit(texUnit); GLenum oldTarget = m_state->getPriorityEnabledTarget(GL_TEXTURE_2D); if (newTarget != oldTarget) { if (newTarget == GL_TEXTURE_EXTERNAL_OES) { m_state->disableTextureTarget(GL_TEXTURE_2D); m_state->enableTextureTarget(GL_TEXTURE_EXTERNAL_OES); } else { m_state->disableTextureTarget(GL_TEXTURE_EXTERNAL_OES); m_state->enableTextureTarget(GL_TEXTURE_2D); } m_glActiveTexture_enc(this, texUnit); m_glBindTexture_enc(this, GL_TEXTURE_2D, m_state->getBoundTexture(newTarget)); return true; } return false; } void GL2Encoder::s_glUseProgram(void *self, GLuint program) { GL2Encoder *ctx = (GL2Encoder*)self; GLClientState* state = ctx->m_state; GLSharedGroupPtr shared = ctx->m_shared; ctx->m_glUseProgram_enc(self, program); ctx->m_state->setCurrentProgram(program); GLenum origActiveTexture = state->getActiveTextureUnit(); GLenum hostActiveTexture = origActiveTexture; GLint samplerIdx = -1; GLint samplerVal; GLenum samplerTarget; while ((samplerIdx = shared->getNextSamplerUniform(program, samplerIdx, &samplerVal, &samplerTarget)) != -1) { if (samplerVal < 0 || samplerVal >= GLClientState::MAX_TEXTURE_UNITS) continue; if (ctx->updateHostTexture2DBinding(GL_TEXTURE0 + samplerVal, samplerTarget)) { hostActiveTexture = GL_TEXTURE0 + samplerVal; } } state->setActiveTextureUnit(origActiveTexture); if (hostActiveTexture != origActiveTexture) { ctx->m_glActiveTexture_enc(self, origActiveTexture); } } void GL2Encoder::checkValidUniformParam(void *self, GLsizei count, GLboolean transpose) { GL2Encoder *ctx = (GL2Encoder*)self; GLuint program = ctx->m_state->currentProgram(); SET_ERROR_IF(!ctx->m_shared->isProgram(program), GL_INVALID_OPERATION); SET_ERROR_IF((count < 0 || transpose == GL_TRUE), GL_INVALID_VALUE); } void GL2Encoder::getHostLocation(void *self, GLint location, GLint *hostLoc) { GL2Encoder *ctx = (GL2Encoder*)self; GLuint program = ctx->m_state->currentProgram(); if (location == -1) { *hostLoc = location; return; } SET_ERROR_IF((location < 0), GL_INVALID_OPERATION); GLint curHostLoc = ctx->m_shared->locationWARAppToHost(program,location); SET_ERROR_IF((ctx->m_shared->getProgramUniformType(program,curHostLoc) == 0 && curHostLoc!=-1), GL_INVALID_OPERATION); *hostLoc = curHostLoc; } void GL2Encoder::s_glUniform1f(void *self , GLint location, GLfloat x) { GL2Encoder *ctx = (GL2Encoder*)self; GLint hostLoc; ctx->checkValidUniformParam(self, 0, GL_FALSE); ctx->getHostLocation(self, location, &hostLoc); ctx->m_glUniform1f_enc(self, hostLoc, x); } void GL2Encoder::s_glUniform1fv(void *self , GLint location, GLsizei count, const GLfloat* v) { GL2Encoder *ctx = (GL2Encoder*)self; GLint hostLoc; ctx->checkValidUniformParam(self, count, GL_FALSE); ctx->getHostLocation(self, location, &hostLoc); ctx->m_glUniform1fv_enc(self, hostLoc, count, v); } void GL2Encoder::s_glUniform1i(void *self , GLint location, GLint x) { GL2Encoder *ctx = (GL2Encoder*)self; GLClientState* state = ctx->m_state; GLSharedGroupPtr shared = ctx->m_shared; GLint hostLoc; ctx->checkValidUniformParam(self, 0, GL_FALSE); ctx->getHostLocation(self, location, &hostLoc); ctx->m_glUniform1i_enc(self, hostLoc, x); GLenum target; if (shared->setSamplerUniform(state->currentProgram(), location, x, &target)) { GLenum origActiveTexture = state->getActiveTextureUnit(); if (ctx->updateHostTexture2DBinding(GL_TEXTURE0 + x, target)) { ctx->m_glActiveTexture_enc(self, origActiveTexture); } state->setActiveTextureUnit(origActiveTexture); } } void GL2Encoder::s_glUniform1iv(void *self , GLint location, GLsizei count, const GLint* v) { GL2Encoder *ctx = (GL2Encoder*)self; GLint hostLoc; ctx->checkValidUniformParam(self, count, GL_FALSE); ctx->getHostLocation(self, location, &hostLoc); ctx->m_glUniform1iv_enc(self, hostLoc, count, v); } void GL2Encoder::s_glUniform2f(void *self , GLint location, GLfloat x, GLfloat y) { GL2Encoder *ctx = (GL2Encoder*)self; GLint hostLoc; ctx->checkValidUniformParam(self, 0, GL_FALSE); ctx->getHostLocation(self, location, &hostLoc); ctx->m_glUniform2f_enc(self, hostLoc, x, y); } void GL2Encoder::s_glUniform2fv(void *self , GLint location, GLsizei count, const GLfloat* v) { GL2Encoder *ctx = (GL2Encoder*)self; GLint hostLoc; ctx->checkValidUniformParam(self, count, GL_FALSE); ctx->getHostLocation(self, location, &hostLoc); ctx->m_glUniform2fv_enc(self, hostLoc, count, v); } void GL2Encoder::s_glUniform2i(void *self , GLint location, GLint x, GLint y) { GL2Encoder *ctx = (GL2Encoder*)self; GLint hostLoc; ctx->checkValidUniformParam(self, 0, GL_FALSE); ctx->getHostLocation(self, location, &hostLoc); ctx->m_glUniform2i_enc(self, hostLoc, x, y); } void GL2Encoder::s_glUniform2iv(void *self , GLint location, GLsizei count, const GLint* v) { GL2Encoder *ctx = (GL2Encoder*)self; GLint hostLoc; ctx->checkValidUniformParam(self, count, GL_FALSE); ctx->getHostLocation(self, location, &hostLoc); ctx->m_glUniform2iv_enc(self, hostLoc, count, v); } void GL2Encoder::s_glUniform3f(void *self , GLint location, GLfloat x, GLfloat y, GLfloat z) { GL2Encoder *ctx = (GL2Encoder*)self; GLint hostLoc; ctx->checkValidUniformParam(self, 0, GL_FALSE); ctx->getHostLocation(self, location, &hostLoc); ctx->m_glUniform3f_enc(self, hostLoc, x, y, z); } void GL2Encoder::s_glUniform3fv(void *self , GLint location, GLsizei count, const GLfloat* v) { GL2Encoder *ctx = (GL2Encoder*)self; GLint hostLoc; ctx->checkValidUniformParam(self, count, GL_FALSE); ctx->getHostLocation(self, location, &hostLoc); ctx->m_glUniform3fv_enc(self, hostLoc, count, v); } void GL2Encoder::s_glUniform3i(void *self , GLint location, GLint x, GLint y, GLint z) { GL2Encoder *ctx = (GL2Encoder*)self; GLint hostLoc; ctx->checkValidUniformParam(self, 0, GL_FALSE); ctx->getHostLocation(self, location, &hostLoc); ctx->m_glUniform3i_enc(self, hostLoc, x, y, z); } void GL2Encoder::s_glUniform3iv(void *self , GLint location, GLsizei count, const GLint* v) { GL2Encoder *ctx = (GL2Encoder*)self; GLint hostLoc; ctx->checkValidUniformParam(self, count, GL_FALSE); ctx->getHostLocation(self, location, &hostLoc); ctx->m_glUniform3iv_enc(self, hostLoc, count, v); } void GL2Encoder::s_glUniform4f(void *self , GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { GL2Encoder *ctx = (GL2Encoder*)self; GLint hostLoc; ctx->checkValidUniformParam(self, 0, GL_FALSE); ctx->getHostLocation(self, location, &hostLoc); ctx->m_glUniform4f_enc(self, hostLoc, x, y, z, w); } void GL2Encoder::s_glUniform4fv(void *self , GLint location, GLsizei count, const GLfloat* v) { GL2Encoder *ctx = (GL2Encoder*)self; GLint hostLoc; ctx->checkValidUniformParam(self, count, GL_FALSE); ctx->getHostLocation(self, location, &hostLoc); ctx->m_glUniform4fv_enc(self, hostLoc, count, v); } void GL2Encoder::s_glUniform4i(void *self , GLint location, GLint x, GLint y, GLint z, GLint w) { GL2Encoder *ctx = (GL2Encoder*)self; GLint hostLoc; ctx->checkValidUniformParam(self, 0, GL_FALSE); ctx->getHostLocation(self, location, &hostLoc); ctx->m_glUniform4i_enc(self, hostLoc, x, y, z, w); } void GL2Encoder::s_glUniform4iv(void *self , GLint location, GLsizei count, const GLint* v) { GL2Encoder *ctx = (GL2Encoder*)self; GLint hostLoc; ctx->checkValidUniformParam(self, count, GL_FALSE); ctx->getHostLocation(self, location, &hostLoc); ctx->m_glUniform4iv_enc(self, hostLoc, count, v); } void GL2Encoder::s_glUniformMatrix2fv(void *self , GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { GL2Encoder *ctx = (GL2Encoder*)self; GLint hostLoc; ctx->checkValidUniformParam(self, count, transpose); ctx->getHostLocation(self, location, &hostLoc); ctx->m_glUniformMatrix2fv_enc(self, hostLoc, count, transpose, value); } void GL2Encoder::s_glUniformMatrix3fv(void *self , GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { GL2Encoder *ctx = (GL2Encoder*)self; GLint hostLoc; ctx->checkValidUniformParam(self, count, transpose); ctx->getHostLocation(self, location, &hostLoc); ctx->m_glUniformMatrix3fv_enc(self, hostLoc, count, transpose, value); } void GL2Encoder::s_glUniformMatrix4fv(void *self , GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { GL2Encoder *ctx = (GL2Encoder*)self; GLint hostLoc; ctx->checkValidUniformParam(self, count, transpose); ctx->getHostLocation(self, location, &hostLoc); ctx->m_glUniformMatrix4fv_enc(self, hostLoc, count, transpose, value); } void GL2Encoder::s_glActiveTexture(void* self, GLenum texture) { GL2Encoder* ctx = (GL2Encoder*)self; GLClientState* state = ctx->m_state; GLenum err; SET_ERROR_IF((err = state->setActiveTextureUnit(texture)) != GL_NO_ERROR, err); ctx->m_glActiveTexture_enc(ctx, texture); } void GL2Encoder::s_glBindTexture(void* self, GLenum target, GLuint texture) { GL2Encoder* ctx = (GL2Encoder*)self; GLClientState* state = ctx->m_state; GLenum err; GLboolean firstUse; SET_ERROR_IF((err = state->bindTexture(target, texture, &firstUse)) != GL_NO_ERROR, err); if (target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES) { ctx->m_glBindTexture_enc(ctx, target, texture); return; } GLenum priorityTarget = state->getPriorityEnabledTarget(GL_TEXTURE_2D); if (target == GL_TEXTURE_EXTERNAL_OES && firstUse) { ctx->m_glBindTexture_enc(ctx, GL_TEXTURE_2D, texture); ctx->m_glTexParameteri_enc(ctx, GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); ctx->m_glTexParameteri_enc(ctx, GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); ctx->m_glTexParameteri_enc(ctx, GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); if (target != priorityTarget) { ctx->m_glBindTexture_enc(ctx, GL_TEXTURE_2D, state->getBoundTexture(GL_TEXTURE_2D)); } } if (target == priorityTarget) { ctx->m_glBindTexture_enc(ctx, GL_TEXTURE_2D, texture); } } void GL2Encoder::s_glDeleteTextures(void* self, GLsizei n, const GLuint* textures) { GL2Encoder* ctx = (GL2Encoder*)self; GLClientState* state = ctx->m_state; state->deleteTextures(n, textures); ctx->m_glDeleteTextures_enc(ctx, n, textures); } void GL2Encoder::s_glGetTexParameterfv(void* self, GLenum target, GLenum pname, GLfloat* params) { GL2Encoder* ctx = (GL2Encoder*)self; const GLClientState* state = ctx->m_state; if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { ctx->override2DTextureTarget(target); ctx->m_glGetTexParameterfv_enc(ctx, GL_TEXTURE_2D, pname, params); ctx->restore2DTextureTarget(); } else { ctx->m_glGetTexParameterfv_enc(ctx, target, pname, params); } } void GL2Encoder::s_glGetTexParameteriv(void* self, GLenum target, GLenum pname, GLint* params) { GL2Encoder* ctx = (GL2Encoder*)self; const GLClientState* state = ctx->m_state; switch (pname) { case GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES: *params = 1; break; default: if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { ctx->override2DTextureTarget(target); ctx->m_glGetTexParameteriv_enc(ctx, GL_TEXTURE_2D, pname, params); ctx->restore2DTextureTarget(); } else { ctx->m_glGetTexParameteriv_enc(ctx, target, pname, params); } break; } } static bool isValidTextureExternalParam(GLenum pname, GLenum param) { switch (pname) { case GL_TEXTURE_MIN_FILTER: case GL_TEXTURE_MAG_FILTER: return param == GL_NEAREST || param == GL_LINEAR; case GL_TEXTURE_WRAP_S: case GL_TEXTURE_WRAP_T: return param == GL_CLAMP_TO_EDGE; default: return true; } } void GL2Encoder::s_glTexParameterf(void* self, GLenum target, GLenum pname, GLfloat param) { GL2Encoder* ctx = (GL2Encoder*)self; const GLClientState* state = ctx->m_state; SET_ERROR_IF((target == GL_TEXTURE_EXTERNAL_OES && !isValidTextureExternalParam(pname, (GLenum)param)), GL_INVALID_ENUM); if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { ctx->override2DTextureTarget(target); ctx->m_glTexParameterf_enc(ctx, GL_TEXTURE_2D, pname, param); ctx->restore2DTextureTarget(); } else { ctx->m_glTexParameterf_enc(ctx, target, pname, param); } } void GL2Encoder::s_glTexParameterfv(void* self, GLenum target, GLenum pname, const GLfloat* params) { GL2Encoder* ctx = (GL2Encoder*)self; const GLClientState* state = ctx->m_state; SET_ERROR_IF((target == GL_TEXTURE_EXTERNAL_OES && !isValidTextureExternalParam(pname, (GLenum)params[0])), GL_INVALID_ENUM); if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { ctx->override2DTextureTarget(target); ctx->m_glTexParameterfv_enc(ctx, GL_TEXTURE_2D, pname, params); ctx->restore2DTextureTarget(); } else { ctx->m_glTexParameterfv_enc(ctx, target, pname, params); } } void GL2Encoder::s_glTexParameteri(void* self, GLenum target, GLenum pname, GLint param) { GL2Encoder* ctx = (GL2Encoder*)self; const GLClientState* state = ctx->m_state; SET_ERROR_IF((target == GL_TEXTURE_EXTERNAL_OES && !isValidTextureExternalParam(pname, (GLenum)param)), GL_INVALID_ENUM); if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { ctx->override2DTextureTarget(target); ctx->m_glTexParameteri_enc(ctx, GL_TEXTURE_2D, pname, param); ctx->restore2DTextureTarget(); } else { ctx->m_glTexParameteri_enc(ctx, target, pname, param); } } void GL2Encoder::s_glTexImage2D(void* self, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels) { GL2Encoder* ctx = (GL2Encoder*)self; if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { ctx->override2DTextureTarget(target); ctx->m_glTexImage2D_enc(ctx, target, level, internalformat, width, height, border, format, type, pixels); ctx->restore2DTextureTarget(); } else { ctx->m_glTexImage2D_enc(ctx, target, level, internalformat, width, height, border, format, type, pixels); } } void GL2Encoder::s_glTexSubImage2D(void* self, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels) { GL2Encoder* ctx = (GL2Encoder*)self; GLint maxTextureSize; ctx->glGetIntegerv(self, GL_MAX_TEXTURE_SIZE, &maxTextureSize); SET_ERROR_IF((level < 0 || level > log2(maxTextureSize)), GL_INVALID_VALUE); if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { ctx->override2DTextureTarget(target); ctx->m_glTexSubImage2D_enc(ctx, target, level, xoffset, yoffset, width, height, format, type, pixels); ctx->restore2DTextureTarget(); } else { ctx->m_glTexSubImage2D_enc(ctx, target, level, xoffset, yoffset, width, height, format, type, pixels); } } void GL2Encoder::s_glTexParameteriv(void* self, GLenum target, GLenum pname, const GLint* params) { GL2Encoder* ctx = (GL2Encoder*)self; const GLClientState* state = ctx->m_state; SET_ERROR_IF((target == GL_TEXTURE_EXTERNAL_OES && !isValidTextureExternalParam(pname, (GLenum)params[0])), GL_INVALID_ENUM); if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { ctx->override2DTextureTarget(target); ctx->m_glTexParameteriv_enc(ctx, GL_TEXTURE_2D, pname, params); ctx->restore2DTextureTarget(); } else { ctx->m_glTexParameteriv_enc(ctx, target, pname, params); } } void GL2Encoder::override2DTextureTarget(GLenum target) { if ((target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) && target != m_state->getPriorityEnabledTarget(GL_TEXTURE_2D)) { m_glBindTexture_enc(this, GL_TEXTURE_2D, m_state->getBoundTexture(target)); } } void GL2Encoder::restore2DTextureTarget() { GLenum priorityTarget = m_state->getPriorityEnabledTarget(GL_TEXTURE_2D); m_glBindTexture_enc(this, GL_TEXTURE_2D, m_state->getBoundTexture(priorityTarget)); } anbox-0.0~git20191115/android/opengl/system/GLESv2_enc/GL2Encoder.h000066400000000000000000000275151356361734700243530ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _GL2_ENCODER_H_ #define _GL2_ENCODER_H_ #include "gl2_enc.h" #include "GLClientState.h" #include "GLSharedGroup.h" #include "FixedBuffer.h" class GL2Encoder : public gl2_encoder_context_t { public: GL2Encoder(IOStream *stream, ChecksumCalculator* protocol); virtual ~GL2Encoder(); void setClientState(GLClientState *state) { m_state = state; } void setSharedGroup(GLSharedGroupPtr shared){ m_shared = shared; } const GLClientState *state() { return m_state; } const GLSharedGroupPtr shared() { return m_shared; } void flush() { m_stream->flush(); } void setInitialized(){ m_initialized = true; }; bool isInitialized(){ return m_initialized; }; virtual void setError(GLenum error){ m_error = error; }; virtual GLenum getError() { return m_error; }; void override2DTextureTarget(GLenum target); void restore2DTextureTarget(); private: bool m_initialized; GLClientState *m_state; GLSharedGroupPtr m_shared; GLenum m_error; GLint *m_compressedTextureFormats; GLint m_num_compressedTextureFormats; GLint *getCompressedTextureFormats(); GLint m_max_cubeMapTextureSize; GLint m_max_renderBufferSize; GLint m_max_textureSize; FixedBuffer m_fixedBuffer; void sendVertexAttributes(GLint first, GLsizei count); bool updateHostTexture2DBinding(GLenum texUnit, GLenum newTarget); void checkValidUniformParam(void * self, GLsizei count, GLboolean transpose); void getHostLocation(void *self, GLint location, GLint *hostLoc); glGetError_client_proc_t m_glGetError_enc; static GLenum s_glGetError(void * self); glFlush_client_proc_t m_glFlush_enc; static void s_glFlush(void * self); glPixelStorei_client_proc_t m_glPixelStorei_enc; static void s_glPixelStorei(void *self, GLenum param, GLint value); glGetString_client_proc_t m_glGetString_enc; static const GLubyte * s_glGetString(void *self, GLenum name); glBindBuffer_client_proc_t m_glBindBuffer_enc; static void s_glBindBuffer(void *self, GLenum target, GLuint id); glBufferData_client_proc_t m_glBufferData_enc; static void s_glBufferData(void *self, GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage); glBufferSubData_client_proc_t m_glBufferSubData_enc; static void s_glBufferSubData(void *self, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data); glDeleteBuffers_client_proc_t m_glDeleteBuffers_enc; static void s_glDeleteBuffers(void *self, GLsizei n, const GLuint * buffers); glDrawArrays_client_proc_t m_glDrawArrays_enc; static void s_glDrawArrays(void *self, GLenum mode, GLint first, GLsizei count); glDrawElements_client_proc_t m_glDrawElements_enc; static void s_glDrawElements(void *self, GLenum mode, GLsizei count, GLenum type, const void *indices); glGetIntegerv_client_proc_t m_glGetIntegerv_enc; static void s_glGetIntegerv(void *self, GLenum pname, GLint *ptr); glGetFloatv_client_proc_t m_glGetFloatv_enc; static void s_glGetFloatv(void *self, GLenum pname, GLfloat *ptr); glGetBooleanv_client_proc_t m_glGetBooleanv_enc; static void s_glGetBooleanv(void *self, GLenum pname, GLboolean *ptr); glVertexAttribPointer_client_proc_t m_glVertexAttribPointer_enc; static void s_glVertexAttribPointer(void *self, GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * ptr); glEnableVertexAttribArray_client_proc_t m_glEnableVertexAttribArray_enc; static void s_glEnableVertexAttribArray(void *self, GLuint index); glDisableVertexAttribArray_client_proc_t m_glDisableVertexAttribArray_enc; static void s_glDisableVertexAttribArray(void *self, GLuint index); glGetVertexAttribiv_client_proc_t m_glGetVertexAttribiv_enc; static void s_glGetVertexAttribiv(void *self, GLuint index, GLenum pname, GLint *params); glGetVertexAttribfv_client_proc_t m_glGetVertexAttribfv_enc; static void s_glGetVertexAttribfv(void *self, GLuint index, GLenum pname, GLfloat *params); glGetVertexAttribPointerv_client_proc_t m_glGetVertexAttribPointerv_enc; static void s_glGetVertexAttribPointerv(void *self, GLuint index, GLenum pname, GLvoid **pointer); static void s_glShaderBinary(void *self, GLsizei n, const GLuint *shaders, GLenum binaryformat, const void* binary, GLsizei length); static void s_glShaderSource(void *self, GLuint shader, GLsizei count, const GLchar * const *string, const GLint *length); static void s_glFinish(void *self); glLinkProgram_client_proc_t m_glLinkProgram_enc; static void s_glLinkProgram(void *self, GLuint program); glDeleteProgram_client_proc_t m_glDeleteProgram_enc; static void s_glDeleteProgram(void * self, GLuint program); glGetUniformiv_client_proc_t m_glGetUniformiv_enc; static void s_glGetUniformiv(void *self, GLuint program, GLint location , GLint *params); glGetUniformfv_client_proc_t m_glGetUniformfv_enc; static void s_glGetUniformfv(void *self, GLuint program, GLint location , GLfloat *params); glCreateProgram_client_proc_t m_glCreateProgram_enc; static GLuint s_glCreateProgram(void *self); glCreateShader_client_proc_t m_glCreateShader_enc; static GLuint s_glCreateShader(void *self, GLenum shaderType); glDeleteShader_client_proc_t m_glDeleteShader_enc; static void s_glDeleteShader(void *self, GLuint shader); glAttachShader_client_proc_t m_glAttachShader_enc; static void s_glAttachShader(void *self, GLuint program, GLuint shader); glDetachShader_client_proc_t m_glDetachShader_enc; static void s_glDetachShader(void *self, GLuint program, GLuint shader); glGetAttachedShaders_client_proc_t m_glGetAttachedShaders_enc; static void s_glGetAttachedShaders(void *self, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* shaders); glGetShaderSource_client_proc_t m_glGetShaderSource_enc; static void s_glGetShaderSource(void *self, GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source); glGetShaderInfoLog_client_proc_t m_glGetShaderInfoLog_enc; static void s_glGetShaderInfoLog(void *self,GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog); glGetProgramInfoLog_client_proc_t m_glGetProgramInfoLog_enc; static void s_glGetProgramInfoLog(void *self,GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog); glGetUniformLocation_client_proc_t m_glGetUniformLocation_enc; static int s_glGetUniformLocation(void *self, GLuint program, const GLchar *name); glUseProgram_client_proc_t m_glUseProgram_enc; glUniform1f_client_proc_t m_glUniform1f_enc; glUniform1fv_client_proc_t m_glUniform1fv_enc; glUniform1i_client_proc_t m_glUniform1i_enc; glUniform1iv_client_proc_t m_glUniform1iv_enc; glUniform2f_client_proc_t m_glUniform2f_enc; glUniform2fv_client_proc_t m_glUniform2fv_enc; glUniform2i_client_proc_t m_glUniform2i_enc; glUniform2iv_client_proc_t m_glUniform2iv_enc; glUniform3f_client_proc_t m_glUniform3f_enc; glUniform3fv_client_proc_t m_glUniform3fv_enc; glUniform3i_client_proc_t m_glUniform3i_enc; glUniform3iv_client_proc_t m_glUniform3iv_enc; glUniform4f_client_proc_t m_glUniform4f_enc; glUniform4fv_client_proc_t m_glUniform4fv_enc; glUniform4i_client_proc_t m_glUniform4i_enc; glUniform4iv_client_proc_t m_glUniform4iv_enc; glUniformMatrix2fv_client_proc_t m_glUniformMatrix2fv_enc; glUniformMatrix3fv_client_proc_t m_glUniformMatrix3fv_enc; glUniformMatrix4fv_client_proc_t m_glUniformMatrix4fv_enc; static void s_glUseProgram(void *self, GLuint program); static void s_glUniform1f(void *self , GLint location, GLfloat x); static void s_glUniform1fv(void *self , GLint location, GLsizei count, const GLfloat* v); static void s_glUniform1i(void *self , GLint location, GLint x); static void s_glUniform1iv(void *self , GLint location, GLsizei count, const GLint* v); static void s_glUniform2f(void *self , GLint location, GLfloat x, GLfloat y); static void s_glUniform2fv(void *self , GLint location, GLsizei count, const GLfloat* v); static void s_glUniform2i(void *self , GLint location, GLint x, GLint y); static void s_glUniform2iv(void *self , GLint location, GLsizei count, const GLint* v); static void s_glUniform3f(void *self , GLint location, GLfloat x, GLfloat y, GLfloat z); static void s_glUniform3fv(void *self , GLint location, GLsizei count, const GLfloat* v); static void s_glUniform3i(void *self , GLint location, GLint x, GLint y, GLint z); static void s_glUniform3iv(void *self , GLint location, GLsizei count, const GLint* v); static void s_glUniform4f(void *self , GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w); static void s_glUniform4fv(void *self , GLint location, GLsizei count, const GLfloat* v); static void s_glUniform4i(void *self , GLint location, GLint x, GLint y, GLint z, GLint w); static void s_glUniform4iv(void *self , GLint location, GLsizei count, const GLint* v); static void s_glUniformMatrix2fv(void *self , GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); static void s_glUniformMatrix3fv(void *self , GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); static void s_glUniformMatrix4fv(void *self , GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); glActiveTexture_client_proc_t m_glActiveTexture_enc; glBindTexture_client_proc_t m_glBindTexture_enc; glDeleteTextures_client_proc_t m_glDeleteTextures_enc; glGetTexParameterfv_client_proc_t m_glGetTexParameterfv_enc; glGetTexParameteriv_client_proc_t m_glGetTexParameteriv_enc; glTexParameterf_client_proc_t m_glTexParameterf_enc; glTexParameterfv_client_proc_t m_glTexParameterfv_enc; glTexParameteri_client_proc_t m_glTexParameteri_enc; glTexParameteriv_client_proc_t m_glTexParameteriv_enc; glTexImage2D_client_proc_t m_glTexImage2D_enc; glTexSubImage2D_client_proc_t m_glTexSubImage2D_enc; static void s_glActiveTexture(void* self, GLenum texture); static void s_glBindTexture(void* self, GLenum target, GLuint texture); static void s_glDeleteTextures(void* self, GLsizei n, const GLuint* textures); static void s_glGetTexParameterfv(void* self, GLenum target, GLenum pname, GLfloat* params); static void s_glGetTexParameteriv(void* self, GLenum target, GLenum pname, GLint* params); static void s_glTexParameterf(void* self, GLenum target, GLenum pname, GLfloat param); static void s_glTexParameterfv(void* self, GLenum target, GLenum pname, const GLfloat* params); static void s_glTexParameteri(void* self, GLenum target, GLenum pname, GLint param); static void s_glTexParameteriv(void* self, GLenum target, GLenum pname, const GLint* params); static void s_glTexImage2D(void* self, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels); static void s_glTexSubImage2D(void* self, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels); public: glEGLImageTargetTexture2DOES_client_proc_t m_glEGLImageTargetTexture2DOES_enc; }; #endif anbox-0.0~git20191115/android/opengl/system/GLESv2_enc/GL2EncoderUtils.cpp000066400000000000000000000026451356361734700257240ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include "GL2Encoder.h" #include namespace glesv2_enc { size_t pixelDataSize(void *self, GLsizei width, GLsizei height, GLenum format, GLenum type, int pack) { GL2Encoder *ctx = (GL2Encoder *)self; assert (ctx->state() != NULL); return ctx->state()->pixelDataSize(width, height, format, type, pack); } size_t pixelDataSize3D(void *self, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, int pack) { size_t layerSize = pixelDataSize(self, width, height, format, type, pack); return layerSize * depth; } GLenum uniformType(void * self, GLuint program, GLint location) { GL2Encoder * ctx = (GL2Encoder *) self; assert (ctx->shared() != NULL); return ctx->shared()->getProgramUniformType(program, location); } } // namespace glesv2_enc anbox-0.0~git20191115/android/opengl/system/GLESv2_enc/GL2EncoderUtils.h000066400000000000000000000017561356361734700253730ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef GL2_ENCODER_UTILS_H #define GL2_ENCODER_UTILS_H namespace glesv2_enc { size_t pixelDataSize(void *self, GLsizei width, GLsizei height, GLenum format, GLenum type, int pack); size_t pixelDataSize3D(void *self, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, int pack); GLenum uniformType(void * self, GLuint program, GLint location); } // namespace glesv2_enc #endif anbox-0.0~git20191115/android/opengl/system/GLESv2_enc/gl2_client_context.cpp000066400000000000000000000476131356361734700266110ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #include #include "gl2_client_context.h" #include int gl2_client_context_t::initDispatchByName(void *(*getProc)(const char *, void *userData), void *userData) { glActiveTexture = (glActiveTexture_client_proc_t) getProc("glActiveTexture", userData); glAttachShader = (glAttachShader_client_proc_t) getProc("glAttachShader", userData); glBindAttribLocation = (glBindAttribLocation_client_proc_t) getProc("glBindAttribLocation", userData); glBindBuffer = (glBindBuffer_client_proc_t) getProc("glBindBuffer", userData); glBindFramebuffer = (glBindFramebuffer_client_proc_t) getProc("glBindFramebuffer", userData); glBindRenderbuffer = (glBindRenderbuffer_client_proc_t) getProc("glBindRenderbuffer", userData); glBindTexture = (glBindTexture_client_proc_t) getProc("glBindTexture", userData); glBlendColor = (glBlendColor_client_proc_t) getProc("glBlendColor", userData); glBlendEquation = (glBlendEquation_client_proc_t) getProc("glBlendEquation", userData); glBlendEquationSeparate = (glBlendEquationSeparate_client_proc_t) getProc("glBlendEquationSeparate", userData); glBlendFunc = (glBlendFunc_client_proc_t) getProc("glBlendFunc", userData); glBlendFuncSeparate = (glBlendFuncSeparate_client_proc_t) getProc("glBlendFuncSeparate", userData); glBufferData = (glBufferData_client_proc_t) getProc("glBufferData", userData); glBufferSubData = (glBufferSubData_client_proc_t) getProc("glBufferSubData", userData); glCheckFramebufferStatus = (glCheckFramebufferStatus_client_proc_t) getProc("glCheckFramebufferStatus", userData); glClear = (glClear_client_proc_t) getProc("glClear", userData); glClearColor = (glClearColor_client_proc_t) getProc("glClearColor", userData); glClearDepthf = (glClearDepthf_client_proc_t) getProc("glClearDepthf", userData); glClearStencil = (glClearStencil_client_proc_t) getProc("glClearStencil", userData); glColorMask = (glColorMask_client_proc_t) getProc("glColorMask", userData); glCompileShader = (glCompileShader_client_proc_t) getProc("glCompileShader", userData); glCompressedTexImage2D = (glCompressedTexImage2D_client_proc_t) getProc("glCompressedTexImage2D", userData); glCompressedTexSubImage2D = (glCompressedTexSubImage2D_client_proc_t) getProc("glCompressedTexSubImage2D", userData); glCopyTexImage2D = (glCopyTexImage2D_client_proc_t) getProc("glCopyTexImage2D", userData); glCopyTexSubImage2D = (glCopyTexSubImage2D_client_proc_t) getProc("glCopyTexSubImage2D", userData); glCreateProgram = (glCreateProgram_client_proc_t) getProc("glCreateProgram", userData); glCreateShader = (glCreateShader_client_proc_t) getProc("glCreateShader", userData); glCullFace = (glCullFace_client_proc_t) getProc("glCullFace", userData); glDeleteBuffers = (glDeleteBuffers_client_proc_t) getProc("glDeleteBuffers", userData); glDeleteFramebuffers = (glDeleteFramebuffers_client_proc_t) getProc("glDeleteFramebuffers", userData); glDeleteProgram = (glDeleteProgram_client_proc_t) getProc("glDeleteProgram", userData); glDeleteRenderbuffers = (glDeleteRenderbuffers_client_proc_t) getProc("glDeleteRenderbuffers", userData); glDeleteShader = (glDeleteShader_client_proc_t) getProc("glDeleteShader", userData); glDeleteTextures = (glDeleteTextures_client_proc_t) getProc("glDeleteTextures", userData); glDepthFunc = (glDepthFunc_client_proc_t) getProc("glDepthFunc", userData); glDepthMask = (glDepthMask_client_proc_t) getProc("glDepthMask", userData); glDepthRangef = (glDepthRangef_client_proc_t) getProc("glDepthRangef", userData); glDetachShader = (glDetachShader_client_proc_t) getProc("glDetachShader", userData); glDisable = (glDisable_client_proc_t) getProc("glDisable", userData); glDisableVertexAttribArray = (glDisableVertexAttribArray_client_proc_t) getProc("glDisableVertexAttribArray", userData); glDrawArrays = (glDrawArrays_client_proc_t) getProc("glDrawArrays", userData); glDrawElements = (glDrawElements_client_proc_t) getProc("glDrawElements", userData); glEnable = (glEnable_client_proc_t) getProc("glEnable", userData); glEnableVertexAttribArray = (glEnableVertexAttribArray_client_proc_t) getProc("glEnableVertexAttribArray", userData); glFinish = (glFinish_client_proc_t) getProc("glFinish", userData); glFlush = (glFlush_client_proc_t) getProc("glFlush", userData); glFramebufferRenderbuffer = (glFramebufferRenderbuffer_client_proc_t) getProc("glFramebufferRenderbuffer", userData); glFramebufferTexture2D = (glFramebufferTexture2D_client_proc_t) getProc("glFramebufferTexture2D", userData); glFrontFace = (glFrontFace_client_proc_t) getProc("glFrontFace", userData); glGenBuffers = (glGenBuffers_client_proc_t) getProc("glGenBuffers", userData); glGenerateMipmap = (glGenerateMipmap_client_proc_t) getProc("glGenerateMipmap", userData); glGenFramebuffers = (glGenFramebuffers_client_proc_t) getProc("glGenFramebuffers", userData); glGenRenderbuffers = (glGenRenderbuffers_client_proc_t) getProc("glGenRenderbuffers", userData); glGenTextures = (glGenTextures_client_proc_t) getProc("glGenTextures", userData); glGetActiveAttrib = (glGetActiveAttrib_client_proc_t) getProc("glGetActiveAttrib", userData); glGetActiveUniform = (glGetActiveUniform_client_proc_t) getProc("glGetActiveUniform", userData); glGetAttachedShaders = (glGetAttachedShaders_client_proc_t) getProc("glGetAttachedShaders", userData); glGetAttribLocation = (glGetAttribLocation_client_proc_t) getProc("glGetAttribLocation", userData); glGetBooleanv = (glGetBooleanv_client_proc_t) getProc("glGetBooleanv", userData); glGetBufferParameteriv = (glGetBufferParameteriv_client_proc_t) getProc("glGetBufferParameteriv", userData); glGetError = (glGetError_client_proc_t) getProc("glGetError", userData); glGetFloatv = (glGetFloatv_client_proc_t) getProc("glGetFloatv", userData); glGetFramebufferAttachmentParameteriv = (glGetFramebufferAttachmentParameteriv_client_proc_t) getProc("glGetFramebufferAttachmentParameteriv", userData); glGetIntegerv = (glGetIntegerv_client_proc_t) getProc("glGetIntegerv", userData); glGetProgramiv = (glGetProgramiv_client_proc_t) getProc("glGetProgramiv", userData); glGetProgramInfoLog = (glGetProgramInfoLog_client_proc_t) getProc("glGetProgramInfoLog", userData); glGetRenderbufferParameteriv = (glGetRenderbufferParameteriv_client_proc_t) getProc("glGetRenderbufferParameteriv", userData); glGetShaderiv = (glGetShaderiv_client_proc_t) getProc("glGetShaderiv", userData); glGetShaderInfoLog = (glGetShaderInfoLog_client_proc_t) getProc("glGetShaderInfoLog", userData); glGetShaderPrecisionFormat = (glGetShaderPrecisionFormat_client_proc_t) getProc("glGetShaderPrecisionFormat", userData); glGetShaderSource = (glGetShaderSource_client_proc_t) getProc("glGetShaderSource", userData); glGetString = (glGetString_client_proc_t) getProc("glGetString", userData); glGetTexParameterfv = (glGetTexParameterfv_client_proc_t) getProc("glGetTexParameterfv", userData); glGetTexParameteriv = (glGetTexParameteriv_client_proc_t) getProc("glGetTexParameteriv", userData); glGetUniformfv = (glGetUniformfv_client_proc_t) getProc("glGetUniformfv", userData); glGetUniformiv = (glGetUniformiv_client_proc_t) getProc("glGetUniformiv", userData); glGetUniformLocation = (glGetUniformLocation_client_proc_t) getProc("glGetUniformLocation", userData); glGetVertexAttribfv = (glGetVertexAttribfv_client_proc_t) getProc("glGetVertexAttribfv", userData); glGetVertexAttribiv = (glGetVertexAttribiv_client_proc_t) getProc("glGetVertexAttribiv", userData); glGetVertexAttribPointerv = (glGetVertexAttribPointerv_client_proc_t) getProc("glGetVertexAttribPointerv", userData); glHint = (glHint_client_proc_t) getProc("glHint", userData); glIsBuffer = (glIsBuffer_client_proc_t) getProc("glIsBuffer", userData); glIsEnabled = (glIsEnabled_client_proc_t) getProc("glIsEnabled", userData); glIsFramebuffer = (glIsFramebuffer_client_proc_t) getProc("glIsFramebuffer", userData); glIsProgram = (glIsProgram_client_proc_t) getProc("glIsProgram", userData); glIsRenderbuffer = (glIsRenderbuffer_client_proc_t) getProc("glIsRenderbuffer", userData); glIsShader = (glIsShader_client_proc_t) getProc("glIsShader", userData); glIsTexture = (glIsTexture_client_proc_t) getProc("glIsTexture", userData); glLineWidth = (glLineWidth_client_proc_t) getProc("glLineWidth", userData); glLinkProgram = (glLinkProgram_client_proc_t) getProc("glLinkProgram", userData); glPixelStorei = (glPixelStorei_client_proc_t) getProc("glPixelStorei", userData); glPolygonOffset = (glPolygonOffset_client_proc_t) getProc("glPolygonOffset", userData); glReadPixels = (glReadPixels_client_proc_t) getProc("glReadPixels", userData); glReleaseShaderCompiler = (glReleaseShaderCompiler_client_proc_t) getProc("glReleaseShaderCompiler", userData); glRenderbufferStorage = (glRenderbufferStorage_client_proc_t) getProc("glRenderbufferStorage", userData); glSampleCoverage = (glSampleCoverage_client_proc_t) getProc("glSampleCoverage", userData); glScissor = (glScissor_client_proc_t) getProc("glScissor", userData); glShaderBinary = (glShaderBinary_client_proc_t) getProc("glShaderBinary", userData); glShaderSource = (glShaderSource_client_proc_t) getProc("glShaderSource", userData); glStencilFunc = (glStencilFunc_client_proc_t) getProc("glStencilFunc", userData); glStencilFuncSeparate = (glStencilFuncSeparate_client_proc_t) getProc("glStencilFuncSeparate", userData); glStencilMask = (glStencilMask_client_proc_t) getProc("glStencilMask", userData); glStencilMaskSeparate = (glStencilMaskSeparate_client_proc_t) getProc("glStencilMaskSeparate", userData); glStencilOp = (glStencilOp_client_proc_t) getProc("glStencilOp", userData); glStencilOpSeparate = (glStencilOpSeparate_client_proc_t) getProc("glStencilOpSeparate", userData); glTexImage2D = (glTexImage2D_client_proc_t) getProc("glTexImage2D", userData); glTexParameterf = (glTexParameterf_client_proc_t) getProc("glTexParameterf", userData); glTexParameterfv = (glTexParameterfv_client_proc_t) getProc("glTexParameterfv", userData); glTexParameteri = (glTexParameteri_client_proc_t) getProc("glTexParameteri", userData); glTexParameteriv = (glTexParameteriv_client_proc_t) getProc("glTexParameteriv", userData); glTexSubImage2D = (glTexSubImage2D_client_proc_t) getProc("glTexSubImage2D", userData); glUniform1f = (glUniform1f_client_proc_t) getProc("glUniform1f", userData); glUniform1fv = (glUniform1fv_client_proc_t) getProc("glUniform1fv", userData); glUniform1i = (glUniform1i_client_proc_t) getProc("glUniform1i", userData); glUniform1iv = (glUniform1iv_client_proc_t) getProc("glUniform1iv", userData); glUniform2f = (glUniform2f_client_proc_t) getProc("glUniform2f", userData); glUniform2fv = (glUniform2fv_client_proc_t) getProc("glUniform2fv", userData); glUniform2i = (glUniform2i_client_proc_t) getProc("glUniform2i", userData); glUniform2iv = (glUniform2iv_client_proc_t) getProc("glUniform2iv", userData); glUniform3f = (glUniform3f_client_proc_t) getProc("glUniform3f", userData); glUniform3fv = (glUniform3fv_client_proc_t) getProc("glUniform3fv", userData); glUniform3i = (glUniform3i_client_proc_t) getProc("glUniform3i", userData); glUniform3iv = (glUniform3iv_client_proc_t) getProc("glUniform3iv", userData); glUniform4f = (glUniform4f_client_proc_t) getProc("glUniform4f", userData); glUniform4fv = (glUniform4fv_client_proc_t) getProc("glUniform4fv", userData); glUniform4i = (glUniform4i_client_proc_t) getProc("glUniform4i", userData); glUniform4iv = (glUniform4iv_client_proc_t) getProc("glUniform4iv", userData); glUniformMatrix2fv = (glUniformMatrix2fv_client_proc_t) getProc("glUniformMatrix2fv", userData); glUniformMatrix3fv = (glUniformMatrix3fv_client_proc_t) getProc("glUniformMatrix3fv", userData); glUniformMatrix4fv = (glUniformMatrix4fv_client_proc_t) getProc("glUniformMatrix4fv", userData); glUseProgram = (glUseProgram_client_proc_t) getProc("glUseProgram", userData); glValidateProgram = (glValidateProgram_client_proc_t) getProc("glValidateProgram", userData); glVertexAttrib1f = (glVertexAttrib1f_client_proc_t) getProc("glVertexAttrib1f", userData); glVertexAttrib1fv = (glVertexAttrib1fv_client_proc_t) getProc("glVertexAttrib1fv", userData); glVertexAttrib2f = (glVertexAttrib2f_client_proc_t) getProc("glVertexAttrib2f", userData); glVertexAttrib2fv = (glVertexAttrib2fv_client_proc_t) getProc("glVertexAttrib2fv", userData); glVertexAttrib3f = (glVertexAttrib3f_client_proc_t) getProc("glVertexAttrib3f", userData); glVertexAttrib3fv = (glVertexAttrib3fv_client_proc_t) getProc("glVertexAttrib3fv", userData); glVertexAttrib4f = (glVertexAttrib4f_client_proc_t) getProc("glVertexAttrib4f", userData); glVertexAttrib4fv = (glVertexAttrib4fv_client_proc_t) getProc("glVertexAttrib4fv", userData); glVertexAttribPointer = (glVertexAttribPointer_client_proc_t) getProc("glVertexAttribPointer", userData); glViewport = (glViewport_client_proc_t) getProc("glViewport", userData); glEGLImageTargetTexture2DOES = (glEGLImageTargetTexture2DOES_client_proc_t) getProc("glEGLImageTargetTexture2DOES", userData); glEGLImageTargetRenderbufferStorageOES = (glEGLImageTargetRenderbufferStorageOES_client_proc_t) getProc("glEGLImageTargetRenderbufferStorageOES", userData); glGetProgramBinaryOES = (glGetProgramBinaryOES_client_proc_t) getProc("glGetProgramBinaryOES", userData); glProgramBinaryOES = (glProgramBinaryOES_client_proc_t) getProc("glProgramBinaryOES", userData); glMapBufferOES = (glMapBufferOES_client_proc_t) getProc("glMapBufferOES", userData); glUnmapBufferOES = (glUnmapBufferOES_client_proc_t) getProc("glUnmapBufferOES", userData); glTexImage3DOES = (glTexImage3DOES_client_proc_t) getProc("glTexImage3DOES", userData); glTexSubImage3DOES = (glTexSubImage3DOES_client_proc_t) getProc("glTexSubImage3DOES", userData); glCopyTexSubImage3DOES = (glCopyTexSubImage3DOES_client_proc_t) getProc("glCopyTexSubImage3DOES", userData); glCompressedTexImage3DOES = (glCompressedTexImage3DOES_client_proc_t) getProc("glCompressedTexImage3DOES", userData); glCompressedTexSubImage3DOES = (glCompressedTexSubImage3DOES_client_proc_t) getProc("glCompressedTexSubImage3DOES", userData); glFramebufferTexture3DOES = (glFramebufferTexture3DOES_client_proc_t) getProc("glFramebufferTexture3DOES", userData); glBindVertexArrayOES = (glBindVertexArrayOES_client_proc_t) getProc("glBindVertexArrayOES", userData); glDeleteVertexArraysOES = (glDeleteVertexArraysOES_client_proc_t) getProc("glDeleteVertexArraysOES", userData); glGenVertexArraysOES = (glGenVertexArraysOES_client_proc_t) getProc("glGenVertexArraysOES", userData); glIsVertexArrayOES = (glIsVertexArrayOES_client_proc_t) getProc("glIsVertexArrayOES", userData); glDiscardFramebufferEXT = (glDiscardFramebufferEXT_client_proc_t) getProc("glDiscardFramebufferEXT", userData); glMultiDrawArraysEXT = (glMultiDrawArraysEXT_client_proc_t) getProc("glMultiDrawArraysEXT", userData); glMultiDrawElementsEXT = (glMultiDrawElementsEXT_client_proc_t) getProc("glMultiDrawElementsEXT", userData); glGetPerfMonitorGroupsAMD = (glGetPerfMonitorGroupsAMD_client_proc_t) getProc("glGetPerfMonitorGroupsAMD", userData); glGetPerfMonitorCountersAMD = (glGetPerfMonitorCountersAMD_client_proc_t) getProc("glGetPerfMonitorCountersAMD", userData); glGetPerfMonitorGroupStringAMD = (glGetPerfMonitorGroupStringAMD_client_proc_t) getProc("glGetPerfMonitorGroupStringAMD", userData); glGetPerfMonitorCounterStringAMD = (glGetPerfMonitorCounterStringAMD_client_proc_t) getProc("glGetPerfMonitorCounterStringAMD", userData); glGetPerfMonitorCounterInfoAMD = (glGetPerfMonitorCounterInfoAMD_client_proc_t) getProc("glGetPerfMonitorCounterInfoAMD", userData); glGenPerfMonitorsAMD = (glGenPerfMonitorsAMD_client_proc_t) getProc("glGenPerfMonitorsAMD", userData); glDeletePerfMonitorsAMD = (glDeletePerfMonitorsAMD_client_proc_t) getProc("glDeletePerfMonitorsAMD", userData); glSelectPerfMonitorCountersAMD = (glSelectPerfMonitorCountersAMD_client_proc_t) getProc("glSelectPerfMonitorCountersAMD", userData); glBeginPerfMonitorAMD = (glBeginPerfMonitorAMD_client_proc_t) getProc("glBeginPerfMonitorAMD", userData); glEndPerfMonitorAMD = (glEndPerfMonitorAMD_client_proc_t) getProc("glEndPerfMonitorAMD", userData); glGetPerfMonitorCounterDataAMD = (glGetPerfMonitorCounterDataAMD_client_proc_t) getProc("glGetPerfMonitorCounterDataAMD", userData); glRenderbufferStorageMultisampleIMG = (glRenderbufferStorageMultisampleIMG_client_proc_t) getProc("glRenderbufferStorageMultisampleIMG", userData); glFramebufferTexture2DMultisampleIMG = (glFramebufferTexture2DMultisampleIMG_client_proc_t) getProc("glFramebufferTexture2DMultisampleIMG", userData); glDeleteFencesNV = (glDeleteFencesNV_client_proc_t) getProc("glDeleteFencesNV", userData); glGenFencesNV = (glGenFencesNV_client_proc_t) getProc("glGenFencesNV", userData); glIsFenceNV = (glIsFenceNV_client_proc_t) getProc("glIsFenceNV", userData); glTestFenceNV = (glTestFenceNV_client_proc_t) getProc("glTestFenceNV", userData); glGetFenceivNV = (glGetFenceivNV_client_proc_t) getProc("glGetFenceivNV", userData); glFinishFenceNV = (glFinishFenceNV_client_proc_t) getProc("glFinishFenceNV", userData); glSetFenceNV = (glSetFenceNV_client_proc_t) getProc("glSetFenceNV", userData); glCoverageMaskNV = (glCoverageMaskNV_client_proc_t) getProc("glCoverageMaskNV", userData); glCoverageOperationNV = (glCoverageOperationNV_client_proc_t) getProc("glCoverageOperationNV", userData); glGetDriverControlsQCOM = (glGetDriverControlsQCOM_client_proc_t) getProc("glGetDriverControlsQCOM", userData); glGetDriverControlStringQCOM = (glGetDriverControlStringQCOM_client_proc_t) getProc("glGetDriverControlStringQCOM", userData); glEnableDriverControlQCOM = (glEnableDriverControlQCOM_client_proc_t) getProc("glEnableDriverControlQCOM", userData); glDisableDriverControlQCOM = (glDisableDriverControlQCOM_client_proc_t) getProc("glDisableDriverControlQCOM", userData); glExtGetTexturesQCOM = (glExtGetTexturesQCOM_client_proc_t) getProc("glExtGetTexturesQCOM", userData); glExtGetBuffersQCOM = (glExtGetBuffersQCOM_client_proc_t) getProc("glExtGetBuffersQCOM", userData); glExtGetRenderbuffersQCOM = (glExtGetRenderbuffersQCOM_client_proc_t) getProc("glExtGetRenderbuffersQCOM", userData); glExtGetFramebuffersQCOM = (glExtGetFramebuffersQCOM_client_proc_t) getProc("glExtGetFramebuffersQCOM", userData); glExtGetTexLevelParameterivQCOM = (glExtGetTexLevelParameterivQCOM_client_proc_t) getProc("glExtGetTexLevelParameterivQCOM", userData); glExtTexObjectStateOverrideiQCOM = (glExtTexObjectStateOverrideiQCOM_client_proc_t) getProc("glExtTexObjectStateOverrideiQCOM", userData); glExtGetTexSubImageQCOM = (glExtGetTexSubImageQCOM_client_proc_t) getProc("glExtGetTexSubImageQCOM", userData); glExtGetBufferPointervQCOM = (glExtGetBufferPointervQCOM_client_proc_t) getProc("glExtGetBufferPointervQCOM", userData); glExtGetShadersQCOM = (glExtGetShadersQCOM_client_proc_t) getProc("glExtGetShadersQCOM", userData); glExtGetProgramsQCOM = (glExtGetProgramsQCOM_client_proc_t) getProc("glExtGetProgramsQCOM", userData); glExtIsProgramBinaryQCOM = (glExtIsProgramBinaryQCOM_client_proc_t) getProc("glExtIsProgramBinaryQCOM", userData); glExtGetProgramBinarySourceQCOM = (glExtGetProgramBinarySourceQCOM_client_proc_t) getProc("glExtGetProgramBinarySourceQCOM", userData); glStartTilingQCOM = (glStartTilingQCOM_client_proc_t) getProc("glStartTilingQCOM", userData); glEndTilingQCOM = (glEndTilingQCOM_client_proc_t) getProc("glEndTilingQCOM", userData); glVertexAttribPointerData = (glVertexAttribPointerData_client_proc_t) getProc("glVertexAttribPointerData", userData); glVertexAttribPointerOffset = (glVertexAttribPointerOffset_client_proc_t) getProc("glVertexAttribPointerOffset", userData); glDrawElementsOffset = (glDrawElementsOffset_client_proc_t) getProc("glDrawElementsOffset", userData); glDrawElementsData = (glDrawElementsData_client_proc_t) getProc("glDrawElementsData", userData); glGetCompressedTextureFormats = (glGetCompressedTextureFormats_client_proc_t) getProc("glGetCompressedTextureFormats", userData); glShaderString = (glShaderString_client_proc_t) getProc("glShaderString", userData); glFinishRoundTrip = (glFinishRoundTrip_client_proc_t) getProc("glFinishRoundTrip", userData); return 0; } anbox-0.0~git20191115/android/opengl/system/GLESv2_enc/gl2_client_context.h000066400000000000000000000265531356361734700262560ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef __gl2_client_context_t_h #define __gl2_client_context_t_h #include "gl2_client_proc.h" #include "gl2_types.h" struct gl2_client_context_t { glActiveTexture_client_proc_t glActiveTexture; glAttachShader_client_proc_t glAttachShader; glBindAttribLocation_client_proc_t glBindAttribLocation; glBindBuffer_client_proc_t glBindBuffer; glBindFramebuffer_client_proc_t glBindFramebuffer; glBindRenderbuffer_client_proc_t glBindRenderbuffer; glBindTexture_client_proc_t glBindTexture; glBlendColor_client_proc_t glBlendColor; glBlendEquation_client_proc_t glBlendEquation; glBlendEquationSeparate_client_proc_t glBlendEquationSeparate; glBlendFunc_client_proc_t glBlendFunc; glBlendFuncSeparate_client_proc_t glBlendFuncSeparate; glBufferData_client_proc_t glBufferData; glBufferSubData_client_proc_t glBufferSubData; glCheckFramebufferStatus_client_proc_t glCheckFramebufferStatus; glClear_client_proc_t glClear; glClearColor_client_proc_t glClearColor; glClearDepthf_client_proc_t glClearDepthf; glClearStencil_client_proc_t glClearStencil; glColorMask_client_proc_t glColorMask; glCompileShader_client_proc_t glCompileShader; glCompressedTexImage2D_client_proc_t glCompressedTexImage2D; glCompressedTexSubImage2D_client_proc_t glCompressedTexSubImage2D; glCopyTexImage2D_client_proc_t glCopyTexImage2D; glCopyTexSubImage2D_client_proc_t glCopyTexSubImage2D; glCreateProgram_client_proc_t glCreateProgram; glCreateShader_client_proc_t glCreateShader; glCullFace_client_proc_t glCullFace; glDeleteBuffers_client_proc_t glDeleteBuffers; glDeleteFramebuffers_client_proc_t glDeleteFramebuffers; glDeleteProgram_client_proc_t glDeleteProgram; glDeleteRenderbuffers_client_proc_t glDeleteRenderbuffers; glDeleteShader_client_proc_t glDeleteShader; glDeleteTextures_client_proc_t glDeleteTextures; glDepthFunc_client_proc_t glDepthFunc; glDepthMask_client_proc_t glDepthMask; glDepthRangef_client_proc_t glDepthRangef; glDetachShader_client_proc_t glDetachShader; glDisable_client_proc_t glDisable; glDisableVertexAttribArray_client_proc_t glDisableVertexAttribArray; glDrawArrays_client_proc_t glDrawArrays; glDrawElements_client_proc_t glDrawElements; glEnable_client_proc_t glEnable; glEnableVertexAttribArray_client_proc_t glEnableVertexAttribArray; glFinish_client_proc_t glFinish; glFlush_client_proc_t glFlush; glFramebufferRenderbuffer_client_proc_t glFramebufferRenderbuffer; glFramebufferTexture2D_client_proc_t glFramebufferTexture2D; glFrontFace_client_proc_t glFrontFace; glGenBuffers_client_proc_t glGenBuffers; glGenerateMipmap_client_proc_t glGenerateMipmap; glGenFramebuffers_client_proc_t glGenFramebuffers; glGenRenderbuffers_client_proc_t glGenRenderbuffers; glGenTextures_client_proc_t glGenTextures; glGetActiveAttrib_client_proc_t glGetActiveAttrib; glGetActiveUniform_client_proc_t glGetActiveUniform; glGetAttachedShaders_client_proc_t glGetAttachedShaders; glGetAttribLocation_client_proc_t glGetAttribLocation; glGetBooleanv_client_proc_t glGetBooleanv; glGetBufferParameteriv_client_proc_t glGetBufferParameteriv; glGetError_client_proc_t glGetError; glGetFloatv_client_proc_t glGetFloatv; glGetFramebufferAttachmentParameteriv_client_proc_t glGetFramebufferAttachmentParameteriv; glGetIntegerv_client_proc_t glGetIntegerv; glGetProgramiv_client_proc_t glGetProgramiv; glGetProgramInfoLog_client_proc_t glGetProgramInfoLog; glGetRenderbufferParameteriv_client_proc_t glGetRenderbufferParameteriv; glGetShaderiv_client_proc_t glGetShaderiv; glGetShaderInfoLog_client_proc_t glGetShaderInfoLog; glGetShaderPrecisionFormat_client_proc_t glGetShaderPrecisionFormat; glGetShaderSource_client_proc_t glGetShaderSource; glGetString_client_proc_t glGetString; glGetTexParameterfv_client_proc_t glGetTexParameterfv; glGetTexParameteriv_client_proc_t glGetTexParameteriv; glGetUniformfv_client_proc_t glGetUniformfv; glGetUniformiv_client_proc_t glGetUniformiv; glGetUniformLocation_client_proc_t glGetUniformLocation; glGetVertexAttribfv_client_proc_t glGetVertexAttribfv; glGetVertexAttribiv_client_proc_t glGetVertexAttribiv; glGetVertexAttribPointerv_client_proc_t glGetVertexAttribPointerv; glHint_client_proc_t glHint; glIsBuffer_client_proc_t glIsBuffer; glIsEnabled_client_proc_t glIsEnabled; glIsFramebuffer_client_proc_t glIsFramebuffer; glIsProgram_client_proc_t glIsProgram; glIsRenderbuffer_client_proc_t glIsRenderbuffer; glIsShader_client_proc_t glIsShader; glIsTexture_client_proc_t glIsTexture; glLineWidth_client_proc_t glLineWidth; glLinkProgram_client_proc_t glLinkProgram; glPixelStorei_client_proc_t glPixelStorei; glPolygonOffset_client_proc_t glPolygonOffset; glReadPixels_client_proc_t glReadPixels; glReleaseShaderCompiler_client_proc_t glReleaseShaderCompiler; glRenderbufferStorage_client_proc_t glRenderbufferStorage; glSampleCoverage_client_proc_t glSampleCoverage; glScissor_client_proc_t glScissor; glShaderBinary_client_proc_t glShaderBinary; glShaderSource_client_proc_t glShaderSource; glStencilFunc_client_proc_t glStencilFunc; glStencilFuncSeparate_client_proc_t glStencilFuncSeparate; glStencilMask_client_proc_t glStencilMask; glStencilMaskSeparate_client_proc_t glStencilMaskSeparate; glStencilOp_client_proc_t glStencilOp; glStencilOpSeparate_client_proc_t glStencilOpSeparate; glTexImage2D_client_proc_t glTexImage2D; glTexParameterf_client_proc_t glTexParameterf; glTexParameterfv_client_proc_t glTexParameterfv; glTexParameteri_client_proc_t glTexParameteri; glTexParameteriv_client_proc_t glTexParameteriv; glTexSubImage2D_client_proc_t glTexSubImage2D; glUniform1f_client_proc_t glUniform1f; glUniform1fv_client_proc_t glUniform1fv; glUniform1i_client_proc_t glUniform1i; glUniform1iv_client_proc_t glUniform1iv; glUniform2f_client_proc_t glUniform2f; glUniform2fv_client_proc_t glUniform2fv; glUniform2i_client_proc_t glUniform2i; glUniform2iv_client_proc_t glUniform2iv; glUniform3f_client_proc_t glUniform3f; glUniform3fv_client_proc_t glUniform3fv; glUniform3i_client_proc_t glUniform3i; glUniform3iv_client_proc_t glUniform3iv; glUniform4f_client_proc_t glUniform4f; glUniform4fv_client_proc_t glUniform4fv; glUniform4i_client_proc_t glUniform4i; glUniform4iv_client_proc_t glUniform4iv; glUniformMatrix2fv_client_proc_t glUniformMatrix2fv; glUniformMatrix3fv_client_proc_t glUniformMatrix3fv; glUniformMatrix4fv_client_proc_t glUniformMatrix4fv; glUseProgram_client_proc_t glUseProgram; glValidateProgram_client_proc_t glValidateProgram; glVertexAttrib1f_client_proc_t glVertexAttrib1f; glVertexAttrib1fv_client_proc_t glVertexAttrib1fv; glVertexAttrib2f_client_proc_t glVertexAttrib2f; glVertexAttrib2fv_client_proc_t glVertexAttrib2fv; glVertexAttrib3f_client_proc_t glVertexAttrib3f; glVertexAttrib3fv_client_proc_t glVertexAttrib3fv; glVertexAttrib4f_client_proc_t glVertexAttrib4f; glVertexAttrib4fv_client_proc_t glVertexAttrib4fv; glVertexAttribPointer_client_proc_t glVertexAttribPointer; glViewport_client_proc_t glViewport; glEGLImageTargetTexture2DOES_client_proc_t glEGLImageTargetTexture2DOES; glEGLImageTargetRenderbufferStorageOES_client_proc_t glEGLImageTargetRenderbufferStorageOES; glGetProgramBinaryOES_client_proc_t glGetProgramBinaryOES; glProgramBinaryOES_client_proc_t glProgramBinaryOES; glMapBufferOES_client_proc_t glMapBufferOES; glUnmapBufferOES_client_proc_t glUnmapBufferOES; glTexImage3DOES_client_proc_t glTexImage3DOES; glTexSubImage3DOES_client_proc_t glTexSubImage3DOES; glCopyTexSubImage3DOES_client_proc_t glCopyTexSubImage3DOES; glCompressedTexImage3DOES_client_proc_t glCompressedTexImage3DOES; glCompressedTexSubImage3DOES_client_proc_t glCompressedTexSubImage3DOES; glFramebufferTexture3DOES_client_proc_t glFramebufferTexture3DOES; glBindVertexArrayOES_client_proc_t glBindVertexArrayOES; glDeleteVertexArraysOES_client_proc_t glDeleteVertexArraysOES; glGenVertexArraysOES_client_proc_t glGenVertexArraysOES; glIsVertexArrayOES_client_proc_t glIsVertexArrayOES; glDiscardFramebufferEXT_client_proc_t glDiscardFramebufferEXT; glMultiDrawArraysEXT_client_proc_t glMultiDrawArraysEXT; glMultiDrawElementsEXT_client_proc_t glMultiDrawElementsEXT; glGetPerfMonitorGroupsAMD_client_proc_t glGetPerfMonitorGroupsAMD; glGetPerfMonitorCountersAMD_client_proc_t glGetPerfMonitorCountersAMD; glGetPerfMonitorGroupStringAMD_client_proc_t glGetPerfMonitorGroupStringAMD; glGetPerfMonitorCounterStringAMD_client_proc_t glGetPerfMonitorCounterStringAMD; glGetPerfMonitorCounterInfoAMD_client_proc_t glGetPerfMonitorCounterInfoAMD; glGenPerfMonitorsAMD_client_proc_t glGenPerfMonitorsAMD; glDeletePerfMonitorsAMD_client_proc_t glDeletePerfMonitorsAMD; glSelectPerfMonitorCountersAMD_client_proc_t glSelectPerfMonitorCountersAMD; glBeginPerfMonitorAMD_client_proc_t glBeginPerfMonitorAMD; glEndPerfMonitorAMD_client_proc_t glEndPerfMonitorAMD; glGetPerfMonitorCounterDataAMD_client_proc_t glGetPerfMonitorCounterDataAMD; glRenderbufferStorageMultisampleIMG_client_proc_t glRenderbufferStorageMultisampleIMG; glFramebufferTexture2DMultisampleIMG_client_proc_t glFramebufferTexture2DMultisampleIMG; glDeleteFencesNV_client_proc_t glDeleteFencesNV; glGenFencesNV_client_proc_t glGenFencesNV; glIsFenceNV_client_proc_t glIsFenceNV; glTestFenceNV_client_proc_t glTestFenceNV; glGetFenceivNV_client_proc_t glGetFenceivNV; glFinishFenceNV_client_proc_t glFinishFenceNV; glSetFenceNV_client_proc_t glSetFenceNV; glCoverageMaskNV_client_proc_t glCoverageMaskNV; glCoverageOperationNV_client_proc_t glCoverageOperationNV; glGetDriverControlsQCOM_client_proc_t glGetDriverControlsQCOM; glGetDriverControlStringQCOM_client_proc_t glGetDriverControlStringQCOM; glEnableDriverControlQCOM_client_proc_t glEnableDriverControlQCOM; glDisableDriverControlQCOM_client_proc_t glDisableDriverControlQCOM; glExtGetTexturesQCOM_client_proc_t glExtGetTexturesQCOM; glExtGetBuffersQCOM_client_proc_t glExtGetBuffersQCOM; glExtGetRenderbuffersQCOM_client_proc_t glExtGetRenderbuffersQCOM; glExtGetFramebuffersQCOM_client_proc_t glExtGetFramebuffersQCOM; glExtGetTexLevelParameterivQCOM_client_proc_t glExtGetTexLevelParameterivQCOM; glExtTexObjectStateOverrideiQCOM_client_proc_t glExtTexObjectStateOverrideiQCOM; glExtGetTexSubImageQCOM_client_proc_t glExtGetTexSubImageQCOM; glExtGetBufferPointervQCOM_client_proc_t glExtGetBufferPointervQCOM; glExtGetShadersQCOM_client_proc_t glExtGetShadersQCOM; glExtGetProgramsQCOM_client_proc_t glExtGetProgramsQCOM; glExtIsProgramBinaryQCOM_client_proc_t glExtIsProgramBinaryQCOM; glExtGetProgramBinarySourceQCOM_client_proc_t glExtGetProgramBinarySourceQCOM; glStartTilingQCOM_client_proc_t glStartTilingQCOM; glEndTilingQCOM_client_proc_t glEndTilingQCOM; glVertexAttribPointerData_client_proc_t glVertexAttribPointerData; glVertexAttribPointerOffset_client_proc_t glVertexAttribPointerOffset; glDrawElementsOffset_client_proc_t glDrawElementsOffset; glDrawElementsData_client_proc_t glDrawElementsData; glGetCompressedTextureFormats_client_proc_t glGetCompressedTextureFormats; glShaderString_client_proc_t glShaderString; glFinishRoundTrip_client_proc_t glFinishRoundTrip; virtual ~gl2_client_context_t() {} typedef gl2_client_context_t *CONTEXT_ACCESSOR_TYPE(void); static void setContextAccessor(CONTEXT_ACCESSOR_TYPE *f); int initDispatchByName( void *(*getProc)(const char *name, void *userData), void *userData); virtual void setError(unsigned int error){ (void)error; }; virtual unsigned int getError(){ return 0; }; }; #endif anbox-0.0~git20191115/android/opengl/system/GLESv2_enc/gl2_client_proc.h000066400000000000000000000521761356361734700255350ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef __gl2_client_proc_t_h #define __gl2_client_proc_t_h #include "gl2_types.h" #ifndef gl2_APIENTRY #define gl2_APIENTRY #endif typedef void (gl2_APIENTRY *glActiveTexture_client_proc_t) (void * ctx, GLenum); typedef void (gl2_APIENTRY *glAttachShader_client_proc_t) (void * ctx, GLuint, GLuint); typedef void (gl2_APIENTRY *glBindAttribLocation_client_proc_t) (void * ctx, GLuint, GLuint, const GLchar*); typedef void (gl2_APIENTRY *glBindBuffer_client_proc_t) (void * ctx, GLenum, GLuint); typedef void (gl2_APIENTRY *glBindFramebuffer_client_proc_t) (void * ctx, GLenum, GLuint); typedef void (gl2_APIENTRY *glBindRenderbuffer_client_proc_t) (void * ctx, GLenum, GLuint); typedef void (gl2_APIENTRY *glBindTexture_client_proc_t) (void * ctx, GLenum, GLuint); typedef void (gl2_APIENTRY *glBlendColor_client_proc_t) (void * ctx, GLclampf, GLclampf, GLclampf, GLclampf); typedef void (gl2_APIENTRY *glBlendEquation_client_proc_t) (void * ctx, GLenum); typedef void (gl2_APIENTRY *glBlendEquationSeparate_client_proc_t) (void * ctx, GLenum, GLenum); typedef void (gl2_APIENTRY *glBlendFunc_client_proc_t) (void * ctx, GLenum, GLenum); typedef void (gl2_APIENTRY *glBlendFuncSeparate_client_proc_t) (void * ctx, GLenum, GLenum, GLenum, GLenum); typedef void (gl2_APIENTRY *glBufferData_client_proc_t) (void * ctx, GLenum, GLsizeiptr, const GLvoid*, GLenum); typedef void (gl2_APIENTRY *glBufferSubData_client_proc_t) (void * ctx, GLenum, GLintptr, GLsizeiptr, const GLvoid*); typedef GLenum (gl2_APIENTRY *glCheckFramebufferStatus_client_proc_t) (void * ctx, GLenum); typedef void (gl2_APIENTRY *glClear_client_proc_t) (void * ctx, GLbitfield); typedef void (gl2_APIENTRY *glClearColor_client_proc_t) (void * ctx, GLclampf, GLclampf, GLclampf, GLclampf); typedef void (gl2_APIENTRY *glClearDepthf_client_proc_t) (void * ctx, GLclampf); typedef void (gl2_APIENTRY *glClearStencil_client_proc_t) (void * ctx, GLint); typedef void (gl2_APIENTRY *glColorMask_client_proc_t) (void * ctx, GLboolean, GLboolean, GLboolean, GLboolean); typedef void (gl2_APIENTRY *glCompileShader_client_proc_t) (void * ctx, GLuint); typedef void (gl2_APIENTRY *glCompressedTexImage2D_client_proc_t) (void * ctx, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid*); typedef void (gl2_APIENTRY *glCompressedTexSubImage2D_client_proc_t) (void * ctx, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid*); typedef void (gl2_APIENTRY *glCopyTexImage2D_client_proc_t) (void * ctx, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint); typedef void (gl2_APIENTRY *glCopyTexSubImage2D_client_proc_t) (void * ctx, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei); typedef GLuint (gl2_APIENTRY *glCreateProgram_client_proc_t) (void * ctx); typedef GLuint (gl2_APIENTRY *glCreateShader_client_proc_t) (void * ctx, GLenum); typedef void (gl2_APIENTRY *glCullFace_client_proc_t) (void * ctx, GLenum); typedef void (gl2_APIENTRY *glDeleteBuffers_client_proc_t) (void * ctx, GLsizei, const GLuint*); typedef void (gl2_APIENTRY *glDeleteFramebuffers_client_proc_t) (void * ctx, GLsizei, const GLuint*); typedef void (gl2_APIENTRY *glDeleteProgram_client_proc_t) (void * ctx, GLuint); typedef void (gl2_APIENTRY *glDeleteRenderbuffers_client_proc_t) (void * ctx, GLsizei, const GLuint*); typedef void (gl2_APIENTRY *glDeleteShader_client_proc_t) (void * ctx, GLuint); typedef void (gl2_APIENTRY *glDeleteTextures_client_proc_t) (void * ctx, GLsizei, const GLuint*); typedef void (gl2_APIENTRY *glDepthFunc_client_proc_t) (void * ctx, GLenum); typedef void (gl2_APIENTRY *glDepthMask_client_proc_t) (void * ctx, GLboolean); typedef void (gl2_APIENTRY *glDepthRangef_client_proc_t) (void * ctx, GLclampf, GLclampf); typedef void (gl2_APIENTRY *glDetachShader_client_proc_t) (void * ctx, GLuint, GLuint); typedef void (gl2_APIENTRY *glDisable_client_proc_t) (void * ctx, GLenum); typedef void (gl2_APIENTRY *glDisableVertexAttribArray_client_proc_t) (void * ctx, GLuint); typedef void (gl2_APIENTRY *glDrawArrays_client_proc_t) (void * ctx, GLenum, GLint, GLsizei); typedef void (gl2_APIENTRY *glDrawElements_client_proc_t) (void * ctx, GLenum, GLsizei, GLenum, const GLvoid*); typedef void (gl2_APIENTRY *glEnable_client_proc_t) (void * ctx, GLenum); typedef void (gl2_APIENTRY *glEnableVertexAttribArray_client_proc_t) (void * ctx, GLuint); typedef void (gl2_APIENTRY *glFinish_client_proc_t) (void * ctx); typedef void (gl2_APIENTRY *glFlush_client_proc_t) (void * ctx); typedef void (gl2_APIENTRY *glFramebufferRenderbuffer_client_proc_t) (void * ctx, GLenum, GLenum, GLenum, GLuint); typedef void (gl2_APIENTRY *glFramebufferTexture2D_client_proc_t) (void * ctx, GLenum, GLenum, GLenum, GLuint, GLint); typedef void (gl2_APIENTRY *glFrontFace_client_proc_t) (void * ctx, GLenum); typedef void (gl2_APIENTRY *glGenBuffers_client_proc_t) (void * ctx, GLsizei, GLuint*); typedef void (gl2_APIENTRY *glGenerateMipmap_client_proc_t) (void * ctx, GLenum); typedef void (gl2_APIENTRY *glGenFramebuffers_client_proc_t) (void * ctx, GLsizei, GLuint*); typedef void (gl2_APIENTRY *glGenRenderbuffers_client_proc_t) (void * ctx, GLsizei, GLuint*); typedef void (gl2_APIENTRY *glGenTextures_client_proc_t) (void * ctx, GLsizei, GLuint*); typedef void (gl2_APIENTRY *glGetActiveAttrib_client_proc_t) (void * ctx, GLuint, GLuint, GLsizei, GLsizei*, GLint*, GLenum*, GLchar*); typedef void (gl2_APIENTRY *glGetActiveUniform_client_proc_t) (void * ctx, GLuint, GLuint, GLsizei, GLsizei*, GLint*, GLenum*, GLchar*); typedef void (gl2_APIENTRY *glGetAttachedShaders_client_proc_t) (void * ctx, GLuint, GLsizei, GLsizei*, GLuint*); typedef int (gl2_APIENTRY *glGetAttribLocation_client_proc_t) (void * ctx, GLuint, const GLchar*); typedef void (gl2_APIENTRY *glGetBooleanv_client_proc_t) (void * ctx, GLenum, GLboolean*); typedef void (gl2_APIENTRY *glGetBufferParameteriv_client_proc_t) (void * ctx, GLenum, GLenum, GLint*); typedef GLenum (gl2_APIENTRY *glGetError_client_proc_t) (void * ctx); typedef void (gl2_APIENTRY *glGetFloatv_client_proc_t) (void * ctx, GLenum, GLfloat*); typedef void (gl2_APIENTRY *glGetFramebufferAttachmentParameteriv_client_proc_t) (void * ctx, GLenum, GLenum, GLenum, GLint*); typedef void (gl2_APIENTRY *glGetIntegerv_client_proc_t) (void * ctx, GLenum, GLint*); typedef void (gl2_APIENTRY *glGetProgramiv_client_proc_t) (void * ctx, GLuint, GLenum, GLint*); typedef void (gl2_APIENTRY *glGetProgramInfoLog_client_proc_t) (void * ctx, GLuint, GLsizei, GLsizei*, GLchar*); typedef void (gl2_APIENTRY *glGetRenderbufferParameteriv_client_proc_t) (void * ctx, GLenum, GLenum, GLint*); typedef void (gl2_APIENTRY *glGetShaderiv_client_proc_t) (void * ctx, GLuint, GLenum, GLint*); typedef void (gl2_APIENTRY *glGetShaderInfoLog_client_proc_t) (void * ctx, GLuint, GLsizei, GLsizei*, GLchar*); typedef void (gl2_APIENTRY *glGetShaderPrecisionFormat_client_proc_t) (void * ctx, GLenum, GLenum, GLint*, GLint*); typedef void (gl2_APIENTRY *glGetShaderSource_client_proc_t) (void * ctx, GLuint, GLsizei, GLsizei*, GLchar*); typedef const GLubyte* (gl2_APIENTRY *glGetString_client_proc_t) (void * ctx, GLenum); typedef void (gl2_APIENTRY *glGetTexParameterfv_client_proc_t) (void * ctx, GLenum, GLenum, GLfloat*); typedef void (gl2_APIENTRY *glGetTexParameteriv_client_proc_t) (void * ctx, GLenum, GLenum, GLint*); typedef void (gl2_APIENTRY *glGetUniformfv_client_proc_t) (void * ctx, GLuint, GLint, GLfloat*); typedef void (gl2_APIENTRY *glGetUniformiv_client_proc_t) (void * ctx, GLuint, GLint, GLint*); typedef int (gl2_APIENTRY *glGetUniformLocation_client_proc_t) (void * ctx, GLuint, const GLchar*); typedef void (gl2_APIENTRY *glGetVertexAttribfv_client_proc_t) (void * ctx, GLuint, GLenum, GLfloat*); typedef void (gl2_APIENTRY *glGetVertexAttribiv_client_proc_t) (void * ctx, GLuint, GLenum, GLint*); typedef void (gl2_APIENTRY *glGetVertexAttribPointerv_client_proc_t) (void * ctx, GLuint, GLenum, GLvoid**); typedef void (gl2_APIENTRY *glHint_client_proc_t) (void * ctx, GLenum, GLenum); typedef GLboolean (gl2_APIENTRY *glIsBuffer_client_proc_t) (void * ctx, GLuint); typedef GLboolean (gl2_APIENTRY *glIsEnabled_client_proc_t) (void * ctx, GLenum); typedef GLboolean (gl2_APIENTRY *glIsFramebuffer_client_proc_t) (void * ctx, GLuint); typedef GLboolean (gl2_APIENTRY *glIsProgram_client_proc_t) (void * ctx, GLuint); typedef GLboolean (gl2_APIENTRY *glIsRenderbuffer_client_proc_t) (void * ctx, GLuint); typedef GLboolean (gl2_APIENTRY *glIsShader_client_proc_t) (void * ctx, GLuint); typedef GLboolean (gl2_APIENTRY *glIsTexture_client_proc_t) (void * ctx, GLuint); typedef void (gl2_APIENTRY *glLineWidth_client_proc_t) (void * ctx, GLfloat); typedef void (gl2_APIENTRY *glLinkProgram_client_proc_t) (void * ctx, GLuint); typedef void (gl2_APIENTRY *glPixelStorei_client_proc_t) (void * ctx, GLenum, GLint); typedef void (gl2_APIENTRY *glPolygonOffset_client_proc_t) (void * ctx, GLfloat, GLfloat); typedef void (gl2_APIENTRY *glReadPixels_client_proc_t) (void * ctx, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid*); typedef void (gl2_APIENTRY *glReleaseShaderCompiler_client_proc_t) (void * ctx); typedef void (gl2_APIENTRY *glRenderbufferStorage_client_proc_t) (void * ctx, GLenum, GLenum, GLsizei, GLsizei); typedef void (gl2_APIENTRY *glSampleCoverage_client_proc_t) (void * ctx, GLclampf, GLboolean); typedef void (gl2_APIENTRY *glScissor_client_proc_t) (void * ctx, GLint, GLint, GLsizei, GLsizei); typedef void (gl2_APIENTRY *glShaderBinary_client_proc_t) (void * ctx, GLsizei, const GLuint*, GLenum, const GLvoid*, GLsizei); typedef void (gl2_APIENTRY *glShaderSource_client_proc_t) (void * ctx, GLuint, GLsizei, const GLchar* const*, const GLint*); typedef void (gl2_APIENTRY *glStencilFunc_client_proc_t) (void * ctx, GLenum, GLint, GLuint); typedef void (gl2_APIENTRY *glStencilFuncSeparate_client_proc_t) (void * ctx, GLenum, GLenum, GLint, GLuint); typedef void (gl2_APIENTRY *glStencilMask_client_proc_t) (void * ctx, GLuint); typedef void (gl2_APIENTRY *glStencilMaskSeparate_client_proc_t) (void * ctx, GLenum, GLuint); typedef void (gl2_APIENTRY *glStencilOp_client_proc_t) (void * ctx, GLenum, GLenum, GLenum); typedef void (gl2_APIENTRY *glStencilOpSeparate_client_proc_t) (void * ctx, GLenum, GLenum, GLenum, GLenum); typedef void (gl2_APIENTRY *glTexImage2D_client_proc_t) (void * ctx, GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid*); typedef void (gl2_APIENTRY *glTexParameterf_client_proc_t) (void * ctx, GLenum, GLenum, GLfloat); typedef void (gl2_APIENTRY *glTexParameterfv_client_proc_t) (void * ctx, GLenum, GLenum, const GLfloat*); typedef void (gl2_APIENTRY *glTexParameteri_client_proc_t) (void * ctx, GLenum, GLenum, GLint); typedef void (gl2_APIENTRY *glTexParameteriv_client_proc_t) (void * ctx, GLenum, GLenum, const GLint*); typedef void (gl2_APIENTRY *glTexSubImage2D_client_proc_t) (void * ctx, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid*); typedef void (gl2_APIENTRY *glUniform1f_client_proc_t) (void * ctx, GLint, GLfloat); typedef void (gl2_APIENTRY *glUniform1fv_client_proc_t) (void * ctx, GLint, GLsizei, const GLfloat*); typedef void (gl2_APIENTRY *glUniform1i_client_proc_t) (void * ctx, GLint, GLint); typedef void (gl2_APIENTRY *glUniform1iv_client_proc_t) (void * ctx, GLint, GLsizei, const GLint*); typedef void (gl2_APIENTRY *glUniform2f_client_proc_t) (void * ctx, GLint, GLfloat, GLfloat); typedef void (gl2_APIENTRY *glUniform2fv_client_proc_t) (void * ctx, GLint, GLsizei, const GLfloat*); typedef void (gl2_APIENTRY *glUniform2i_client_proc_t) (void * ctx, GLint, GLint, GLint); typedef void (gl2_APIENTRY *glUniform2iv_client_proc_t) (void * ctx, GLint, GLsizei, const GLint*); typedef void (gl2_APIENTRY *glUniform3f_client_proc_t) (void * ctx, GLint, GLfloat, GLfloat, GLfloat); typedef void (gl2_APIENTRY *glUniform3fv_client_proc_t) (void * ctx, GLint, GLsizei, const GLfloat*); typedef void (gl2_APIENTRY *glUniform3i_client_proc_t) (void * ctx, GLint, GLint, GLint, GLint); typedef void (gl2_APIENTRY *glUniform3iv_client_proc_t) (void * ctx, GLint, GLsizei, const GLint*); typedef void (gl2_APIENTRY *glUniform4f_client_proc_t) (void * ctx, GLint, GLfloat, GLfloat, GLfloat, GLfloat); typedef void (gl2_APIENTRY *glUniform4fv_client_proc_t) (void * ctx, GLint, GLsizei, const GLfloat*); typedef void (gl2_APIENTRY *glUniform4i_client_proc_t) (void * ctx, GLint, GLint, GLint, GLint, GLint); typedef void (gl2_APIENTRY *glUniform4iv_client_proc_t) (void * ctx, GLint, GLsizei, const GLint*); typedef void (gl2_APIENTRY *glUniformMatrix2fv_client_proc_t) (void * ctx, GLint, GLsizei, GLboolean, const GLfloat*); typedef void (gl2_APIENTRY *glUniformMatrix3fv_client_proc_t) (void * ctx, GLint, GLsizei, GLboolean, const GLfloat*); typedef void (gl2_APIENTRY *glUniformMatrix4fv_client_proc_t) (void * ctx, GLint, GLsizei, GLboolean, const GLfloat*); typedef void (gl2_APIENTRY *glUseProgram_client_proc_t) (void * ctx, GLuint); typedef void (gl2_APIENTRY *glValidateProgram_client_proc_t) (void * ctx, GLuint); typedef void (gl2_APIENTRY *glVertexAttrib1f_client_proc_t) (void * ctx, GLuint, GLfloat); typedef void (gl2_APIENTRY *glVertexAttrib1fv_client_proc_t) (void * ctx, GLuint, const GLfloat*); typedef void (gl2_APIENTRY *glVertexAttrib2f_client_proc_t) (void * ctx, GLuint, GLfloat, GLfloat); typedef void (gl2_APIENTRY *glVertexAttrib2fv_client_proc_t) (void * ctx, GLuint, const GLfloat*); typedef void (gl2_APIENTRY *glVertexAttrib3f_client_proc_t) (void * ctx, GLuint, GLfloat, GLfloat, GLfloat); typedef void (gl2_APIENTRY *glVertexAttrib3fv_client_proc_t) (void * ctx, GLuint, const GLfloat*); typedef void (gl2_APIENTRY *glVertexAttrib4f_client_proc_t) (void * ctx, GLuint, GLfloat, GLfloat, GLfloat, GLfloat); typedef void (gl2_APIENTRY *glVertexAttrib4fv_client_proc_t) (void * ctx, GLuint, const GLfloat*); typedef void (gl2_APIENTRY *glVertexAttribPointer_client_proc_t) (void * ctx, GLuint, GLint, GLenum, GLboolean, GLsizei, const GLvoid*); typedef void (gl2_APIENTRY *glViewport_client_proc_t) (void * ctx, GLint, GLint, GLsizei, GLsizei); typedef void (gl2_APIENTRY *glEGLImageTargetTexture2DOES_client_proc_t) (void * ctx, GLenum, GLeglImageOES); typedef void (gl2_APIENTRY *glEGLImageTargetRenderbufferStorageOES_client_proc_t) (void * ctx, GLenum, GLeglImageOES); typedef void (gl2_APIENTRY *glGetProgramBinaryOES_client_proc_t) (void * ctx, GLuint, GLsizei, GLsizei*, GLenum*, GLvoid*); typedef void (gl2_APIENTRY *glProgramBinaryOES_client_proc_t) (void * ctx, GLuint, GLenum, const GLvoid*, GLint); typedef void* (gl2_APIENTRY *glMapBufferOES_client_proc_t) (void * ctx, GLenum, GLenum); typedef GLboolean (gl2_APIENTRY *glUnmapBufferOES_client_proc_t) (void * ctx, GLenum); typedef void (gl2_APIENTRY *glTexImage3DOES_client_proc_t) (void * ctx, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid*); typedef void (gl2_APIENTRY *glTexSubImage3DOES_client_proc_t) (void * ctx, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid*); typedef void (gl2_APIENTRY *glCopyTexSubImage3DOES_client_proc_t) (void * ctx, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei); typedef void (gl2_APIENTRY *glCompressedTexImage3DOES_client_proc_t) (void * ctx, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid*); typedef void (gl2_APIENTRY *glCompressedTexSubImage3DOES_client_proc_t) (void * ctx, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid*); typedef void (gl2_APIENTRY *glFramebufferTexture3DOES_client_proc_t) (void * ctx, GLenum, GLenum, GLenum, GLuint, GLint, GLint); typedef void (gl2_APIENTRY *glBindVertexArrayOES_client_proc_t) (void * ctx, GLuint); typedef void (gl2_APIENTRY *glDeleteVertexArraysOES_client_proc_t) (void * ctx, GLsizei, const GLuint*); typedef void (gl2_APIENTRY *glGenVertexArraysOES_client_proc_t) (void * ctx, GLsizei, GLuint*); typedef GLboolean (gl2_APIENTRY *glIsVertexArrayOES_client_proc_t) (void * ctx, GLuint); typedef void (gl2_APIENTRY *glDiscardFramebufferEXT_client_proc_t) (void * ctx, GLenum, GLsizei, const GLenum*); typedef void (gl2_APIENTRY *glMultiDrawArraysEXT_client_proc_t) (void * ctx, GLenum, const GLint*, const GLsizei*, GLsizei); typedef void (gl2_APIENTRY *glMultiDrawElementsEXT_client_proc_t) (void * ctx, GLenum, const GLsizei*, GLenum, const GLvoid* const*, GLsizei); typedef void (gl2_APIENTRY *glGetPerfMonitorGroupsAMD_client_proc_t) (void * ctx, GLint*, GLsizei, GLuint*); typedef void (gl2_APIENTRY *glGetPerfMonitorCountersAMD_client_proc_t) (void * ctx, GLuint, GLint*, GLint*, GLsizei, GLuint*); typedef void (gl2_APIENTRY *glGetPerfMonitorGroupStringAMD_client_proc_t) (void * ctx, GLuint, GLsizei, GLsizei*, GLchar*); typedef void (gl2_APIENTRY *glGetPerfMonitorCounterStringAMD_client_proc_t) (void * ctx, GLuint, GLuint, GLsizei, GLsizei*, GLchar*); typedef void (gl2_APIENTRY *glGetPerfMonitorCounterInfoAMD_client_proc_t) (void * ctx, GLuint, GLuint, GLenum, GLvoid*); typedef void (gl2_APIENTRY *glGenPerfMonitorsAMD_client_proc_t) (void * ctx, GLsizei, GLuint*); typedef void (gl2_APIENTRY *glDeletePerfMonitorsAMD_client_proc_t) (void * ctx, GLsizei, GLuint*); typedef void (gl2_APIENTRY *glSelectPerfMonitorCountersAMD_client_proc_t) (void * ctx, GLuint, GLboolean, GLuint, GLint, GLuint*); typedef void (gl2_APIENTRY *glBeginPerfMonitorAMD_client_proc_t) (void * ctx, GLuint); typedef void (gl2_APIENTRY *glEndPerfMonitorAMD_client_proc_t) (void * ctx, GLuint); typedef void (gl2_APIENTRY *glGetPerfMonitorCounterDataAMD_client_proc_t) (void * ctx, GLuint, GLenum, GLsizei, GLuint*, GLint*); typedef void (gl2_APIENTRY *glRenderbufferStorageMultisampleIMG_client_proc_t) (void * ctx, GLenum, GLsizei, GLenum, GLsizei, GLsizei); typedef void (gl2_APIENTRY *glFramebufferTexture2DMultisampleIMG_client_proc_t) (void * ctx, GLenum, GLenum, GLenum, GLuint, GLint, GLsizei); typedef void (gl2_APIENTRY *glDeleteFencesNV_client_proc_t) (void * ctx, GLsizei, const GLuint*); typedef void (gl2_APIENTRY *glGenFencesNV_client_proc_t) (void * ctx, GLsizei, GLuint*); typedef GLboolean (gl2_APIENTRY *glIsFenceNV_client_proc_t) (void * ctx, GLuint); typedef GLboolean (gl2_APIENTRY *glTestFenceNV_client_proc_t) (void * ctx, GLuint); typedef void (gl2_APIENTRY *glGetFenceivNV_client_proc_t) (void * ctx, GLuint, GLenum, GLint*); typedef void (gl2_APIENTRY *glFinishFenceNV_client_proc_t) (void * ctx, GLuint); typedef void (gl2_APIENTRY *glSetFenceNV_client_proc_t) (void * ctx, GLuint, GLenum); typedef void (gl2_APIENTRY *glCoverageMaskNV_client_proc_t) (void * ctx, GLboolean); typedef void (gl2_APIENTRY *glCoverageOperationNV_client_proc_t) (void * ctx, GLenum); typedef void (gl2_APIENTRY *glGetDriverControlsQCOM_client_proc_t) (void * ctx, GLint*, GLsizei, GLuint*); typedef void (gl2_APIENTRY *glGetDriverControlStringQCOM_client_proc_t) (void * ctx, GLuint, GLsizei, GLsizei*, GLchar*); typedef void (gl2_APIENTRY *glEnableDriverControlQCOM_client_proc_t) (void * ctx, GLuint); typedef void (gl2_APIENTRY *glDisableDriverControlQCOM_client_proc_t) (void * ctx, GLuint); typedef void (gl2_APIENTRY *glExtGetTexturesQCOM_client_proc_t) (void * ctx, GLuint*, GLint, GLint*); typedef void (gl2_APIENTRY *glExtGetBuffersQCOM_client_proc_t) (void * ctx, GLuint*, GLint, GLint*); typedef void (gl2_APIENTRY *glExtGetRenderbuffersQCOM_client_proc_t) (void * ctx, GLuint*, GLint, GLint*); typedef void (gl2_APIENTRY *glExtGetFramebuffersQCOM_client_proc_t) (void * ctx, GLuint*, GLint, GLint*); typedef void (gl2_APIENTRY *glExtGetTexLevelParameterivQCOM_client_proc_t) (void * ctx, GLuint, GLenum, GLint, GLenum, GLint*); typedef void (gl2_APIENTRY *glExtTexObjectStateOverrideiQCOM_client_proc_t) (void * ctx, GLenum, GLenum, GLint); typedef void (gl2_APIENTRY *glExtGetTexSubImageQCOM_client_proc_t) (void * ctx, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLvoid*); typedef void (gl2_APIENTRY *glExtGetBufferPointervQCOM_client_proc_t) (void * ctx, GLenum, GLvoidptr*); typedef void (gl2_APIENTRY *glExtGetShadersQCOM_client_proc_t) (void * ctx, GLuint*, GLint, GLint*); typedef void (gl2_APIENTRY *glExtGetProgramsQCOM_client_proc_t) (void * ctx, GLuint*, GLint, GLint*); typedef GLboolean (gl2_APIENTRY *glExtIsProgramBinaryQCOM_client_proc_t) (void * ctx, GLuint); typedef void (gl2_APIENTRY *glExtGetProgramBinarySourceQCOM_client_proc_t) (void * ctx, GLuint, GLenum, GLchar*, GLint*); typedef void (gl2_APIENTRY *glStartTilingQCOM_client_proc_t) (void * ctx, GLuint, GLuint, GLuint, GLuint, GLbitfield); typedef void (gl2_APIENTRY *glEndTilingQCOM_client_proc_t) (void * ctx, GLbitfield); typedef void (gl2_APIENTRY *glVertexAttribPointerData_client_proc_t) (void * ctx, GLuint, GLint, GLenum, GLboolean, GLsizei, void*, GLuint); typedef void (gl2_APIENTRY *glVertexAttribPointerOffset_client_proc_t) (void * ctx, GLuint, GLint, GLenum, GLboolean, GLsizei, GLuint); typedef void (gl2_APIENTRY *glDrawElementsOffset_client_proc_t) (void * ctx, GLenum, GLsizei, GLenum, GLuint); typedef void (gl2_APIENTRY *glDrawElementsData_client_proc_t) (void * ctx, GLenum, GLsizei, GLenum, void*, GLuint); typedef void (gl2_APIENTRY *glGetCompressedTextureFormats_client_proc_t) (void * ctx, int, GLint*); typedef void (gl2_APIENTRY *glShaderString_client_proc_t) (void * ctx, GLuint, const GLchar*, GLsizei); typedef int (gl2_APIENTRY *glFinishRoundTrip_client_proc_t) (void * ctx); #endif anbox-0.0~git20191115/android/opengl/system/GLESv2_enc/gl2_enc.cpp000066400000000000000000006020201356361734700243210ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #include #include #include "gl2_opcodes.h" #include "gl2_enc.h" #include namespace { void enc_unsupported() { ALOGE("Function is unsupported\n"); } void glActiveTexture_enc(void *self , GLenum texture) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glActiveTexture;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &texture, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glAttachShader_enc(void *self , GLuint program, GLuint shader) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glAttachShader;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &program, 4); ptr += 4; memcpy(ptr, &shader, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glBindAttribLocation_enc(void *self , GLuint program, GLuint index, const GLchar* name) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_name = (strlen(name) + 1); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_name + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glBindAttribLocation;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &program, 4); ptr += 4; memcpy(ptr, &index, 4); ptr += 4; *(unsigned int *)(ptr) = __size_name; ptr += 4; memcpy(ptr, name, __size_name);ptr += __size_name; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glBindBuffer_enc(void *self , GLenum target, GLuint buffer) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glBindBuffer;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &buffer, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glBindFramebuffer_enc(void *self , GLenum target, GLuint framebuffer) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glBindFramebuffer;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &framebuffer, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glBindRenderbuffer_enc(void *self , GLenum target, GLuint renderbuffer) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glBindRenderbuffer;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &renderbuffer, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glBindTexture_enc(void *self , GLenum target, GLuint texture) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glBindTexture;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &texture, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glBlendColor_enc(void *self , GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glBlendColor;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &red, 4); ptr += 4; memcpy(ptr, &green, 4); ptr += 4; memcpy(ptr, &blue, 4); ptr += 4; memcpy(ptr, &alpha, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glBlendEquation_enc(void *self , GLenum mode) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glBlendEquation;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &mode, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glBlendEquationSeparate_enc(void *self , GLenum modeRGB, GLenum modeAlpha) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glBlendEquationSeparate;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &modeRGB, 4); ptr += 4; memcpy(ptr, &modeAlpha, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glBlendFunc_enc(void *self , GLenum sfactor, GLenum dfactor) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glBlendFunc;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &sfactor, 4); ptr += 4; memcpy(ptr, &dfactor, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glBlendFuncSeparate_enc(void *self , GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glBlendFuncSeparate;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &srcRGB, 4); ptr += 4; memcpy(ptr, &dstRGB, 4); ptr += 4; memcpy(ptr, &srcAlpha, 4); ptr += 4; memcpy(ptr, &dstAlpha, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glBufferData_enc(void *self , GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_data = ((data != NULL) ? size : 0); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_data + 4 + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(8 + 4 + 4); ptr = buf; int tmp = OP_glBufferData;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &size, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); stream->flush(); stream->writeFully(&__size_data,4); if (useChecksum) checksumCalculator->addBuffer(&__size_data,4); if (data != NULL) { stream->writeFully(data, __size_data); if (useChecksum) checksumCalculator->addBuffer(data, __size_data); } buf = stream->alloc(4); ptr = buf; memcpy(ptr, &usage, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); buf = stream->alloc(checksumSize); if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize); } void glBufferSubData_enc(void *self , GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_data = ((data != NULL) ? size : 0); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_data + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(8 + 4 + 4 + 4); ptr = buf; int tmp = OP_glBufferSubData;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &offset, 4); ptr += 4; memcpy(ptr, &size, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); stream->flush(); stream->writeFully(&__size_data,4); if (useChecksum) checksumCalculator->addBuffer(&__size_data,4); if (data != NULL) { stream->writeFully(data, __size_data); if (useChecksum) checksumCalculator->addBuffer(data, __size_data); } buf = stream->alloc(checksumSize); if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize); } GLenum glCheckFramebufferStatus_enc(void *self , GLenum target) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glCheckFramebufferStatus;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLenum retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glCheckFramebufferStatus: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void glClear_enc(void *self , GLbitfield mask) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glClear;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &mask, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glClearColor_enc(void *self , GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glClearColor;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &red, 4); ptr += 4; memcpy(ptr, &green, 4); ptr += 4; memcpy(ptr, &blue, 4); ptr += 4; memcpy(ptr, &alpha, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glClearDepthf_enc(void *self , GLclampf depth) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glClearDepthf;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &depth, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glClearStencil_enc(void *self , GLint s) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glClearStencil;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &s, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glColorMask_enc(void *self , GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 1 + 1 + 1 + 1; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glColorMask;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &red, 1); ptr += 1; memcpy(ptr, &green, 1); ptr += 1; memcpy(ptr, &blue, 1); ptr += 1; memcpy(ptr, &alpha, 1); ptr += 1; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glCompileShader_enc(void *self , GLuint shader) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glCompileShader;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &shader, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glCompressedTexImage2D_enc(void *self , GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_data = ((data != NULL) ? imageSize : 0); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_data + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4); ptr = buf; int tmp = OP_glCompressedTexImage2D;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; memcpy(ptr, &internalformat, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; memcpy(ptr, &border, 4); ptr += 4; memcpy(ptr, &imageSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); stream->flush(); stream->writeFully(&__size_data,4); if (useChecksum) checksumCalculator->addBuffer(&__size_data,4); if (data != NULL) { stream->writeFully(data, __size_data); if (useChecksum) checksumCalculator->addBuffer(data, __size_data); } buf = stream->alloc(checksumSize); if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize); } void glCompressedTexSubImage2D_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_data = ((data != NULL) ? imageSize : 0); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_data + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4); ptr = buf; int tmp = OP_glCompressedTexSubImage2D;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; memcpy(ptr, &xoffset, 4); ptr += 4; memcpy(ptr, &yoffset, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; memcpy(ptr, &format, 4); ptr += 4; memcpy(ptr, &imageSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); stream->flush(); stream->writeFully(&__size_data,4); if (useChecksum) checksumCalculator->addBuffer(&__size_data,4); if (data != NULL) { stream->writeFully(data, __size_data); if (useChecksum) checksumCalculator->addBuffer(data, __size_data); } buf = stream->alloc(checksumSize); if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize); } void glCopyTexImage2D_enc(void *self , GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glCopyTexImage2D;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; memcpy(ptr, &internalformat, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; memcpy(ptr, &border, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glCopyTexSubImage2D_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glCopyTexSubImage2D;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; memcpy(ptr, &xoffset, 4); ptr += 4; memcpy(ptr, &yoffset, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } GLuint glCreateProgram_enc(void *self ) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glCreateProgram;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLuint retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glCreateProgram: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } GLuint glCreateShader_enc(void *self , GLenum type) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glCreateShader;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLuint retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glCreateShader: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void glCullFace_enc(void *self , GLenum mode) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glCullFace;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &mode, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDeleteBuffers_enc(void *self , GLsizei n, const GLuint* buffers) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_buffers = (n * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_buffers + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDeleteBuffers;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &n, 4); ptr += 4; *(unsigned int *)(ptr) = __size_buffers; ptr += 4; memcpy(ptr, buffers, __size_buffers);ptr += __size_buffers; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDeleteFramebuffers_enc(void *self , GLsizei n, const GLuint* framebuffers) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_framebuffers = (n * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_framebuffers + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDeleteFramebuffers;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &n, 4); ptr += 4; *(unsigned int *)(ptr) = __size_framebuffers; ptr += 4; memcpy(ptr, framebuffers, __size_framebuffers);ptr += __size_framebuffers; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDeleteProgram_enc(void *self , GLuint program) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDeleteProgram;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &program, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDeleteRenderbuffers_enc(void *self , GLsizei n, const GLuint* renderbuffers) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_renderbuffers = (n * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_renderbuffers + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDeleteRenderbuffers;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &n, 4); ptr += 4; *(unsigned int *)(ptr) = __size_renderbuffers; ptr += 4; memcpy(ptr, renderbuffers, __size_renderbuffers);ptr += __size_renderbuffers; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDeleteShader_enc(void *self , GLuint shader) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDeleteShader;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &shader, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDeleteTextures_enc(void *self , GLsizei n, const GLuint* textures) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_textures = (n * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_textures + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDeleteTextures;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &n, 4); ptr += 4; *(unsigned int *)(ptr) = __size_textures; ptr += 4; memcpy(ptr, textures, __size_textures);ptr += __size_textures; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDepthFunc_enc(void *self , GLenum func) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDepthFunc;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &func, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDepthMask_enc(void *self , GLboolean flag) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 1; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDepthMask;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &flag, 1); ptr += 1; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDepthRangef_enc(void *self , GLclampf zNear, GLclampf zFar) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDepthRangef;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &zNear, 4); ptr += 4; memcpy(ptr, &zFar, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDetachShader_enc(void *self , GLuint program, GLuint shader) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDetachShader;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &program, 4); ptr += 4; memcpy(ptr, &shader, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDisable_enc(void *self , GLenum cap) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDisable;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &cap, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDisableVertexAttribArray_enc(void *self , GLuint index) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDisableVertexAttribArray;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &index, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDrawArrays_enc(void *self , GLenum mode, GLint first, GLsizei count) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDrawArrays;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &mode, 4); ptr += 4; memcpy(ptr, &first, 4); ptr += 4; memcpy(ptr, &count, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glEnable_enc(void *self , GLenum cap) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glEnable;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &cap, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glEnableVertexAttribArray_enc(void *self , GLuint index) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glEnableVertexAttribArray;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &index, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glFinish_enc(void *self ) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFinish;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glFlush_enc(void *self ) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFlush;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glFramebufferRenderbuffer_enc(void *self , GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFramebufferRenderbuffer;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &attachment, 4); ptr += 4; memcpy(ptr, &renderbuffertarget, 4); ptr += 4; memcpy(ptr, &renderbuffer, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glFramebufferTexture2D_enc(void *self , GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFramebufferTexture2D;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &attachment, 4); ptr += 4; memcpy(ptr, &textarget, 4); ptr += 4; memcpy(ptr, &texture, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glFrontFace_enc(void *self , GLenum mode) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFrontFace;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &mode, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glGenBuffers_enc(void *self , GLsizei n, GLuint* buffers) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_buffers = (n * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_buffers + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGenBuffers;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &n, 4); ptr += 4; *(unsigned int *)(ptr) = __size_buffers; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(buffers, __size_buffers); if (useChecksum) checksumCalculator->addBuffer(buffers, __size_buffers); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGenBuffers: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGenerateMipmap_enc(void *self , GLenum target) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGenerateMipmap;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glGenFramebuffers_enc(void *self , GLsizei n, GLuint* framebuffers) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_framebuffers = (n * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_framebuffers + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGenFramebuffers;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &n, 4); ptr += 4; *(unsigned int *)(ptr) = __size_framebuffers; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(framebuffers, __size_framebuffers); if (useChecksum) checksumCalculator->addBuffer(framebuffers, __size_framebuffers); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGenFramebuffers: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGenRenderbuffers_enc(void *self , GLsizei n, GLuint* renderbuffers) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_renderbuffers = (n * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_renderbuffers + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGenRenderbuffers;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &n, 4); ptr += 4; *(unsigned int *)(ptr) = __size_renderbuffers; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(renderbuffers, __size_renderbuffers); if (useChecksum) checksumCalculator->addBuffer(renderbuffers, __size_renderbuffers); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGenRenderbuffers: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGenTextures_enc(void *self , GLsizei n, GLuint* textures) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_textures = (n * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_textures + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGenTextures;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &n, 4); ptr += 4; *(unsigned int *)(ptr) = __size_textures; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(textures, __size_textures); if (useChecksum) checksumCalculator->addBuffer(textures, __size_textures); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGenTextures: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetActiveAttrib_enc(void *self , GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_length = ((length != NULL) ? (sizeof(GLsizei)) : 0); const unsigned int __size_size = ((size != NULL) ? (sizeof(GLint)) : 0); const unsigned int __size_type = ((type != NULL) ? (sizeof(GLenum)) : 0); const unsigned int __size_name = ((name != NULL) ? bufsize : 0); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_length + __size_size + __size_type + __size_name + 4*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetActiveAttrib;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &program, 4); ptr += 4; memcpy(ptr, &index, 4); ptr += 4; memcpy(ptr, &bufsize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_length; ptr += 4; *(unsigned int *)(ptr) = __size_size; ptr += 4; *(unsigned int *)(ptr) = __size_type; ptr += 4; *(unsigned int *)(ptr) = __size_name; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; if (length != NULL) { stream->readback(length, __size_length); if (useChecksum) checksumCalculator->addBuffer(length, __size_length); } if (size != NULL) { stream->readback(size, __size_size); if (useChecksum) checksumCalculator->addBuffer(size, __size_size); } if (type != NULL) { stream->readback(type, __size_type); if (useChecksum) checksumCalculator->addBuffer(type, __size_type); } if (name != NULL) { stream->readback(name, __size_name); if (useChecksum) checksumCalculator->addBuffer(name, __size_name); } if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetActiveAttrib: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetActiveUniform_enc(void *self , GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_length = ((length != NULL) ? (sizeof(GLsizei)) : 0); const unsigned int __size_size = ((size != NULL) ? (sizeof(GLint)) : 0); const unsigned int __size_type = ((type != NULL) ? (sizeof(GLenum)) : 0); const unsigned int __size_name = ((name != NULL) ? bufsize : 0); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_length + __size_size + __size_type + __size_name + 4*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetActiveUniform;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &program, 4); ptr += 4; memcpy(ptr, &index, 4); ptr += 4; memcpy(ptr, &bufsize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_length; ptr += 4; *(unsigned int *)(ptr) = __size_size; ptr += 4; *(unsigned int *)(ptr) = __size_type; ptr += 4; *(unsigned int *)(ptr) = __size_name; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; if (length != NULL) { stream->readback(length, __size_length); if (useChecksum) checksumCalculator->addBuffer(length, __size_length); } if (size != NULL) { stream->readback(size, __size_size); if (useChecksum) checksumCalculator->addBuffer(size, __size_size); } if (type != NULL) { stream->readback(type, __size_type); if (useChecksum) checksumCalculator->addBuffer(type, __size_type); } if (name != NULL) { stream->readback(name, __size_name); if (useChecksum) checksumCalculator->addBuffer(name, __size_name); } if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetActiveUniform: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetAttachedShaders_enc(void *self , GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_count = ((count != NULL) ? (sizeof(GLsizei)) : 0); const unsigned int __size_shaders = (maxcount*sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_count + __size_shaders + 2*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetAttachedShaders;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &program, 4); ptr += 4; memcpy(ptr, &maxcount, 4); ptr += 4; *(unsigned int *)(ptr) = __size_count; ptr += 4; *(unsigned int *)(ptr) = __size_shaders; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; if (count != NULL) { stream->readback(count, __size_count); if (useChecksum) checksumCalculator->addBuffer(count, __size_count); } stream->readback(shaders, __size_shaders); if (useChecksum) checksumCalculator->addBuffer(shaders, __size_shaders); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetAttachedShaders: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } int glGetAttribLocation_enc(void *self , GLuint program, const GLchar* name) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_name = (strlen(name) + 1); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_name + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetAttribLocation;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &program, 4); ptr += 4; *(unsigned int *)(ptr) = __size_name; ptr += 4; memcpy(ptr, name, __size_name);ptr += __size_name; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; int retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetAttribLocation: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void glGetBooleanv_enc(void *self , GLenum pname, GLboolean* params) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLboolean)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetBooleanv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetBooleanv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetBufferParameteriv_enc(void *self , GLenum target, GLenum pname, GLint* params) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetBufferParameteriv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetBufferParameteriv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } GLenum glGetError_enc(void *self ) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetError;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLenum retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetError: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void glGetFloatv_enc(void *self , GLenum pname, GLfloat* params) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetFloatv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetFloatv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetFramebufferAttachmentParameteriv_enc(void *self , GLenum target, GLenum attachment, GLenum pname, GLint* params) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetFramebufferAttachmentParameteriv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &attachment, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetFramebufferAttachmentParameteriv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetIntegerv_enc(void *self , GLenum pname, GLint* params) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetIntegerv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetIntegerv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetProgramiv_enc(void *self , GLuint program, GLenum pname, GLint* params) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = sizeof(GLint); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetProgramiv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &program, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetProgramiv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetProgramInfoLog_enc(void *self , GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_length = ((length != NULL) ? sizeof(GLsizei) : 0); const unsigned int __size_infolog = bufsize; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_length + __size_infolog + 2*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetProgramInfoLog;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &program, 4); ptr += 4; memcpy(ptr, &bufsize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_length; ptr += 4; *(unsigned int *)(ptr) = __size_infolog; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; if (length != NULL) { stream->readback(length, __size_length); if (useChecksum) checksumCalculator->addBuffer(length, __size_length); } stream->readback(infolog, __size_infolog); if (useChecksum) checksumCalculator->addBuffer(infolog, __size_infolog); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetProgramInfoLog: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetRenderbufferParameteriv_enc(void *self , GLenum target, GLenum pname, GLint* params) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = sizeof(GLint); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetRenderbufferParameteriv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetRenderbufferParameteriv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetShaderiv_enc(void *self , GLuint shader, GLenum pname, GLint* params) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = sizeof(GLint); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetShaderiv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &shader, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetShaderiv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetShaderInfoLog_enc(void *self , GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_length = ((length != NULL) ? (sizeof(GLsizei)) : 0); const unsigned int __size_infolog = bufsize; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_length + __size_infolog + 2*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetShaderInfoLog;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &shader, 4); ptr += 4; memcpy(ptr, &bufsize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_length; ptr += 4; *(unsigned int *)(ptr) = __size_infolog; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; if (length != NULL) { stream->readback(length, __size_length); if (useChecksum) checksumCalculator->addBuffer(length, __size_length); } stream->readback(infolog, __size_infolog); if (useChecksum) checksumCalculator->addBuffer(infolog, __size_infolog); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetShaderInfoLog: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetShaderPrecisionFormat_enc(void *self , GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_range = (2 * sizeof(GLint)); const unsigned int __size_precision = (sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_range + __size_precision + 2*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetShaderPrecisionFormat;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &shadertype, 4); ptr += 4; memcpy(ptr, &precisiontype, 4); ptr += 4; *(unsigned int *)(ptr) = __size_range; ptr += 4; *(unsigned int *)(ptr) = __size_precision; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(range, __size_range); if (useChecksum) checksumCalculator->addBuffer(range, __size_range); stream->readback(precision, __size_precision); if (useChecksum) checksumCalculator->addBuffer(precision, __size_precision); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetShaderPrecisionFormat: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetShaderSource_enc(void *self , GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_length = ((length != NULL) ? (sizeof(GLsizei)) : 0); const unsigned int __size_source = bufsize; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_length + __size_source + 2*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetShaderSource;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &shader, 4); ptr += 4; memcpy(ptr, &bufsize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_length; ptr += 4; *(unsigned int *)(ptr) = __size_source; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; if (length != NULL) { stream->readback(length, __size_length); if (useChecksum) checksumCalculator->addBuffer(length, __size_length); } stream->readback(source, __size_source); if (useChecksum) checksumCalculator->addBuffer(source, __size_source); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetShaderSource: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetTexParameterfv_enc(void *self , GLenum target, GLenum pname, GLfloat* params) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetTexParameterfv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetTexParameterfv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetTexParameteriv_enc(void *self , GLenum target, GLenum pname, GLint* params) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetTexParameteriv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetTexParameteriv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetUniformfv_enc(void *self , GLuint program, GLint location, GLfloat* params) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = glSizeof(glesv2_enc::uniformType(self, program, location)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetUniformfv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &program, 4); ptr += 4; memcpy(ptr, &location, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetUniformfv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetUniformiv_enc(void *self , GLuint program, GLint location, GLint* params) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = glSizeof(glesv2_enc::uniformType(self, program, location)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetUniformiv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &program, 4); ptr += 4; memcpy(ptr, &location, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetUniformiv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } int glGetUniformLocation_enc(void *self , GLuint program, const GLchar* name) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_name = (strlen(name) + 1); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_name + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetUniformLocation;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &program, 4); ptr += 4; *(unsigned int *)(ptr) = __size_name; ptr += 4; memcpy(ptr, name, __size_name);ptr += __size_name; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; int retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetUniformLocation: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void glGetVertexAttribfv_enc(void *self , GLuint index, GLenum pname, GLfloat* params) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetVertexAttribfv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &index, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetVertexAttribfv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glGetVertexAttribiv_enc(void *self , GLuint index, GLenum pname, GLint* params) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetVertexAttribiv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &index, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(params, __size_params); if (useChecksum) checksumCalculator->addBuffer(params, __size_params); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetVertexAttribiv: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glHint_enc(void *self , GLenum target, GLenum mode) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glHint;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &mode, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } GLboolean glIsBuffer_enc(void *self , GLuint buffer) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glIsBuffer;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &buffer, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLboolean retval; stream->readback(&retval, 1); if (useChecksum) checksumCalculator->addBuffer(&retval, 1); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glIsBuffer: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } GLboolean glIsEnabled_enc(void *self , GLenum cap) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glIsEnabled;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &cap, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLboolean retval; stream->readback(&retval, 1); if (useChecksum) checksumCalculator->addBuffer(&retval, 1); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glIsEnabled: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } GLboolean glIsFramebuffer_enc(void *self , GLuint framebuffer) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glIsFramebuffer;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &framebuffer, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLboolean retval; stream->readback(&retval, 1); if (useChecksum) checksumCalculator->addBuffer(&retval, 1); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glIsFramebuffer: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } GLboolean glIsProgram_enc(void *self , GLuint program) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glIsProgram;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &program, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLboolean retval; stream->readback(&retval, 1); if (useChecksum) checksumCalculator->addBuffer(&retval, 1); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glIsProgram: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } GLboolean glIsRenderbuffer_enc(void *self , GLuint renderbuffer) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glIsRenderbuffer;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &renderbuffer, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLboolean retval; stream->readback(&retval, 1); if (useChecksum) checksumCalculator->addBuffer(&retval, 1); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glIsRenderbuffer: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } GLboolean glIsShader_enc(void *self , GLuint shader) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glIsShader;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &shader, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLboolean retval; stream->readback(&retval, 1); if (useChecksum) checksumCalculator->addBuffer(&retval, 1); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glIsShader: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } GLboolean glIsTexture_enc(void *self , GLuint texture) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glIsTexture;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &texture, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLboolean retval; stream->readback(&retval, 1); if (useChecksum) checksumCalculator->addBuffer(&retval, 1); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glIsTexture: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void glLineWidth_enc(void *self , GLfloat width) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLineWidth;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glLinkProgram_enc(void *self , GLuint program) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glLinkProgram;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &program, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glPixelStorei_enc(void *self , GLenum pname, GLint param) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glPixelStorei;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glPolygonOffset_enc(void *self , GLfloat factor, GLfloat units) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glPolygonOffset;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &factor, 4); ptr += 4; memcpy(ptr, &units, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glReadPixels_enc(void *self , GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_pixels = glesv2_enc::pixelDataSize(self, width, height, format, type, 1); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glReadPixels;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; memcpy(ptr, &format, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; *(unsigned int *)(ptr) = __size_pixels; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(pixels, __size_pixels); if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glReadPixels: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glReleaseShaderCompiler_enc(void *self ) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glReleaseShaderCompiler;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glRenderbufferStorage_enc(void *self , GLenum target, GLenum internalformat, GLsizei width, GLsizei height) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glRenderbufferStorage;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &internalformat, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glSampleCoverage_enc(void *self , GLclampf value, GLboolean invert) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 1; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glSampleCoverage;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &value, 4); ptr += 4; memcpy(ptr, &invert, 1); ptr += 1; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glScissor_enc(void *self , GLint x, GLint y, GLsizei width, GLsizei height) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glScissor;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glStencilFunc_enc(void *self , GLenum func, GLint ref, GLuint mask) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glStencilFunc;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &func, 4); ptr += 4; memcpy(ptr, &ref, 4); ptr += 4; memcpy(ptr, &mask, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glStencilFuncSeparate_enc(void *self , GLenum face, GLenum func, GLint ref, GLuint mask) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glStencilFuncSeparate;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &face, 4); ptr += 4; memcpy(ptr, &func, 4); ptr += 4; memcpy(ptr, &ref, 4); ptr += 4; memcpy(ptr, &mask, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glStencilMask_enc(void *self , GLuint mask) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glStencilMask;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &mask, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glStencilMaskSeparate_enc(void *self , GLenum face, GLuint mask) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glStencilMaskSeparate;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &face, 4); ptr += 4; memcpy(ptr, &mask, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glStencilOp_enc(void *self , GLenum fail, GLenum zfail, GLenum zpass) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glStencilOp;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &fail, 4); ptr += 4; memcpy(ptr, &zfail, 4); ptr += 4; memcpy(ptr, &zpass, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glStencilOpSeparate_enc(void *self , GLenum face, GLenum fail, GLenum zfail, GLenum zpass) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glStencilOpSeparate;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &face, 4); ptr += 4; memcpy(ptr, &fail, 4); ptr += 4; memcpy(ptr, &zfail, 4); ptr += 4; memcpy(ptr, &zpass, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexImage2D_enc(void *self , GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_pixels = ((pixels != NULL) ? glesv2_enc::pixelDataSize(self, width, height, format, type, 0) : 0); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4); ptr = buf; int tmp = OP_glTexImage2D;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; memcpy(ptr, &internalformat, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; memcpy(ptr, &border, 4); ptr += 4; memcpy(ptr, &format, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); stream->flush(); stream->writeFully(&__size_pixels,4); if (useChecksum) checksumCalculator->addBuffer(&__size_pixels,4); if (pixels != NULL) { stream->writeFully(pixels, __size_pixels); if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels); } buf = stream->alloc(checksumSize); if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize); } void glTexParameterf_enc(void *self , GLenum target, GLenum pname, GLfloat param) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexParameterf;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexParameterfv_enc(void *self , GLenum target, GLenum pname, const GLfloat* params) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexParameterfv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexParameteri_enc(void *self , GLenum target, GLenum pname, GLint param) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexParameteri;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexParameteriv_enc(void *self , GLenum target, GLenum pname, const GLint* params) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_params = (glUtilsParamSize(pname) * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glTexParameteriv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &pname, 4); ptr += 4; *(unsigned int *)(ptr) = __size_params; ptr += 4; memcpy(ptr, params, __size_params);ptr += __size_params; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glTexSubImage2D_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_pixels = ((pixels != NULL) ? glesv2_enc::pixelDataSize(self, width, height, format, type, 0) : 0); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4); ptr = buf; int tmp = OP_glTexSubImage2D;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; memcpy(ptr, &xoffset, 4); ptr += 4; memcpy(ptr, &yoffset, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; memcpy(ptr, &format, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); stream->flush(); stream->writeFully(&__size_pixels,4); if (useChecksum) checksumCalculator->addBuffer(&__size_pixels,4); if (pixels != NULL) { stream->writeFully(pixels, __size_pixels); if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels); } buf = stream->alloc(checksumSize); if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize); } void glUniform1f_enc(void *self , GLint location, GLfloat x) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glUniform1f;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &location, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glUniform1fv_enc(void *self , GLint location, GLsizei count, const GLfloat* v) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_v = (count * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_v + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glUniform1fv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &location, 4); ptr += 4; memcpy(ptr, &count, 4); ptr += 4; *(unsigned int *)(ptr) = __size_v; ptr += 4; memcpy(ptr, v, __size_v);ptr += __size_v; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glUniform1i_enc(void *self , GLint location, GLint x) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glUniform1i;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &location, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glUniform1iv_enc(void *self , GLint location, GLsizei count, const GLint* v) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_v = (count * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_v + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glUniform1iv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &location, 4); ptr += 4; memcpy(ptr, &count, 4); ptr += 4; *(unsigned int *)(ptr) = __size_v; ptr += 4; memcpy(ptr, v, __size_v);ptr += __size_v; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glUniform2f_enc(void *self , GLint location, GLfloat x, GLfloat y) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glUniform2f;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &location, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glUniform2fv_enc(void *self , GLint location, GLsizei count, const GLfloat* v) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_v = (count * 2 * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_v + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glUniform2fv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &location, 4); ptr += 4; memcpy(ptr, &count, 4); ptr += 4; *(unsigned int *)(ptr) = __size_v; ptr += 4; memcpy(ptr, v, __size_v);ptr += __size_v; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glUniform2i_enc(void *self , GLint location, GLint x, GLint y) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glUniform2i;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &location, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glUniform2iv_enc(void *self , GLint location, GLsizei count, const GLint* v) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_v = (count * 2 * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_v + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glUniform2iv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &location, 4); ptr += 4; memcpy(ptr, &count, 4); ptr += 4; *(unsigned int *)(ptr) = __size_v; ptr += 4; memcpy(ptr, v, __size_v);ptr += __size_v; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glUniform3f_enc(void *self , GLint location, GLfloat x, GLfloat y, GLfloat z) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glUniform3f;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &location, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &z, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glUniform3fv_enc(void *self , GLint location, GLsizei count, const GLfloat* v) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_v = (count * 3 * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_v + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glUniform3fv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &location, 4); ptr += 4; memcpy(ptr, &count, 4); ptr += 4; *(unsigned int *)(ptr) = __size_v; ptr += 4; memcpy(ptr, v, __size_v);ptr += __size_v; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glUniform3i_enc(void *self , GLint location, GLint x, GLint y, GLint z) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glUniform3i;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &location, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &z, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glUniform3iv_enc(void *self , GLint location, GLsizei count, const GLint* v) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_v = (3 * count * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_v + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glUniform3iv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &location, 4); ptr += 4; memcpy(ptr, &count, 4); ptr += 4; *(unsigned int *)(ptr) = __size_v; ptr += 4; memcpy(ptr, v, __size_v);ptr += __size_v; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glUniform4f_enc(void *self , GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glUniform4f;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &location, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &z, 4); ptr += 4; memcpy(ptr, &w, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glUniform4fv_enc(void *self , GLint location, GLsizei count, const GLfloat* v) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_v = (4 * count * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_v + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glUniform4fv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &location, 4); ptr += 4; memcpy(ptr, &count, 4); ptr += 4; *(unsigned int *)(ptr) = __size_v; ptr += 4; memcpy(ptr, v, __size_v);ptr += __size_v; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glUniform4i_enc(void *self , GLint location, GLint x, GLint y, GLint z, GLint w) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glUniform4i;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &location, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &z, 4); ptr += 4; memcpy(ptr, &w, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glUniform4iv_enc(void *self , GLint location, GLsizei count, const GLint* v) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_v = (4 * count * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_v + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glUniform4iv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &location, 4); ptr += 4; memcpy(ptr, &count, 4); ptr += 4; *(unsigned int *)(ptr) = __size_v; ptr += 4; memcpy(ptr, v, __size_v);ptr += __size_v; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glUniformMatrix2fv_enc(void *self , GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_value = (count * 4 * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 1 + __size_value + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glUniformMatrix2fv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &location, 4); ptr += 4; memcpy(ptr, &count, 4); ptr += 4; memcpy(ptr, &transpose, 1); ptr += 1; *(unsigned int *)(ptr) = __size_value; ptr += 4; memcpy(ptr, value, __size_value);ptr += __size_value; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glUniformMatrix3fv_enc(void *self , GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_value = (count * 9 * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 1 + __size_value + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glUniformMatrix3fv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &location, 4); ptr += 4; memcpy(ptr, &count, 4); ptr += 4; memcpy(ptr, &transpose, 1); ptr += 1; *(unsigned int *)(ptr) = __size_value; ptr += 4; memcpy(ptr, value, __size_value);ptr += __size_value; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glUniformMatrix4fv_enc(void *self , GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_value = (count * 16 * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 1 + __size_value + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glUniformMatrix4fv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &location, 4); ptr += 4; memcpy(ptr, &count, 4); ptr += 4; memcpy(ptr, &transpose, 1); ptr += 1; *(unsigned int *)(ptr) = __size_value; ptr += 4; memcpy(ptr, value, __size_value);ptr += __size_value; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glUseProgram_enc(void *self , GLuint program) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glUseProgram;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &program, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glValidateProgram_enc(void *self , GLuint program) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glValidateProgram;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &program, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glVertexAttrib1f_enc(void *self , GLuint indx, GLfloat x) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glVertexAttrib1f;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &indx, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glVertexAttrib1fv_enc(void *self , GLuint indx, const GLfloat* values) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_values = (sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_values + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glVertexAttrib1fv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &indx, 4); ptr += 4; *(unsigned int *)(ptr) = __size_values; ptr += 4; memcpy(ptr, values, __size_values);ptr += __size_values; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glVertexAttrib2f_enc(void *self , GLuint indx, GLfloat x, GLfloat y) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glVertexAttrib2f;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &indx, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glVertexAttrib2fv_enc(void *self , GLuint indx, const GLfloat* values) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_values = (2 * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_values + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glVertexAttrib2fv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &indx, 4); ptr += 4; *(unsigned int *)(ptr) = __size_values; ptr += 4; memcpy(ptr, values, __size_values);ptr += __size_values; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glVertexAttrib3f_enc(void *self , GLuint indx, GLfloat x, GLfloat y, GLfloat z) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glVertexAttrib3f;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &indx, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &z, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glVertexAttrib3fv_enc(void *self , GLuint indx, const GLfloat* values) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_values = (3 * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_values + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glVertexAttrib3fv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &indx, 4); ptr += 4; *(unsigned int *)(ptr) = __size_values; ptr += 4; memcpy(ptr, values, __size_values);ptr += __size_values; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glVertexAttrib4f_enc(void *self , GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glVertexAttrib4f;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &indx, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &z, 4); ptr += 4; memcpy(ptr, &w, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glVertexAttrib4fv_enc(void *self , GLuint indx, const GLfloat* values) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_values = (4 * sizeof(GLfloat)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_values + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glVertexAttrib4fv;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &indx, 4); ptr += 4; *(unsigned int *)(ptr) = __size_values; ptr += 4; memcpy(ptr, values, __size_values);ptr += __size_values; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glViewport_enc(void *self , GLint x, GLint y, GLsizei width, GLsizei height) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glViewport;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glEGLImageTargetTexture2DOES_enc(void *self , GLenum target, GLeglImageOES image) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glEGLImageTargetTexture2DOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &image, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glEGLImageTargetRenderbufferStorageOES_enc(void *self , GLenum target, GLeglImageOES image) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glEGLImageTargetRenderbufferStorageOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &image, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } GLboolean glUnmapBufferOES_enc(void *self , GLenum target) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glUnmapBufferOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLboolean retval; stream->readback(&retval, 1); if (useChecksum) checksumCalculator->addBuffer(&retval, 1); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glUnmapBufferOES: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void glTexImage3DOES_enc(void *self , GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_pixels = ((pixels != NULL) ? glesv2_enc::pixelDataSize3D(self, width, height, depth, format, type, 0) : 0); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4); ptr = buf; int tmp = OP_glTexImage3DOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; memcpy(ptr, &internalformat, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; memcpy(ptr, &depth, 4); ptr += 4; memcpy(ptr, &border, 4); ptr += 4; memcpy(ptr, &format, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); stream->flush(); stream->writeFully(&__size_pixels,4); if (useChecksum) checksumCalculator->addBuffer(&__size_pixels,4); if (pixels != NULL) { stream->writeFully(pixels, __size_pixels); if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels); } buf = stream->alloc(checksumSize); if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize); } void glTexSubImage3DOES_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_pixels = ((pixels != NULL) ? glesv2_enc::pixelDataSize3D(self, width, height, depth, format, type, 0) : 0); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4); ptr = buf; int tmp = OP_glTexSubImage3DOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; memcpy(ptr, &xoffset, 4); ptr += 4; memcpy(ptr, &yoffset, 4); ptr += 4; memcpy(ptr, &zoffset, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; memcpy(ptr, &depth, 4); ptr += 4; memcpy(ptr, &format, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); stream->flush(); stream->writeFully(&__size_pixels,4); if (useChecksum) checksumCalculator->addBuffer(&__size_pixels,4); if (pixels != NULL) { stream->writeFully(pixels, __size_pixels); if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels); } buf = stream->alloc(checksumSize); if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize); } void glCopyTexSubImage3DOES_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glCopyTexSubImage3DOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; memcpy(ptr, &xoffset, 4); ptr += 4; memcpy(ptr, &yoffset, 4); ptr += 4; memcpy(ptr, &zoffset, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glCompressedTexImage3DOES_enc(void *self , GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_data = ((data != NULL) ? imageSize : 0); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_data + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4); ptr = buf; int tmp = OP_glCompressedTexImage3DOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; memcpy(ptr, &internalformat, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; memcpy(ptr, &depth, 4); ptr += 4; memcpy(ptr, &border, 4); ptr += 4; memcpy(ptr, &imageSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); stream->flush(); stream->writeFully(&__size_data,4); if (useChecksum) checksumCalculator->addBuffer(&__size_data,4); if (data != NULL) { stream->writeFully(data, __size_data); if (useChecksum) checksumCalculator->addBuffer(data, __size_data); } buf = stream->alloc(checksumSize); if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize); } void glCompressedTexSubImage3DOES_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_data = ((data != NULL) ? imageSize : 0); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_data + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4); ptr = buf; int tmp = OP_glCompressedTexSubImage3DOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; memcpy(ptr, &xoffset, 4); ptr += 4; memcpy(ptr, &yoffset, 4); ptr += 4; memcpy(ptr, &zoffset, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; memcpy(ptr, &depth, 4); ptr += 4; memcpy(ptr, &format, 4); ptr += 4; memcpy(ptr, &imageSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); stream->flush(); stream->writeFully(&__size_data,4); if (useChecksum) checksumCalculator->addBuffer(&__size_data,4); if (data != NULL) { stream->writeFully(data, __size_data); if (useChecksum) checksumCalculator->addBuffer(data, __size_data); } buf = stream->alloc(checksumSize); if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize); } void glFramebufferTexture3DOES_enc(void *self , GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFramebufferTexture3DOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &attachment, 4); ptr += 4; memcpy(ptr, &textarget, 4); ptr += 4; memcpy(ptr, &texture, 4); ptr += 4; memcpy(ptr, &level, 4); ptr += 4; memcpy(ptr, &zoffset, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glBindVertexArrayOES_enc(void *self , GLuint array) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glBindVertexArrayOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &array, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDeleteVertexArraysOES_enc(void *self , GLsizei n, const GLuint* arrays) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_arrays = (n * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_arrays + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDeleteVertexArraysOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &n, 4); ptr += 4; *(unsigned int *)(ptr) = __size_arrays; ptr += 4; memcpy(ptr, arrays, __size_arrays);ptr += __size_arrays; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glGenVertexArraysOES_enc(void *self , GLsizei n, GLuint* arrays) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_arrays = (n * sizeof(GLuint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_arrays + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGenVertexArraysOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &n, 4); ptr += 4; *(unsigned int *)(ptr) = __size_arrays; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(arrays, __size_arrays); if (useChecksum) checksumCalculator->addBuffer(arrays, __size_arrays); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGenVertexArraysOES: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } GLboolean glIsVertexArrayOES_enc(void *self , GLuint array) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glIsVertexArrayOES;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &array, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLboolean retval; stream->readback(&retval, 1); if (useChecksum) checksumCalculator->addBuffer(&retval, 1); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glIsVertexArrayOES: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void glDiscardFramebufferEXT_enc(void *self , GLenum target, GLsizei numAttachments, const GLenum* attachments) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_attachments = (numAttachments * sizeof(GLenum)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_attachments + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDiscardFramebufferEXT;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &numAttachments, 4); ptr += 4; *(unsigned int *)(ptr) = __size_attachments; ptr += 4; memcpy(ptr, attachments, __size_attachments);ptr += __size_attachments; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glVertexAttribPointerData_enc(void *self , GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, void* data, GLuint datalen) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_data = datalen; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 1 + 4 + __size_data + 4 + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glVertexAttribPointerData;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &indx, 4); ptr += 4; memcpy(ptr, &size, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; memcpy(ptr, &normalized, 1); ptr += 1; memcpy(ptr, &stride, 4); ptr += 4; *(unsigned int *)(ptr) = __size_data; ptr += 4; glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, size, type, stride, datalen);ptr += __size_data; memcpy(ptr, &datalen, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glVertexAttribPointerOffset_enc(void *self , GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint offset) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 1 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glVertexAttribPointerOffset;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &indx, 4); ptr += 4; memcpy(ptr, &size, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; memcpy(ptr, &normalized, 1); ptr += 1; memcpy(ptr, &stride, 4); ptr += 4; memcpy(ptr, &offset, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDrawElementsOffset_enc(void *self , GLenum mode, GLsizei count, GLenum type, GLuint offset) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDrawElementsOffset;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &mode, 4); ptr += 4; memcpy(ptr, &count, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; memcpy(ptr, &offset, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glDrawElementsData_enc(void *self , GLenum mode, GLsizei count, GLenum type, void* data, GLuint datalen) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_data = datalen; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_data + 4 + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glDrawElementsData;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &mode, 4); ptr += 4; memcpy(ptr, &count, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; *(unsigned int *)(ptr) = __size_data; ptr += 4; memcpy(ptr, data, __size_data);ptr += __size_data; memcpy(ptr, &datalen, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void glGetCompressedTextureFormats_enc(void *self , int count, GLint* formats) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_formats = (count * sizeof(GLint)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_formats + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glGetCompressedTextureFormats;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &count, 4); ptr += 4; *(unsigned int *)(ptr) = __size_formats; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(formats, __size_formats); if (useChecksum) checksumCalculator->addBuffer(formats, __size_formats); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glGetCompressedTextureFormats: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } void glShaderString_enc(void *self , GLuint shader, const GLchar* string, GLsizei len) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_string = len; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_string + 4 + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glShaderString;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &shader, 4); ptr += 4; *(unsigned int *)(ptr) = __size_string; ptr += 4; memcpy(ptr, string, __size_string);ptr += __size_string; memcpy(ptr, &len, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } int glFinishRoundTrip_enc(void *self ) { gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_glFinishRoundTrip;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; int retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("glFinishRoundTrip: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } } // namespace gl2_encoder_context_t::gl2_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator) { m_stream = stream; m_checksumCalculator = checksumCalculator; this->glActiveTexture = &glActiveTexture_enc; this->glAttachShader = &glAttachShader_enc; this->glBindAttribLocation = &glBindAttribLocation_enc; this->glBindBuffer = &glBindBuffer_enc; this->glBindFramebuffer = &glBindFramebuffer_enc; this->glBindRenderbuffer = &glBindRenderbuffer_enc; this->glBindTexture = &glBindTexture_enc; this->glBlendColor = &glBlendColor_enc; this->glBlendEquation = &glBlendEquation_enc; this->glBlendEquationSeparate = &glBlendEquationSeparate_enc; this->glBlendFunc = &glBlendFunc_enc; this->glBlendFuncSeparate = &glBlendFuncSeparate_enc; this->glBufferData = &glBufferData_enc; this->glBufferSubData = &glBufferSubData_enc; this->glCheckFramebufferStatus = &glCheckFramebufferStatus_enc; this->glClear = &glClear_enc; this->glClearColor = &glClearColor_enc; this->glClearDepthf = &glClearDepthf_enc; this->glClearStencil = &glClearStencil_enc; this->glColorMask = &glColorMask_enc; this->glCompileShader = &glCompileShader_enc; this->glCompressedTexImage2D = &glCompressedTexImage2D_enc; this->glCompressedTexSubImage2D = &glCompressedTexSubImage2D_enc; this->glCopyTexImage2D = &glCopyTexImage2D_enc; this->glCopyTexSubImage2D = &glCopyTexSubImage2D_enc; this->glCreateProgram = &glCreateProgram_enc; this->glCreateShader = &glCreateShader_enc; this->glCullFace = &glCullFace_enc; this->glDeleteBuffers = &glDeleteBuffers_enc; this->glDeleteFramebuffers = &glDeleteFramebuffers_enc; this->glDeleteProgram = &glDeleteProgram_enc; this->glDeleteRenderbuffers = &glDeleteRenderbuffers_enc; this->glDeleteShader = &glDeleteShader_enc; this->glDeleteTextures = &glDeleteTextures_enc; this->glDepthFunc = &glDepthFunc_enc; this->glDepthMask = &glDepthMask_enc; this->glDepthRangef = &glDepthRangef_enc; this->glDetachShader = &glDetachShader_enc; this->glDisable = &glDisable_enc; this->glDisableVertexAttribArray = &glDisableVertexAttribArray_enc; this->glDrawArrays = &glDrawArrays_enc; this->glDrawElements = (glDrawElements_client_proc_t) &enc_unsupported; this->glEnable = &glEnable_enc; this->glEnableVertexAttribArray = &glEnableVertexAttribArray_enc; this->glFinish = &glFinish_enc; this->glFlush = &glFlush_enc; this->glFramebufferRenderbuffer = &glFramebufferRenderbuffer_enc; this->glFramebufferTexture2D = &glFramebufferTexture2D_enc; this->glFrontFace = &glFrontFace_enc; this->glGenBuffers = &glGenBuffers_enc; this->glGenerateMipmap = &glGenerateMipmap_enc; this->glGenFramebuffers = &glGenFramebuffers_enc; this->glGenRenderbuffers = &glGenRenderbuffers_enc; this->glGenTextures = &glGenTextures_enc; this->glGetActiveAttrib = &glGetActiveAttrib_enc; this->glGetActiveUniform = &glGetActiveUniform_enc; this->glGetAttachedShaders = &glGetAttachedShaders_enc; this->glGetAttribLocation = &glGetAttribLocation_enc; this->glGetBooleanv = &glGetBooleanv_enc; this->glGetBufferParameteriv = &glGetBufferParameteriv_enc; this->glGetError = &glGetError_enc; this->glGetFloatv = &glGetFloatv_enc; this->glGetFramebufferAttachmentParameteriv = &glGetFramebufferAttachmentParameteriv_enc; this->glGetIntegerv = &glGetIntegerv_enc; this->glGetProgramiv = &glGetProgramiv_enc; this->glGetProgramInfoLog = &glGetProgramInfoLog_enc; this->glGetRenderbufferParameteriv = &glGetRenderbufferParameteriv_enc; this->glGetShaderiv = &glGetShaderiv_enc; this->glGetShaderInfoLog = &glGetShaderInfoLog_enc; this->glGetShaderPrecisionFormat = &glGetShaderPrecisionFormat_enc; this->glGetShaderSource = &glGetShaderSource_enc; this->glGetString = (glGetString_client_proc_t) &enc_unsupported; this->glGetTexParameterfv = &glGetTexParameterfv_enc; this->glGetTexParameteriv = &glGetTexParameteriv_enc; this->glGetUniformfv = &glGetUniformfv_enc; this->glGetUniformiv = &glGetUniformiv_enc; this->glGetUniformLocation = &glGetUniformLocation_enc; this->glGetVertexAttribfv = &glGetVertexAttribfv_enc; this->glGetVertexAttribiv = &glGetVertexAttribiv_enc; this->glGetVertexAttribPointerv = (glGetVertexAttribPointerv_client_proc_t) &enc_unsupported; this->glHint = &glHint_enc; this->glIsBuffer = &glIsBuffer_enc; this->glIsEnabled = &glIsEnabled_enc; this->glIsFramebuffer = &glIsFramebuffer_enc; this->glIsProgram = &glIsProgram_enc; this->glIsRenderbuffer = &glIsRenderbuffer_enc; this->glIsShader = &glIsShader_enc; this->glIsTexture = &glIsTexture_enc; this->glLineWidth = &glLineWidth_enc; this->glLinkProgram = &glLinkProgram_enc; this->glPixelStorei = &glPixelStorei_enc; this->glPolygonOffset = &glPolygonOffset_enc; this->glReadPixels = &glReadPixels_enc; this->glReleaseShaderCompiler = &glReleaseShaderCompiler_enc; this->glRenderbufferStorage = &glRenderbufferStorage_enc; this->glSampleCoverage = &glSampleCoverage_enc; this->glScissor = &glScissor_enc; this->glShaderBinary = (glShaderBinary_client_proc_t) &enc_unsupported; this->glShaderSource = (glShaderSource_client_proc_t) &enc_unsupported; this->glStencilFunc = &glStencilFunc_enc; this->glStencilFuncSeparate = &glStencilFuncSeparate_enc; this->glStencilMask = &glStencilMask_enc; this->glStencilMaskSeparate = &glStencilMaskSeparate_enc; this->glStencilOp = &glStencilOp_enc; this->glStencilOpSeparate = &glStencilOpSeparate_enc; this->glTexImage2D = &glTexImage2D_enc; this->glTexParameterf = &glTexParameterf_enc; this->glTexParameterfv = &glTexParameterfv_enc; this->glTexParameteri = &glTexParameteri_enc; this->glTexParameteriv = &glTexParameteriv_enc; this->glTexSubImage2D = &glTexSubImage2D_enc; this->glUniform1f = &glUniform1f_enc; this->glUniform1fv = &glUniform1fv_enc; this->glUniform1i = &glUniform1i_enc; this->glUniform1iv = &glUniform1iv_enc; this->glUniform2f = &glUniform2f_enc; this->glUniform2fv = &glUniform2fv_enc; this->glUniform2i = &glUniform2i_enc; this->glUniform2iv = &glUniform2iv_enc; this->glUniform3f = &glUniform3f_enc; this->glUniform3fv = &glUniform3fv_enc; this->glUniform3i = &glUniform3i_enc; this->glUniform3iv = &glUniform3iv_enc; this->glUniform4f = &glUniform4f_enc; this->glUniform4fv = &glUniform4fv_enc; this->glUniform4i = &glUniform4i_enc; this->glUniform4iv = &glUniform4iv_enc; this->glUniformMatrix2fv = &glUniformMatrix2fv_enc; this->glUniformMatrix3fv = &glUniformMatrix3fv_enc; this->glUniformMatrix4fv = &glUniformMatrix4fv_enc; this->glUseProgram = &glUseProgram_enc; this->glValidateProgram = &glValidateProgram_enc; this->glVertexAttrib1f = &glVertexAttrib1f_enc; this->glVertexAttrib1fv = &glVertexAttrib1fv_enc; this->glVertexAttrib2f = &glVertexAttrib2f_enc; this->glVertexAttrib2fv = &glVertexAttrib2fv_enc; this->glVertexAttrib3f = &glVertexAttrib3f_enc; this->glVertexAttrib3fv = &glVertexAttrib3fv_enc; this->glVertexAttrib4f = &glVertexAttrib4f_enc; this->glVertexAttrib4fv = &glVertexAttrib4fv_enc; this->glVertexAttribPointer = (glVertexAttribPointer_client_proc_t) &enc_unsupported; this->glViewport = &glViewport_enc; this->glEGLImageTargetTexture2DOES = &glEGLImageTargetTexture2DOES_enc; this->glEGLImageTargetRenderbufferStorageOES = &glEGLImageTargetRenderbufferStorageOES_enc; this->glGetProgramBinaryOES = (glGetProgramBinaryOES_client_proc_t) &enc_unsupported; this->glProgramBinaryOES = (glProgramBinaryOES_client_proc_t) &enc_unsupported; this->glMapBufferOES = (glMapBufferOES_client_proc_t) &enc_unsupported; this->glUnmapBufferOES = &glUnmapBufferOES_enc; this->glTexImage3DOES = &glTexImage3DOES_enc; this->glTexSubImage3DOES = &glTexSubImage3DOES_enc; this->glCopyTexSubImage3DOES = &glCopyTexSubImage3DOES_enc; this->glCompressedTexImage3DOES = &glCompressedTexImage3DOES_enc; this->glCompressedTexSubImage3DOES = &glCompressedTexSubImage3DOES_enc; this->glFramebufferTexture3DOES = &glFramebufferTexture3DOES_enc; this->glBindVertexArrayOES = &glBindVertexArrayOES_enc; this->glDeleteVertexArraysOES = &glDeleteVertexArraysOES_enc; this->glGenVertexArraysOES = &glGenVertexArraysOES_enc; this->glIsVertexArrayOES = &glIsVertexArrayOES_enc; this->glDiscardFramebufferEXT = &glDiscardFramebufferEXT_enc; this->glMultiDrawArraysEXT = (glMultiDrawArraysEXT_client_proc_t) &enc_unsupported; this->glMultiDrawElementsEXT = (glMultiDrawElementsEXT_client_proc_t) &enc_unsupported; this->glGetPerfMonitorGroupsAMD = (glGetPerfMonitorGroupsAMD_client_proc_t) &enc_unsupported; this->glGetPerfMonitorCountersAMD = (glGetPerfMonitorCountersAMD_client_proc_t) &enc_unsupported; this->glGetPerfMonitorGroupStringAMD = (glGetPerfMonitorGroupStringAMD_client_proc_t) &enc_unsupported; this->glGetPerfMonitorCounterStringAMD = (glGetPerfMonitorCounterStringAMD_client_proc_t) &enc_unsupported; this->glGetPerfMonitorCounterInfoAMD = (glGetPerfMonitorCounterInfoAMD_client_proc_t) &enc_unsupported; this->glGenPerfMonitorsAMD = (glGenPerfMonitorsAMD_client_proc_t) &enc_unsupported; this->glDeletePerfMonitorsAMD = (glDeletePerfMonitorsAMD_client_proc_t) &enc_unsupported; this->glSelectPerfMonitorCountersAMD = (glSelectPerfMonitorCountersAMD_client_proc_t) &enc_unsupported; this->glBeginPerfMonitorAMD = (glBeginPerfMonitorAMD_client_proc_t) &enc_unsupported; this->glEndPerfMonitorAMD = (glEndPerfMonitorAMD_client_proc_t) &enc_unsupported; this->glGetPerfMonitorCounterDataAMD = (glGetPerfMonitorCounterDataAMD_client_proc_t) &enc_unsupported; this->glRenderbufferStorageMultisampleIMG = (glRenderbufferStorageMultisampleIMG_client_proc_t) &enc_unsupported; this->glFramebufferTexture2DMultisampleIMG = (glFramebufferTexture2DMultisampleIMG_client_proc_t) &enc_unsupported; this->glDeleteFencesNV = (glDeleteFencesNV_client_proc_t) &enc_unsupported; this->glGenFencesNV = (glGenFencesNV_client_proc_t) &enc_unsupported; this->glIsFenceNV = (glIsFenceNV_client_proc_t) &enc_unsupported; this->glTestFenceNV = (glTestFenceNV_client_proc_t) &enc_unsupported; this->glGetFenceivNV = (glGetFenceivNV_client_proc_t) &enc_unsupported; this->glFinishFenceNV = (glFinishFenceNV_client_proc_t) &enc_unsupported; this->glSetFenceNV = (glSetFenceNV_client_proc_t) &enc_unsupported; this->glCoverageMaskNV = (glCoverageMaskNV_client_proc_t) &enc_unsupported; this->glCoverageOperationNV = (glCoverageOperationNV_client_proc_t) &enc_unsupported; this->glGetDriverControlsQCOM = (glGetDriverControlsQCOM_client_proc_t) &enc_unsupported; this->glGetDriverControlStringQCOM = (glGetDriverControlStringQCOM_client_proc_t) &enc_unsupported; this->glEnableDriverControlQCOM = (glEnableDriverControlQCOM_client_proc_t) &enc_unsupported; this->glDisableDriverControlQCOM = (glDisableDriverControlQCOM_client_proc_t) &enc_unsupported; this->glExtGetTexturesQCOM = (glExtGetTexturesQCOM_client_proc_t) &enc_unsupported; this->glExtGetBuffersQCOM = (glExtGetBuffersQCOM_client_proc_t) &enc_unsupported; this->glExtGetRenderbuffersQCOM = (glExtGetRenderbuffersQCOM_client_proc_t) &enc_unsupported; this->glExtGetFramebuffersQCOM = (glExtGetFramebuffersQCOM_client_proc_t) &enc_unsupported; this->glExtGetTexLevelParameterivQCOM = (glExtGetTexLevelParameterivQCOM_client_proc_t) &enc_unsupported; this->glExtTexObjectStateOverrideiQCOM = (glExtTexObjectStateOverrideiQCOM_client_proc_t) &enc_unsupported; this->glExtGetTexSubImageQCOM = (glExtGetTexSubImageQCOM_client_proc_t) &enc_unsupported; this->glExtGetBufferPointervQCOM = (glExtGetBufferPointervQCOM_client_proc_t) &enc_unsupported; this->glExtGetShadersQCOM = (glExtGetShadersQCOM_client_proc_t) &enc_unsupported; this->glExtGetProgramsQCOM = (glExtGetProgramsQCOM_client_proc_t) &enc_unsupported; this->glExtIsProgramBinaryQCOM = (glExtIsProgramBinaryQCOM_client_proc_t) &enc_unsupported; this->glExtGetProgramBinarySourceQCOM = (glExtGetProgramBinarySourceQCOM_client_proc_t) &enc_unsupported; this->glStartTilingQCOM = (glStartTilingQCOM_client_proc_t) &enc_unsupported; this->glEndTilingQCOM = (glEndTilingQCOM_client_proc_t) &enc_unsupported; this->glVertexAttribPointerData = &glVertexAttribPointerData_enc; this->glVertexAttribPointerOffset = &glVertexAttribPointerOffset_enc; this->glDrawElementsOffset = &glDrawElementsOffset_enc; this->glDrawElementsData = &glDrawElementsData_enc; this->glGetCompressedTextureFormats = &glGetCompressedTextureFormats_enc; this->glShaderString = &glShaderString_enc; this->glFinishRoundTrip = &glFinishRoundTrip_enc; } anbox-0.0~git20191115/android/opengl/system/GLESv2_enc/gl2_enc.h000066400000000000000000000010401356361734700237610ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef GUARD_gl2_encoder_context_t #define GUARD_gl2_encoder_context_t #include "IOStream.h" #include "ChecksumCalculator.h" #include "gl2_client_context.h" #include #include "glUtils.h" #include "GL2EncoderUtils.h" struct gl2_encoder_context_t : public gl2_client_context_t { IOStream *m_stream; ChecksumCalculator *m_checksumCalculator; gl2_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator); }; #endif // GUARD_gl2_encoder_context_tanbox-0.0~git20191115/android/opengl/system/GLESv2_enc/gl2_entry.cpp000066400000000000000000001333751356361734700247310ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #include #include #include "gl2_client_context.h" #ifndef GL_TRUE extern "C" { void glActiveTexture(GLenum texture); void glAttachShader(GLuint program, GLuint shader); void glBindAttribLocation(GLuint program, GLuint index, const GLchar* name); void glBindBuffer(GLenum target, GLuint buffer); void glBindFramebuffer(GLenum target, GLuint framebuffer); void glBindRenderbuffer(GLenum target, GLuint renderbuffer); void glBindTexture(GLenum target, GLuint texture); void glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); void glBlendEquation(GLenum mode); void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha); void glBlendFunc(GLenum sfactor, GLenum dfactor); void glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); void glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); GLenum glCheckFramebufferStatus(GLenum target); void glClear(GLbitfield mask); void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); void glClearDepthf(GLclampf depth); void glClearStencil(GLint s); void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); void glCompileShader(GLuint shader); void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); GLuint glCreateProgram(); GLuint glCreateShader(GLenum type); void glCullFace(GLenum mode); void glDeleteBuffers(GLsizei n, const GLuint* buffers); void glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers); void glDeleteProgram(GLuint program); void glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers); void glDeleteShader(GLuint shader); void glDeleteTextures(GLsizei n, const GLuint* textures); void glDepthFunc(GLenum func); void glDepthMask(GLboolean flag); void glDepthRangef(GLclampf zNear, GLclampf zFar); void glDetachShader(GLuint program, GLuint shader); void glDisable(GLenum cap); void glDisableVertexAttribArray(GLuint index); void glDrawArrays(GLenum mode, GLint first, GLsizei count); void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices); void glEnable(GLenum cap); void glEnableVertexAttribArray(GLuint index); void glFinish(); void glFlush(); void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); void glFrontFace(GLenum mode); void glGenBuffers(GLsizei n, GLuint* buffers); void glGenerateMipmap(GLenum target); void glGenFramebuffers(GLsizei n, GLuint* framebuffers); void glGenRenderbuffers(GLsizei n, GLuint* renderbuffers); void glGenTextures(GLsizei n, GLuint* textures); void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name); void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name); void glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders); int glGetAttribLocation(GLuint program, const GLchar* name); void glGetBooleanv(GLenum pname, GLboolean* params); void glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params); GLenum glGetError(); void glGetFloatv(GLenum pname, GLfloat* params); void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params); void glGetIntegerv(GLenum pname, GLint* params); void glGetProgramiv(GLuint program, GLenum pname, GLint* params); void glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog); void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params); void glGetShaderiv(GLuint shader, GLenum pname, GLint* params); void glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog); void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision); void glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source); const GLubyte* glGetString(GLenum name); void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params); void glGetTexParameteriv(GLenum target, GLenum pname, GLint* params); void glGetUniformfv(GLuint program, GLint location, GLfloat* params); void glGetUniformiv(GLuint program, GLint location, GLint* params); int glGetUniformLocation(GLuint program, const GLchar* name); void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params); void glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params); void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer); void glHint(GLenum target, GLenum mode); GLboolean glIsBuffer(GLuint buffer); GLboolean glIsEnabled(GLenum cap); GLboolean glIsFramebuffer(GLuint framebuffer); GLboolean glIsProgram(GLuint program); GLboolean glIsRenderbuffer(GLuint renderbuffer); GLboolean glIsShader(GLuint shader); GLboolean glIsTexture(GLuint texture); void glLineWidth(GLfloat width); void glLinkProgram(GLuint program); void glPixelStorei(GLenum pname, GLint param); void glPolygonOffset(GLfloat factor, GLfloat units); void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels); void glReleaseShaderCompiler(); void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); void glSampleCoverage(GLclampf value, GLboolean invert); void glScissor(GLint x, GLint y, GLsizei width, GLsizei height); void glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length); void glShaderSource(GLuint shader, GLsizei count, const GLchar* const* string, const GLint* length); void glStencilFunc(GLenum func, GLint ref, GLuint mask); void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask); void glStencilMask(GLuint mask); void glStencilMaskSeparate(GLenum face, GLuint mask); void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass); void glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass); void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels); void glTexParameterf(GLenum target, GLenum pname, GLfloat param); void glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params); void glTexParameteri(GLenum target, GLenum pname, GLint param); void glTexParameteriv(GLenum target, GLenum pname, const GLint* params); void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels); void glUniform1f(GLint location, GLfloat x); void glUniform1fv(GLint location, GLsizei count, const GLfloat* v); void glUniform1i(GLint location, GLint x); void glUniform1iv(GLint location, GLsizei count, const GLint* v); void glUniform2f(GLint location, GLfloat x, GLfloat y); void glUniform2fv(GLint location, GLsizei count, const GLfloat* v); void glUniform2i(GLint location, GLint x, GLint y); void glUniform2iv(GLint location, GLsizei count, const GLint* v); void glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z); void glUniform3fv(GLint location, GLsizei count, const GLfloat* v); void glUniform3i(GLint location, GLint x, GLint y, GLint z); void glUniform3iv(GLint location, GLsizei count, const GLint* v); void glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w); void glUniform4fv(GLint location, GLsizei count, const GLfloat* v); void glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w); void glUniform4iv(GLint location, GLsizei count, const GLint* v); void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); void glUseProgram(GLuint program); void glValidateProgram(GLuint program); void glVertexAttrib1f(GLuint indx, GLfloat x); void glVertexAttrib1fv(GLuint indx, const GLfloat* values); void glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y); void glVertexAttrib2fv(GLuint indx, const GLfloat* values); void glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z); void glVertexAttrib3fv(GLuint indx, const GLfloat* values); void glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w); void glVertexAttrib4fv(GLuint indx, const GLfloat* values); void glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr); void glViewport(GLint x, GLint y, GLsizei width, GLsizei height); void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image); void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image); void glGetProgramBinaryOES(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary); void glProgramBinaryOES(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLint length); void* glMapBufferOES(GLenum target, GLenum access); GLboolean glUnmapBufferOES(GLenum target); void glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels); void glTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels); void glCopyTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); void glCompressedTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data); void glCompressedTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data); void glFramebufferTexture3DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); void glBindVertexArrayOES(GLuint array); void glDeleteVertexArraysOES(GLsizei n, const GLuint* arrays); void glGenVertexArraysOES(GLsizei n, GLuint* arrays); GLboolean glIsVertexArrayOES(GLuint array); void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum* attachments); void glMultiDrawArraysEXT(GLenum mode, const GLint* first, const GLsizei* count, GLsizei primcount); void glMultiDrawElementsEXT(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices, GLsizei primcount); void glGetPerfMonitorGroupsAMD(GLint* numGroups, GLsizei groupsSize, GLuint* groups); void glGetPerfMonitorCountersAMD(GLuint group, GLint* numCounters, GLint* maxActiveCounters, GLsizei counterSize, GLuint* counters); void glGetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize, GLsizei* length, GLchar* groupString); void glGetPerfMonitorCounterStringAMD(GLuint group, GLuint counter, GLsizei bufSize, GLsizei* length, GLchar* counterString); void glGetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, GLenum pname, GLvoid* data); void glGenPerfMonitorsAMD(GLsizei n, GLuint* monitors); void glDeletePerfMonitorsAMD(GLsizei n, GLuint* monitors); void glSelectPerfMonitorCountersAMD(GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint* countersList); void glBeginPerfMonitorAMD(GLuint monitor); void glEndPerfMonitorAMD(GLuint monitor); void glGetPerfMonitorCounterDataAMD(GLuint monitor, GLenum pname, GLsizei dataSize, GLuint* data, GLint* bytesWritten); void glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); void glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples); void glDeleteFencesNV(GLsizei n, const GLuint* fences); void glGenFencesNV(GLsizei n, GLuint* fences); GLboolean glIsFenceNV(GLuint fence); GLboolean glTestFenceNV(GLuint fence); void glGetFenceivNV(GLuint fence, GLenum pname, GLint* params); void glFinishFenceNV(GLuint fence); void glSetFenceNV(GLuint fence, GLenum condition); void glCoverageMaskNV(GLboolean mask); void glCoverageOperationNV(GLenum operation); void glGetDriverControlsQCOM(GLint* num, GLsizei size, GLuint* driverControls); void glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei* length, GLchar* driverControlString); void glEnableDriverControlQCOM(GLuint driverControl); void glDisableDriverControlQCOM(GLuint driverControl); void glExtGetTexturesQCOM(GLuint* textures, GLint maxTextures, GLint* numTextures); void glExtGetBuffersQCOM(GLuint* buffers, GLint maxBuffers, GLint* numBuffers); void glExtGetRenderbuffersQCOM(GLuint* renderbuffers, GLint maxRenderbuffers, GLint* numRenderbuffers); void glExtGetFramebuffersQCOM(GLuint* framebuffers, GLint maxFramebuffers, GLint* numFramebuffers); void glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint* params); void glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param); void glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid* texels); void glExtGetBufferPointervQCOM(GLenum target, GLvoidptr* params); void glExtGetShadersQCOM(GLuint* shaders, GLint maxShaders, GLint* numShaders); void glExtGetProgramsQCOM(GLuint* programs, GLint maxPrograms, GLint* numPrograms); GLboolean glExtIsProgramBinaryQCOM(GLuint program); void glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar* source, GLint* length); void glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask); void glEndTilingQCOM(GLbitfield preserveMask); void glVertexAttribPointerData(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, void* data, GLuint datalen); void glVertexAttribPointerOffset(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint offset); void glDrawElementsOffset(GLenum mode, GLsizei count, GLenum type, GLuint offset); void glDrawElementsData(GLenum mode, GLsizei count, GLenum type, void* data, GLuint datalen); void glGetCompressedTextureFormats(int count, GLint* formats); void glShaderString(GLuint shader, const GLchar* string, GLsizei len); int glFinishRoundTrip(); }; #endif #ifndef GET_CONTEXT static gl2_client_context_t::CONTEXT_ACCESSOR_TYPE *getCurrentContext = NULL; void gl2_client_context_t::setContextAccessor(CONTEXT_ACCESSOR_TYPE *f) { getCurrentContext = f; } #define GET_CONTEXT gl2_client_context_t * ctx = getCurrentContext() #endif void glActiveTexture(GLenum texture) { GET_CONTEXT; ctx->glActiveTexture(ctx, texture); } void glAttachShader(GLuint program, GLuint shader) { GET_CONTEXT; ctx->glAttachShader(ctx, program, shader); } void glBindAttribLocation(GLuint program, GLuint index, const GLchar* name) { GET_CONTEXT; ctx->glBindAttribLocation(ctx, program, index, name); } void glBindBuffer(GLenum target, GLuint buffer) { GET_CONTEXT; ctx->glBindBuffer(ctx, target, buffer); } void glBindFramebuffer(GLenum target, GLuint framebuffer) { GET_CONTEXT; ctx->glBindFramebuffer(ctx, target, framebuffer); } void glBindRenderbuffer(GLenum target, GLuint renderbuffer) { GET_CONTEXT; ctx->glBindRenderbuffer(ctx, target, renderbuffer); } void glBindTexture(GLenum target, GLuint texture) { GET_CONTEXT; ctx->glBindTexture(ctx, target, texture); } void glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { GET_CONTEXT; ctx->glBlendColor(ctx, red, green, blue, alpha); } void glBlendEquation(GLenum mode) { GET_CONTEXT; ctx->glBlendEquation(ctx, mode); } void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) { GET_CONTEXT; ctx->glBlendEquationSeparate(ctx, modeRGB, modeAlpha); } void glBlendFunc(GLenum sfactor, GLenum dfactor) { GET_CONTEXT; ctx->glBlendFunc(ctx, sfactor, dfactor); } void glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) { GET_CONTEXT; ctx->glBlendFuncSeparate(ctx, srcRGB, dstRGB, srcAlpha, dstAlpha); } void glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) { GET_CONTEXT; ctx->glBufferData(ctx, target, size, data, usage); } void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) { GET_CONTEXT; ctx->glBufferSubData(ctx, target, offset, size, data); } GLenum glCheckFramebufferStatus(GLenum target) { GET_CONTEXT; return ctx->glCheckFramebufferStatus(ctx, target); } void glClear(GLbitfield mask) { GET_CONTEXT; ctx->glClear(ctx, mask); } void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { GET_CONTEXT; ctx->glClearColor(ctx, red, green, blue, alpha); } void glClearDepthf(GLclampf depth) { GET_CONTEXT; ctx->glClearDepthf(ctx, depth); } void glClearStencil(GLint s) { GET_CONTEXT; ctx->glClearStencil(ctx, s); } void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) { GET_CONTEXT; ctx->glColorMask(ctx, red, green, blue, alpha); } void glCompileShader(GLuint shader) { GET_CONTEXT; ctx->glCompileShader(ctx, shader); } void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) { GET_CONTEXT; ctx->glCompressedTexImage2D(ctx, target, level, internalformat, width, height, border, imageSize, data); } void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) { GET_CONTEXT; ctx->glCompressedTexSubImage2D(ctx, target, level, xoffset, yoffset, width, height, format, imageSize, data); } void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { GET_CONTEXT; ctx->glCopyTexImage2D(ctx, target, level, internalformat, x, y, width, height, border); } void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { GET_CONTEXT; ctx->glCopyTexSubImage2D(ctx, target, level, xoffset, yoffset, x, y, width, height); } GLuint glCreateProgram() { GET_CONTEXT; return ctx->glCreateProgram(ctx); } GLuint glCreateShader(GLenum type) { GET_CONTEXT; return ctx->glCreateShader(ctx, type); } void glCullFace(GLenum mode) { GET_CONTEXT; ctx->glCullFace(ctx, mode); } void glDeleteBuffers(GLsizei n, const GLuint* buffers) { GET_CONTEXT; if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } ctx->glDeleteBuffers(ctx, n, buffers); } void glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers) { GET_CONTEXT; if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } ctx->glDeleteFramebuffers(ctx, n, framebuffers); } void glDeleteProgram(GLuint program) { GET_CONTEXT; ctx->glDeleteProgram(ctx, program); } void glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) { GET_CONTEXT; if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } ctx->glDeleteRenderbuffers(ctx, n, renderbuffers); } void glDeleteShader(GLuint shader) { GET_CONTEXT; ctx->glDeleteShader(ctx, shader); } void glDeleteTextures(GLsizei n, const GLuint* textures) { GET_CONTEXT; if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } ctx->glDeleteTextures(ctx, n, textures); } void glDepthFunc(GLenum func) { GET_CONTEXT; ctx->glDepthFunc(ctx, func); } void glDepthMask(GLboolean flag) { GET_CONTEXT; ctx->glDepthMask(ctx, flag); } void glDepthRangef(GLclampf zNear, GLclampf zFar) { GET_CONTEXT; ctx->glDepthRangef(ctx, zNear, zFar); } void glDetachShader(GLuint program, GLuint shader) { GET_CONTEXT; ctx->glDetachShader(ctx, program, shader); } void glDisable(GLenum cap) { GET_CONTEXT; ctx->glDisable(ctx, cap); } void glDisableVertexAttribArray(GLuint index) { GET_CONTEXT; ctx->glDisableVertexAttribArray(ctx, index); } void glDrawArrays(GLenum mode, GLint first, GLsizei count) { GET_CONTEXT; ctx->glDrawArrays(ctx, mode, first, count); } void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices) { GET_CONTEXT; ctx->glDrawElements(ctx, mode, count, type, indices); } void glEnable(GLenum cap) { GET_CONTEXT; ctx->glEnable(ctx, cap); } void glEnableVertexAttribArray(GLuint index) { GET_CONTEXT; ctx->glEnableVertexAttribArray(ctx, index); } void glFinish() { GET_CONTEXT; ctx->glFinish(ctx); } void glFlush() { GET_CONTEXT; ctx->glFlush(ctx); } void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) { GET_CONTEXT; ctx->glFramebufferRenderbuffer(ctx, target, attachment, renderbuffertarget, renderbuffer); } void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { GET_CONTEXT; ctx->glFramebufferTexture2D(ctx, target, attachment, textarget, texture, level); } void glFrontFace(GLenum mode) { GET_CONTEXT; ctx->glFrontFace(ctx, mode); } void glGenBuffers(GLsizei n, GLuint* buffers) { GET_CONTEXT; if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } ctx->glGenBuffers(ctx, n, buffers); } void glGenerateMipmap(GLenum target) { GET_CONTEXT; ctx->glGenerateMipmap(ctx, target); } void glGenFramebuffers(GLsizei n, GLuint* framebuffers) { GET_CONTEXT; if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } ctx->glGenFramebuffers(ctx, n, framebuffers); } void glGenRenderbuffers(GLsizei n, GLuint* renderbuffers) { GET_CONTEXT; if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } ctx->glGenRenderbuffers(ctx, n, renderbuffers); } void glGenTextures(GLsizei n, GLuint* textures) { GET_CONTEXT; if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } ctx->glGenTextures(ctx, n, textures); } void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name) { GET_CONTEXT; ctx->glGetActiveAttrib(ctx, program, index, bufsize, length, size, type, name); } void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name) { GET_CONTEXT; ctx->glGetActiveUniform(ctx, program, index, bufsize, length, size, type, name); } void glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) { GET_CONTEXT; ctx->glGetAttachedShaders(ctx, program, maxcount, count, shaders); } int glGetAttribLocation(GLuint program, const GLchar* name) { GET_CONTEXT; return ctx->glGetAttribLocation(ctx, program, name); } void glGetBooleanv(GLenum pname, GLboolean* params) { GET_CONTEXT; ctx->glGetBooleanv(ctx, pname, params); } void glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params) { GET_CONTEXT; ctx->glGetBufferParameteriv(ctx, target, pname, params); } GLenum glGetError() { GET_CONTEXT; return ctx->glGetError(ctx); } void glGetFloatv(GLenum pname, GLfloat* params) { GET_CONTEXT; ctx->glGetFloatv(ctx, pname, params); } void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) { GET_CONTEXT; ctx->glGetFramebufferAttachmentParameteriv(ctx, target, attachment, pname, params); } void glGetIntegerv(GLenum pname, GLint* params) { GET_CONTEXT; ctx->glGetIntegerv(ctx, pname, params); } void glGetProgramiv(GLuint program, GLenum pname, GLint* params) { GET_CONTEXT; ctx->glGetProgramiv(ctx, program, pname, params); } void glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog) { GET_CONTEXT; ctx->glGetProgramInfoLog(ctx, program, bufsize, length, infolog); } void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) { GET_CONTEXT; ctx->glGetRenderbufferParameteriv(ctx, target, pname, params); } void glGetShaderiv(GLuint shader, GLenum pname, GLint* params) { GET_CONTEXT; ctx->glGetShaderiv(ctx, shader, pname, params); } void glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog) { GET_CONTEXT; ctx->glGetShaderInfoLog(ctx, shader, bufsize, length, infolog); } void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) { GET_CONTEXT; ctx->glGetShaderPrecisionFormat(ctx, shadertype, precisiontype, range, precision); } void glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source) { GET_CONTEXT; ctx->glGetShaderSource(ctx, shader, bufsize, length, source); } const GLubyte* glGetString(GLenum name) { GET_CONTEXT; return ctx->glGetString(ctx, name); } void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) { GET_CONTEXT; ctx->glGetTexParameterfv(ctx, target, pname, params); } void glGetTexParameteriv(GLenum target, GLenum pname, GLint* params) { GET_CONTEXT; ctx->glGetTexParameteriv(ctx, target, pname, params); } void glGetUniformfv(GLuint program, GLint location, GLfloat* params) { GET_CONTEXT; ctx->glGetUniformfv(ctx, program, location, params); } void glGetUniformiv(GLuint program, GLint location, GLint* params) { GET_CONTEXT; ctx->glGetUniformiv(ctx, program, location, params); } int glGetUniformLocation(GLuint program, const GLchar* name) { GET_CONTEXT; return ctx->glGetUniformLocation(ctx, program, name); } void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) { GET_CONTEXT; ctx->glGetVertexAttribfv(ctx, index, pname, params); } void glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params) { GET_CONTEXT; ctx->glGetVertexAttribiv(ctx, index, pname, params); } void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer) { GET_CONTEXT; ctx->glGetVertexAttribPointerv(ctx, index, pname, pointer); } void glHint(GLenum target, GLenum mode) { GET_CONTEXT; ctx->glHint(ctx, target, mode); } GLboolean glIsBuffer(GLuint buffer) { GET_CONTEXT; return ctx->glIsBuffer(ctx, buffer); } GLboolean glIsEnabled(GLenum cap) { GET_CONTEXT; return ctx->glIsEnabled(ctx, cap); } GLboolean glIsFramebuffer(GLuint framebuffer) { GET_CONTEXT; return ctx->glIsFramebuffer(ctx, framebuffer); } GLboolean glIsProgram(GLuint program) { GET_CONTEXT; return ctx->glIsProgram(ctx, program); } GLboolean glIsRenderbuffer(GLuint renderbuffer) { GET_CONTEXT; return ctx->glIsRenderbuffer(ctx, renderbuffer); } GLboolean glIsShader(GLuint shader) { GET_CONTEXT; return ctx->glIsShader(ctx, shader); } GLboolean glIsTexture(GLuint texture) { GET_CONTEXT; return ctx->glIsTexture(ctx, texture); } void glLineWidth(GLfloat width) { GET_CONTEXT; ctx->glLineWidth(ctx, width); } void glLinkProgram(GLuint program) { GET_CONTEXT; ctx->glLinkProgram(ctx, program); } void glPixelStorei(GLenum pname, GLint param) { GET_CONTEXT; ctx->glPixelStorei(ctx, pname, param); } void glPolygonOffset(GLfloat factor, GLfloat units) { GET_CONTEXT; ctx->glPolygonOffset(ctx, factor, units); } void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels) { GET_CONTEXT; ctx->glReadPixels(ctx, x, y, width, height, format, type, pixels); } void glReleaseShaderCompiler() { GET_CONTEXT; ctx->glReleaseShaderCompiler(ctx); } void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) { GET_CONTEXT; ctx->glRenderbufferStorage(ctx, target, internalformat, width, height); } void glSampleCoverage(GLclampf value, GLboolean invert) { GET_CONTEXT; ctx->glSampleCoverage(ctx, value, invert); } void glScissor(GLint x, GLint y, GLsizei width, GLsizei height) { GET_CONTEXT; ctx->glScissor(ctx, x, y, width, height); } void glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length) { GET_CONTEXT; ctx->glShaderBinary(ctx, n, shaders, binaryformat, binary, length); } void glShaderSource(GLuint shader, GLsizei count, const GLchar* const* string, const GLint* length) { GET_CONTEXT; ctx->glShaderSource(ctx, shader, count, string, length); } void glStencilFunc(GLenum func, GLint ref, GLuint mask) { GET_CONTEXT; ctx->glStencilFunc(ctx, func, ref, mask); } void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) { GET_CONTEXT; ctx->glStencilFuncSeparate(ctx, face, func, ref, mask); } void glStencilMask(GLuint mask) { GET_CONTEXT; ctx->glStencilMask(ctx, mask); } void glStencilMaskSeparate(GLenum face, GLuint mask) { GET_CONTEXT; ctx->glStencilMaskSeparate(ctx, face, mask); } void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) { GET_CONTEXT; ctx->glStencilOp(ctx, fail, zfail, zpass); } void glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) { GET_CONTEXT; ctx->glStencilOpSeparate(ctx, face, fail, zfail, zpass); } void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels) { GET_CONTEXT; ctx->glTexImage2D(ctx, target, level, internalformat, width, height, border, format, type, pixels); } void glTexParameterf(GLenum target, GLenum pname, GLfloat param) { GET_CONTEXT; ctx->glTexParameterf(ctx, target, pname, param); } void glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params) { GET_CONTEXT; ctx->glTexParameterfv(ctx, target, pname, params); } void glTexParameteri(GLenum target, GLenum pname, GLint param) { GET_CONTEXT; ctx->glTexParameteri(ctx, target, pname, param); } void glTexParameteriv(GLenum target, GLenum pname, const GLint* params) { GET_CONTEXT; ctx->glTexParameteriv(ctx, target, pname, params); } void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels) { GET_CONTEXT; ctx->glTexSubImage2D(ctx, target, level, xoffset, yoffset, width, height, format, type, pixels); } void glUniform1f(GLint location, GLfloat x) { GET_CONTEXT; ctx->glUniform1f(ctx, location, x); } void glUniform1fv(GLint location, GLsizei count, const GLfloat* v) { GET_CONTEXT; ctx->glUniform1fv(ctx, location, count, v); } void glUniform1i(GLint location, GLint x) { GET_CONTEXT; ctx->glUniform1i(ctx, location, x); } void glUniform1iv(GLint location, GLsizei count, const GLint* v) { GET_CONTEXT; ctx->glUniform1iv(ctx, location, count, v); } void glUniform2f(GLint location, GLfloat x, GLfloat y) { GET_CONTEXT; ctx->glUniform2f(ctx, location, x, y); } void glUniform2fv(GLint location, GLsizei count, const GLfloat* v) { GET_CONTEXT; ctx->glUniform2fv(ctx, location, count, v); } void glUniform2i(GLint location, GLint x, GLint y) { GET_CONTEXT; ctx->glUniform2i(ctx, location, x, y); } void glUniform2iv(GLint location, GLsizei count, const GLint* v) { GET_CONTEXT; ctx->glUniform2iv(ctx, location, count, v); } void glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) { GET_CONTEXT; ctx->glUniform3f(ctx, location, x, y, z); } void glUniform3fv(GLint location, GLsizei count, const GLfloat* v) { GET_CONTEXT; ctx->glUniform3fv(ctx, location, count, v); } void glUniform3i(GLint location, GLint x, GLint y, GLint z) { GET_CONTEXT; ctx->glUniform3i(ctx, location, x, y, z); } void glUniform3iv(GLint location, GLsizei count, const GLint* v) { GET_CONTEXT; ctx->glUniform3iv(ctx, location, count, v); } void glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { GET_CONTEXT; ctx->glUniform4f(ctx, location, x, y, z, w); } void glUniform4fv(GLint location, GLsizei count, const GLfloat* v) { GET_CONTEXT; ctx->glUniform4fv(ctx, location, count, v); } void glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) { GET_CONTEXT; ctx->glUniform4i(ctx, location, x, y, z, w); } void glUniform4iv(GLint location, GLsizei count, const GLint* v) { GET_CONTEXT; ctx->glUniform4iv(ctx, location, count, v); } void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { GET_CONTEXT; ctx->glUniformMatrix2fv(ctx, location, count, transpose, value); } void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { GET_CONTEXT; ctx->glUniformMatrix3fv(ctx, location, count, transpose, value); } void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { GET_CONTEXT; ctx->glUniformMatrix4fv(ctx, location, count, transpose, value); } void glUseProgram(GLuint program) { GET_CONTEXT; ctx->glUseProgram(ctx, program); } void glValidateProgram(GLuint program) { GET_CONTEXT; ctx->glValidateProgram(ctx, program); } void glVertexAttrib1f(GLuint indx, GLfloat x) { GET_CONTEXT; ctx->glVertexAttrib1f(ctx, indx, x); } void glVertexAttrib1fv(GLuint indx, const GLfloat* values) { GET_CONTEXT; ctx->glVertexAttrib1fv(ctx, indx, values); } void glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) { GET_CONTEXT; ctx->glVertexAttrib2f(ctx, indx, x, y); } void glVertexAttrib2fv(GLuint indx, const GLfloat* values) { GET_CONTEXT; ctx->glVertexAttrib2fv(ctx, indx, values); } void glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) { GET_CONTEXT; ctx->glVertexAttrib3f(ctx, indx, x, y, z); } void glVertexAttrib3fv(GLuint indx, const GLfloat* values) { GET_CONTEXT; ctx->glVertexAttrib3fv(ctx, indx, values); } void glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { GET_CONTEXT; ctx->glVertexAttrib4f(ctx, indx, x, y, z, w); } void glVertexAttrib4fv(GLuint indx, const GLfloat* values) { GET_CONTEXT; ctx->glVertexAttrib4fv(ctx, indx, values); } void glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr) { GET_CONTEXT; ctx->glVertexAttribPointer(ctx, indx, size, type, normalized, stride, ptr); } void glViewport(GLint x, GLint y, GLsizei width, GLsizei height) { GET_CONTEXT; ctx->glViewport(ctx, x, y, width, height); } void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image) { GET_CONTEXT; ctx->glEGLImageTargetTexture2DOES(ctx, target, image); } void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image) { GET_CONTEXT; ctx->glEGLImageTargetRenderbufferStorageOES(ctx, target, image); } void glGetProgramBinaryOES(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) { GET_CONTEXT; ctx->glGetProgramBinaryOES(ctx, program, bufSize, length, binaryFormat, binary); } void glProgramBinaryOES(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLint length) { GET_CONTEXT; ctx->glProgramBinaryOES(ctx, program, binaryFormat, binary, length); } void* glMapBufferOES(GLenum target, GLenum access) { GET_CONTEXT; return ctx->glMapBufferOES(ctx, target, access); } GLboolean glUnmapBufferOES(GLenum target) { GET_CONTEXT; return ctx->glUnmapBufferOES(ctx, target); } void glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels) { GET_CONTEXT; ctx->glTexImage3DOES(ctx, target, level, internalformat, width, height, depth, border, format, type, pixels); } void glTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels) { GET_CONTEXT; ctx->glTexSubImage3DOES(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); } void glCopyTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) { GET_CONTEXT; ctx->glCopyTexSubImage3DOES(ctx, target, level, xoffset, yoffset, zoffset, x, y, width, height); } void glCompressedTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) { GET_CONTEXT; ctx->glCompressedTexImage3DOES(ctx, target, level, internalformat, width, height, depth, border, imageSize, data); } void glCompressedTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) { GET_CONTEXT; ctx->glCompressedTexSubImage3DOES(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); } void glFramebufferTexture3DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) { GET_CONTEXT; ctx->glFramebufferTexture3DOES(ctx, target, attachment, textarget, texture, level, zoffset); } void glBindVertexArrayOES(GLuint array) { GET_CONTEXT; ctx->glBindVertexArrayOES(ctx, array); } void glDeleteVertexArraysOES(GLsizei n, const GLuint* arrays) { GET_CONTEXT; if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } ctx->glDeleteVertexArraysOES(ctx, n, arrays); } void glGenVertexArraysOES(GLsizei n, GLuint* arrays) { GET_CONTEXT; if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } ctx->glGenVertexArraysOES(ctx, n, arrays); } GLboolean glIsVertexArrayOES(GLuint array) { GET_CONTEXT; return ctx->glIsVertexArrayOES(ctx, array); } void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum* attachments) { GET_CONTEXT; ctx->glDiscardFramebufferEXT(ctx, target, numAttachments, attachments); } void glMultiDrawArraysEXT(GLenum mode, const GLint* first, const GLsizei* count, GLsizei primcount) { GET_CONTEXT; ctx->glMultiDrawArraysEXT(ctx, mode, first, count, primcount); } void glMultiDrawElementsEXT(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices, GLsizei primcount) { GET_CONTEXT; ctx->glMultiDrawElementsEXT(ctx, mode, count, type, indices, primcount); } void glGetPerfMonitorGroupsAMD(GLint* numGroups, GLsizei groupsSize, GLuint* groups) { GET_CONTEXT; ctx->glGetPerfMonitorGroupsAMD(ctx, numGroups, groupsSize, groups); } void glGetPerfMonitorCountersAMD(GLuint group, GLint* numCounters, GLint* maxActiveCounters, GLsizei counterSize, GLuint* counters) { GET_CONTEXT; ctx->glGetPerfMonitorCountersAMD(ctx, group, numCounters, maxActiveCounters, counterSize, counters); } void glGetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize, GLsizei* length, GLchar* groupString) { GET_CONTEXT; ctx->glGetPerfMonitorGroupStringAMD(ctx, group, bufSize, length, groupString); } void glGetPerfMonitorCounterStringAMD(GLuint group, GLuint counter, GLsizei bufSize, GLsizei* length, GLchar* counterString) { GET_CONTEXT; ctx->glGetPerfMonitorCounterStringAMD(ctx, group, counter, bufSize, length, counterString); } void glGetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, GLenum pname, GLvoid* data) { GET_CONTEXT; ctx->glGetPerfMonitorCounterInfoAMD(ctx, group, counter, pname, data); } void glGenPerfMonitorsAMD(GLsizei n, GLuint* monitors) { GET_CONTEXT; ctx->glGenPerfMonitorsAMD(ctx, n, monitors); } void glDeletePerfMonitorsAMD(GLsizei n, GLuint* monitors) { GET_CONTEXT; ctx->glDeletePerfMonitorsAMD(ctx, n, monitors); } void glSelectPerfMonitorCountersAMD(GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint* countersList) { GET_CONTEXT; ctx->glSelectPerfMonitorCountersAMD(ctx, monitor, enable, group, numCounters, countersList); } void glBeginPerfMonitorAMD(GLuint monitor) { GET_CONTEXT; ctx->glBeginPerfMonitorAMD(ctx, monitor); } void glEndPerfMonitorAMD(GLuint monitor) { GET_CONTEXT; ctx->glEndPerfMonitorAMD(ctx, monitor); } void glGetPerfMonitorCounterDataAMD(GLuint monitor, GLenum pname, GLsizei dataSize, GLuint* data, GLint* bytesWritten) { GET_CONTEXT; ctx->glGetPerfMonitorCounterDataAMD(ctx, monitor, pname, dataSize, data, bytesWritten); } void glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) { GET_CONTEXT; ctx->glRenderbufferStorageMultisampleIMG(ctx, target, samples, internalformat, width, height); } void glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples) { GET_CONTEXT; ctx->glFramebufferTexture2DMultisampleIMG(ctx, target, attachment, textarget, texture, level, samples); } void glDeleteFencesNV(GLsizei n, const GLuint* fences) { GET_CONTEXT; ctx->glDeleteFencesNV(ctx, n, fences); } void glGenFencesNV(GLsizei n, GLuint* fences) { GET_CONTEXT; ctx->glGenFencesNV(ctx, n, fences); } GLboolean glIsFenceNV(GLuint fence) { GET_CONTEXT; return ctx->glIsFenceNV(ctx, fence); } GLboolean glTestFenceNV(GLuint fence) { GET_CONTEXT; return ctx->glTestFenceNV(ctx, fence); } void glGetFenceivNV(GLuint fence, GLenum pname, GLint* params) { GET_CONTEXT; ctx->glGetFenceivNV(ctx, fence, pname, params); } void glFinishFenceNV(GLuint fence) { GET_CONTEXT; ctx->glFinishFenceNV(ctx, fence); } void glSetFenceNV(GLuint fence, GLenum condition) { GET_CONTEXT; ctx->glSetFenceNV(ctx, fence, condition); } void glCoverageMaskNV(GLboolean mask) { GET_CONTEXT; ctx->glCoverageMaskNV(ctx, mask); } void glCoverageOperationNV(GLenum operation) { GET_CONTEXT; ctx->glCoverageOperationNV(ctx, operation); } void glGetDriverControlsQCOM(GLint* num, GLsizei size, GLuint* driverControls) { GET_CONTEXT; ctx->glGetDriverControlsQCOM(ctx, num, size, driverControls); } void glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei* length, GLchar* driverControlString) { GET_CONTEXT; ctx->glGetDriverControlStringQCOM(ctx, driverControl, bufSize, length, driverControlString); } void glEnableDriverControlQCOM(GLuint driverControl) { GET_CONTEXT; ctx->glEnableDriverControlQCOM(ctx, driverControl); } void glDisableDriverControlQCOM(GLuint driverControl) { GET_CONTEXT; ctx->glDisableDriverControlQCOM(ctx, driverControl); } void glExtGetTexturesQCOM(GLuint* textures, GLint maxTextures, GLint* numTextures) { GET_CONTEXT; ctx->glExtGetTexturesQCOM(ctx, textures, maxTextures, numTextures); } void glExtGetBuffersQCOM(GLuint* buffers, GLint maxBuffers, GLint* numBuffers) { GET_CONTEXT; ctx->glExtGetBuffersQCOM(ctx, buffers, maxBuffers, numBuffers); } void glExtGetRenderbuffersQCOM(GLuint* renderbuffers, GLint maxRenderbuffers, GLint* numRenderbuffers) { GET_CONTEXT; ctx->glExtGetRenderbuffersQCOM(ctx, renderbuffers, maxRenderbuffers, numRenderbuffers); } void glExtGetFramebuffersQCOM(GLuint* framebuffers, GLint maxFramebuffers, GLint* numFramebuffers) { GET_CONTEXT; ctx->glExtGetFramebuffersQCOM(ctx, framebuffers, maxFramebuffers, numFramebuffers); } void glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint* params) { GET_CONTEXT; ctx->glExtGetTexLevelParameterivQCOM(ctx, texture, face, level, pname, params); } void glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param) { GET_CONTEXT; ctx->glExtTexObjectStateOverrideiQCOM(ctx, target, pname, param); } void glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid* texels) { GET_CONTEXT; ctx->glExtGetTexSubImageQCOM(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels); } void glExtGetBufferPointervQCOM(GLenum target, GLvoidptr* params) { GET_CONTEXT; ctx->glExtGetBufferPointervQCOM(ctx, target, params); } void glExtGetShadersQCOM(GLuint* shaders, GLint maxShaders, GLint* numShaders) { GET_CONTEXT; ctx->glExtGetShadersQCOM(ctx, shaders, maxShaders, numShaders); } void glExtGetProgramsQCOM(GLuint* programs, GLint maxPrograms, GLint* numPrograms) { GET_CONTEXT; ctx->glExtGetProgramsQCOM(ctx, programs, maxPrograms, numPrograms); } GLboolean glExtIsProgramBinaryQCOM(GLuint program) { GET_CONTEXT; return ctx->glExtIsProgramBinaryQCOM(ctx, program); } void glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar* source, GLint* length) { GET_CONTEXT; ctx->glExtGetProgramBinarySourceQCOM(ctx, program, shadertype, source, length); } void glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask) { GET_CONTEXT; ctx->glStartTilingQCOM(ctx, x, y, width, height, preserveMask); } void glEndTilingQCOM(GLbitfield preserveMask) { GET_CONTEXT; ctx->glEndTilingQCOM(ctx, preserveMask); } void glVertexAttribPointerData(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, void* data, GLuint datalen) { GET_CONTEXT; ctx->glVertexAttribPointerData(ctx, indx, size, type, normalized, stride, data, datalen); } void glVertexAttribPointerOffset(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint offset) { GET_CONTEXT; ctx->glVertexAttribPointerOffset(ctx, indx, size, type, normalized, stride, offset); } void glDrawElementsOffset(GLenum mode, GLsizei count, GLenum type, GLuint offset) { GET_CONTEXT; ctx->glDrawElementsOffset(ctx, mode, count, type, offset); } void glDrawElementsData(GLenum mode, GLsizei count, GLenum type, void* data, GLuint datalen) { GET_CONTEXT; ctx->glDrawElementsData(ctx, mode, count, type, data, datalen); } void glGetCompressedTextureFormats(int count, GLint* formats) { GET_CONTEXT; ctx->glGetCompressedTextureFormats(ctx, count, formats); } void glShaderString(GLuint shader, const GLchar* string, GLsizei len) { GET_CONTEXT; ctx->glShaderString(ctx, shader, string, len); } int glFinishRoundTrip() { GET_CONTEXT; return ctx->glFinishRoundTrip(ctx); } anbox-0.0~git20191115/android/opengl/system/GLESv2_enc/gl2_ftable.h000066400000000000000000000244651356361734700244710ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef __gl2_client_ftable_t_h #define __gl2_client_ftable_t_h static const struct _gl2_funcs_by_name { const char *name; void *proc; } gl2_funcs_by_name[] = { {"glActiveTexture", (void*)glActiveTexture}, {"glAttachShader", (void*)glAttachShader}, {"glBindAttribLocation", (void*)glBindAttribLocation}, {"glBindBuffer", (void*)glBindBuffer}, {"glBindFramebuffer", (void*)glBindFramebuffer}, {"glBindRenderbuffer", (void*)glBindRenderbuffer}, {"glBindTexture", (void*)glBindTexture}, {"glBlendColor", (void*)glBlendColor}, {"glBlendEquation", (void*)glBlendEquation}, {"glBlendEquationSeparate", (void*)glBlendEquationSeparate}, {"glBlendFunc", (void*)glBlendFunc}, {"glBlendFuncSeparate", (void*)glBlendFuncSeparate}, {"glBufferData", (void*)glBufferData}, {"glBufferSubData", (void*)glBufferSubData}, {"glCheckFramebufferStatus", (void*)glCheckFramebufferStatus}, {"glClear", (void*)glClear}, {"glClearColor", (void*)glClearColor}, {"glClearDepthf", (void*)glClearDepthf}, {"glClearStencil", (void*)glClearStencil}, {"glColorMask", (void*)glColorMask}, {"glCompileShader", (void*)glCompileShader}, {"glCompressedTexImage2D", (void*)glCompressedTexImage2D}, {"glCompressedTexSubImage2D", (void*)glCompressedTexSubImage2D}, {"glCopyTexImage2D", (void*)glCopyTexImage2D}, {"glCopyTexSubImage2D", (void*)glCopyTexSubImage2D}, {"glCreateProgram", (void*)glCreateProgram}, {"glCreateShader", (void*)glCreateShader}, {"glCullFace", (void*)glCullFace}, {"glDeleteBuffers", (void*)glDeleteBuffers}, {"glDeleteFramebuffers", (void*)glDeleteFramebuffers}, {"glDeleteProgram", (void*)glDeleteProgram}, {"glDeleteRenderbuffers", (void*)glDeleteRenderbuffers}, {"glDeleteShader", (void*)glDeleteShader}, {"glDeleteTextures", (void*)glDeleteTextures}, {"glDepthFunc", (void*)glDepthFunc}, {"glDepthMask", (void*)glDepthMask}, {"glDepthRangef", (void*)glDepthRangef}, {"glDetachShader", (void*)glDetachShader}, {"glDisable", (void*)glDisable}, {"glDisableVertexAttribArray", (void*)glDisableVertexAttribArray}, {"glDrawArrays", (void*)glDrawArrays}, {"glDrawElements", (void*)glDrawElements}, {"glEnable", (void*)glEnable}, {"glEnableVertexAttribArray", (void*)glEnableVertexAttribArray}, {"glFinish", (void*)glFinish}, {"glFlush", (void*)glFlush}, {"glFramebufferRenderbuffer", (void*)glFramebufferRenderbuffer}, {"glFramebufferTexture2D", (void*)glFramebufferTexture2D}, {"glFrontFace", (void*)glFrontFace}, {"glGenBuffers", (void*)glGenBuffers}, {"glGenerateMipmap", (void*)glGenerateMipmap}, {"glGenFramebuffers", (void*)glGenFramebuffers}, {"glGenRenderbuffers", (void*)glGenRenderbuffers}, {"glGenTextures", (void*)glGenTextures}, {"glGetActiveAttrib", (void*)glGetActiveAttrib}, {"glGetActiveUniform", (void*)glGetActiveUniform}, {"glGetAttachedShaders", (void*)glGetAttachedShaders}, {"glGetAttribLocation", (void*)glGetAttribLocation}, {"glGetBooleanv", (void*)glGetBooleanv}, {"glGetBufferParameteriv", (void*)glGetBufferParameteriv}, {"glGetError", (void*)glGetError}, {"glGetFloatv", (void*)glGetFloatv}, {"glGetFramebufferAttachmentParameteriv", (void*)glGetFramebufferAttachmentParameteriv}, {"glGetIntegerv", (void*)glGetIntegerv}, {"glGetProgramiv", (void*)glGetProgramiv}, {"glGetProgramInfoLog", (void*)glGetProgramInfoLog}, {"glGetRenderbufferParameteriv", (void*)glGetRenderbufferParameteriv}, {"glGetShaderiv", (void*)glGetShaderiv}, {"glGetShaderInfoLog", (void*)glGetShaderInfoLog}, {"glGetShaderPrecisionFormat", (void*)glGetShaderPrecisionFormat}, {"glGetShaderSource", (void*)glGetShaderSource}, {"glGetString", (void*)glGetString}, {"glGetTexParameterfv", (void*)glGetTexParameterfv}, {"glGetTexParameteriv", (void*)glGetTexParameteriv}, {"glGetUniformfv", (void*)glGetUniformfv}, {"glGetUniformiv", (void*)glGetUniformiv}, {"glGetUniformLocation", (void*)glGetUniformLocation}, {"glGetVertexAttribfv", (void*)glGetVertexAttribfv}, {"glGetVertexAttribiv", (void*)glGetVertexAttribiv}, {"glGetVertexAttribPointerv", (void*)glGetVertexAttribPointerv}, {"glHint", (void*)glHint}, {"glIsBuffer", (void*)glIsBuffer}, {"glIsEnabled", (void*)glIsEnabled}, {"glIsFramebuffer", (void*)glIsFramebuffer}, {"glIsProgram", (void*)glIsProgram}, {"glIsRenderbuffer", (void*)glIsRenderbuffer}, {"glIsShader", (void*)glIsShader}, {"glIsTexture", (void*)glIsTexture}, {"glLineWidth", (void*)glLineWidth}, {"glLinkProgram", (void*)glLinkProgram}, {"glPixelStorei", (void*)glPixelStorei}, {"glPolygonOffset", (void*)glPolygonOffset}, {"glReadPixels", (void*)glReadPixels}, {"glReleaseShaderCompiler", (void*)glReleaseShaderCompiler}, {"glRenderbufferStorage", (void*)glRenderbufferStorage}, {"glSampleCoverage", (void*)glSampleCoverage}, {"glScissor", (void*)glScissor}, {"glShaderBinary", (void*)glShaderBinary}, {"glShaderSource", (void*)glShaderSource}, {"glStencilFunc", (void*)glStencilFunc}, {"glStencilFuncSeparate", (void*)glStencilFuncSeparate}, {"glStencilMask", (void*)glStencilMask}, {"glStencilMaskSeparate", (void*)glStencilMaskSeparate}, {"glStencilOp", (void*)glStencilOp}, {"glStencilOpSeparate", (void*)glStencilOpSeparate}, {"glTexImage2D", (void*)glTexImage2D}, {"glTexParameterf", (void*)glTexParameterf}, {"glTexParameterfv", (void*)glTexParameterfv}, {"glTexParameteri", (void*)glTexParameteri}, {"glTexParameteriv", (void*)glTexParameteriv}, {"glTexSubImage2D", (void*)glTexSubImage2D}, {"glUniform1f", (void*)glUniform1f}, {"glUniform1fv", (void*)glUniform1fv}, {"glUniform1i", (void*)glUniform1i}, {"glUniform1iv", (void*)glUniform1iv}, {"glUniform2f", (void*)glUniform2f}, {"glUniform2fv", (void*)glUniform2fv}, {"glUniform2i", (void*)glUniform2i}, {"glUniform2iv", (void*)glUniform2iv}, {"glUniform3f", (void*)glUniform3f}, {"glUniform3fv", (void*)glUniform3fv}, {"glUniform3i", (void*)glUniform3i}, {"glUniform3iv", (void*)glUniform3iv}, {"glUniform4f", (void*)glUniform4f}, {"glUniform4fv", (void*)glUniform4fv}, {"glUniform4i", (void*)glUniform4i}, {"glUniform4iv", (void*)glUniform4iv}, {"glUniformMatrix2fv", (void*)glUniformMatrix2fv}, {"glUniformMatrix3fv", (void*)glUniformMatrix3fv}, {"glUniformMatrix4fv", (void*)glUniformMatrix4fv}, {"glUseProgram", (void*)glUseProgram}, {"glValidateProgram", (void*)glValidateProgram}, {"glVertexAttrib1f", (void*)glVertexAttrib1f}, {"glVertexAttrib1fv", (void*)glVertexAttrib1fv}, {"glVertexAttrib2f", (void*)glVertexAttrib2f}, {"glVertexAttrib2fv", (void*)glVertexAttrib2fv}, {"glVertexAttrib3f", (void*)glVertexAttrib3f}, {"glVertexAttrib3fv", (void*)glVertexAttrib3fv}, {"glVertexAttrib4f", (void*)glVertexAttrib4f}, {"glVertexAttrib4fv", (void*)glVertexAttrib4fv}, {"glVertexAttribPointer", (void*)glVertexAttribPointer}, {"glViewport", (void*)glViewport}, {"glEGLImageTargetTexture2DOES", (void*)glEGLImageTargetTexture2DOES}, {"glEGLImageTargetRenderbufferStorageOES", (void*)glEGLImageTargetRenderbufferStorageOES}, {"glGetProgramBinaryOES", (void*)glGetProgramBinaryOES}, {"glProgramBinaryOES", (void*)glProgramBinaryOES}, {"glMapBufferOES", (void*)glMapBufferOES}, {"glUnmapBufferOES", (void*)glUnmapBufferOES}, {"glTexImage3DOES", (void*)glTexImage3DOES}, {"glTexSubImage3DOES", (void*)glTexSubImage3DOES}, {"glCopyTexSubImage3DOES", (void*)glCopyTexSubImage3DOES}, {"glCompressedTexImage3DOES", (void*)glCompressedTexImage3DOES}, {"glCompressedTexSubImage3DOES", (void*)glCompressedTexSubImage3DOES}, {"glFramebufferTexture3DOES", (void*)glFramebufferTexture3DOES}, {"glBindVertexArrayOES", (void*)glBindVertexArrayOES}, {"glDeleteVertexArraysOES", (void*)glDeleteVertexArraysOES}, {"glGenVertexArraysOES", (void*)glGenVertexArraysOES}, {"glIsVertexArrayOES", (void*)glIsVertexArrayOES}, {"glDiscardFramebufferEXT", (void*)glDiscardFramebufferEXT}, {"glMultiDrawArraysEXT", (void*)glMultiDrawArraysEXT}, {"glMultiDrawElementsEXT", (void*)glMultiDrawElementsEXT}, {"glGetPerfMonitorGroupsAMD", (void*)glGetPerfMonitorGroupsAMD}, {"glGetPerfMonitorCountersAMD", (void*)glGetPerfMonitorCountersAMD}, {"glGetPerfMonitorGroupStringAMD", (void*)glGetPerfMonitorGroupStringAMD}, {"glGetPerfMonitorCounterStringAMD", (void*)glGetPerfMonitorCounterStringAMD}, {"glGetPerfMonitorCounterInfoAMD", (void*)glGetPerfMonitorCounterInfoAMD}, {"glGenPerfMonitorsAMD", (void*)glGenPerfMonitorsAMD}, {"glDeletePerfMonitorsAMD", (void*)glDeletePerfMonitorsAMD}, {"glSelectPerfMonitorCountersAMD", (void*)glSelectPerfMonitorCountersAMD}, {"glBeginPerfMonitorAMD", (void*)glBeginPerfMonitorAMD}, {"glEndPerfMonitorAMD", (void*)glEndPerfMonitorAMD}, {"glGetPerfMonitorCounterDataAMD", (void*)glGetPerfMonitorCounterDataAMD}, {"glRenderbufferStorageMultisampleIMG", (void*)glRenderbufferStorageMultisampleIMG}, {"glFramebufferTexture2DMultisampleIMG", (void*)glFramebufferTexture2DMultisampleIMG}, {"glDeleteFencesNV", (void*)glDeleteFencesNV}, {"glGenFencesNV", (void*)glGenFencesNV}, {"glIsFenceNV", (void*)glIsFenceNV}, {"glTestFenceNV", (void*)glTestFenceNV}, {"glGetFenceivNV", (void*)glGetFenceivNV}, {"glFinishFenceNV", (void*)glFinishFenceNV}, {"glSetFenceNV", (void*)glSetFenceNV}, {"glCoverageMaskNV", (void*)glCoverageMaskNV}, {"glCoverageOperationNV", (void*)glCoverageOperationNV}, {"glGetDriverControlsQCOM", (void*)glGetDriverControlsQCOM}, {"glGetDriverControlStringQCOM", (void*)glGetDriverControlStringQCOM}, {"glEnableDriverControlQCOM", (void*)glEnableDriverControlQCOM}, {"glDisableDriverControlQCOM", (void*)glDisableDriverControlQCOM}, {"glExtGetTexturesQCOM", (void*)glExtGetTexturesQCOM}, {"glExtGetBuffersQCOM", (void*)glExtGetBuffersQCOM}, {"glExtGetRenderbuffersQCOM", (void*)glExtGetRenderbuffersQCOM}, {"glExtGetFramebuffersQCOM", (void*)glExtGetFramebuffersQCOM}, {"glExtGetTexLevelParameterivQCOM", (void*)glExtGetTexLevelParameterivQCOM}, {"glExtTexObjectStateOverrideiQCOM", (void*)glExtTexObjectStateOverrideiQCOM}, {"glExtGetTexSubImageQCOM", (void*)glExtGetTexSubImageQCOM}, {"glExtGetBufferPointervQCOM", (void*)glExtGetBufferPointervQCOM}, {"glExtGetShadersQCOM", (void*)glExtGetShadersQCOM}, {"glExtGetProgramsQCOM", (void*)glExtGetProgramsQCOM}, {"glExtIsProgramBinaryQCOM", (void*)glExtIsProgramBinaryQCOM}, {"glExtGetProgramBinarySourceQCOM", (void*)glExtGetProgramBinarySourceQCOM}, {"glStartTilingQCOM", (void*)glStartTilingQCOM}, {"glEndTilingQCOM", (void*)glEndTilingQCOM}, }; static const int gl2_num_funcs = sizeof(gl2_funcs_by_name) / sizeof(struct _gl2_funcs_by_name); #endif anbox-0.0~git20191115/android/opengl/system/GLESv2_enc/gl2_opcodes.h000066400000000000000000000203001356361734700246500ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef __GUARD_gl2_opcodes_h_ #define __GUARD_gl2_opcodes_h_ #define OP_glActiveTexture 2048 #define OP_glAttachShader 2049 #define OP_glBindAttribLocation 2050 #define OP_glBindBuffer 2051 #define OP_glBindFramebuffer 2052 #define OP_glBindRenderbuffer 2053 #define OP_glBindTexture 2054 #define OP_glBlendColor 2055 #define OP_glBlendEquation 2056 #define OP_glBlendEquationSeparate 2057 #define OP_glBlendFunc 2058 #define OP_glBlendFuncSeparate 2059 #define OP_glBufferData 2060 #define OP_glBufferSubData 2061 #define OP_glCheckFramebufferStatus 2062 #define OP_glClear 2063 #define OP_glClearColor 2064 #define OP_glClearDepthf 2065 #define OP_glClearStencil 2066 #define OP_glColorMask 2067 #define OP_glCompileShader 2068 #define OP_glCompressedTexImage2D 2069 #define OP_glCompressedTexSubImage2D 2070 #define OP_glCopyTexImage2D 2071 #define OP_glCopyTexSubImage2D 2072 #define OP_glCreateProgram 2073 #define OP_glCreateShader 2074 #define OP_glCullFace 2075 #define OP_glDeleteBuffers 2076 #define OP_glDeleteFramebuffers 2077 #define OP_glDeleteProgram 2078 #define OP_glDeleteRenderbuffers 2079 #define OP_glDeleteShader 2080 #define OP_glDeleteTextures 2081 #define OP_glDepthFunc 2082 #define OP_glDepthMask 2083 #define OP_glDepthRangef 2084 #define OP_glDetachShader 2085 #define OP_glDisable 2086 #define OP_glDisableVertexAttribArray 2087 #define OP_glDrawArrays 2088 #define OP_glDrawElements 2089 #define OP_glEnable 2090 #define OP_glEnableVertexAttribArray 2091 #define OP_glFinish 2092 #define OP_glFlush 2093 #define OP_glFramebufferRenderbuffer 2094 #define OP_glFramebufferTexture2D 2095 #define OP_glFrontFace 2096 #define OP_glGenBuffers 2097 #define OP_glGenerateMipmap 2098 #define OP_glGenFramebuffers 2099 #define OP_glGenRenderbuffers 2100 #define OP_glGenTextures 2101 #define OP_glGetActiveAttrib 2102 #define OP_glGetActiveUniform 2103 #define OP_glGetAttachedShaders 2104 #define OP_glGetAttribLocation 2105 #define OP_glGetBooleanv 2106 #define OP_glGetBufferParameteriv 2107 #define OP_glGetError 2108 #define OP_glGetFloatv 2109 #define OP_glGetFramebufferAttachmentParameteriv 2110 #define OP_glGetIntegerv 2111 #define OP_glGetProgramiv 2112 #define OP_glGetProgramInfoLog 2113 #define OP_glGetRenderbufferParameteriv 2114 #define OP_glGetShaderiv 2115 #define OP_glGetShaderInfoLog 2116 #define OP_glGetShaderPrecisionFormat 2117 #define OP_glGetShaderSource 2118 #define OP_glGetString 2119 #define OP_glGetTexParameterfv 2120 #define OP_glGetTexParameteriv 2121 #define OP_glGetUniformfv 2122 #define OP_glGetUniformiv 2123 #define OP_glGetUniformLocation 2124 #define OP_glGetVertexAttribfv 2125 #define OP_glGetVertexAttribiv 2126 #define OP_glGetVertexAttribPointerv 2127 #define OP_glHint 2128 #define OP_glIsBuffer 2129 #define OP_glIsEnabled 2130 #define OP_glIsFramebuffer 2131 #define OP_glIsProgram 2132 #define OP_glIsRenderbuffer 2133 #define OP_glIsShader 2134 #define OP_glIsTexture 2135 #define OP_glLineWidth 2136 #define OP_glLinkProgram 2137 #define OP_glPixelStorei 2138 #define OP_glPolygonOffset 2139 #define OP_glReadPixels 2140 #define OP_glReleaseShaderCompiler 2141 #define OP_glRenderbufferStorage 2142 #define OP_glSampleCoverage 2143 #define OP_glScissor 2144 #define OP_glShaderBinary 2145 #define OP_glShaderSource 2146 #define OP_glStencilFunc 2147 #define OP_glStencilFuncSeparate 2148 #define OP_glStencilMask 2149 #define OP_glStencilMaskSeparate 2150 #define OP_glStencilOp 2151 #define OP_glStencilOpSeparate 2152 #define OP_glTexImage2D 2153 #define OP_glTexParameterf 2154 #define OP_glTexParameterfv 2155 #define OP_glTexParameteri 2156 #define OP_glTexParameteriv 2157 #define OP_glTexSubImage2D 2158 #define OP_glUniform1f 2159 #define OP_glUniform1fv 2160 #define OP_glUniform1i 2161 #define OP_glUniform1iv 2162 #define OP_glUniform2f 2163 #define OP_glUniform2fv 2164 #define OP_glUniform2i 2165 #define OP_glUniform2iv 2166 #define OP_glUniform3f 2167 #define OP_glUniform3fv 2168 #define OP_glUniform3i 2169 #define OP_glUniform3iv 2170 #define OP_glUniform4f 2171 #define OP_glUniform4fv 2172 #define OP_glUniform4i 2173 #define OP_glUniform4iv 2174 #define OP_glUniformMatrix2fv 2175 #define OP_glUniformMatrix3fv 2176 #define OP_glUniformMatrix4fv 2177 #define OP_glUseProgram 2178 #define OP_glValidateProgram 2179 #define OP_glVertexAttrib1f 2180 #define OP_glVertexAttrib1fv 2181 #define OP_glVertexAttrib2f 2182 #define OP_glVertexAttrib2fv 2183 #define OP_glVertexAttrib3f 2184 #define OP_glVertexAttrib3fv 2185 #define OP_glVertexAttrib4f 2186 #define OP_glVertexAttrib4fv 2187 #define OP_glVertexAttribPointer 2188 #define OP_glViewport 2189 #define OP_glEGLImageTargetTexture2DOES 2190 #define OP_glEGLImageTargetRenderbufferStorageOES 2191 #define OP_glGetProgramBinaryOES 2192 #define OP_glProgramBinaryOES 2193 #define OP_glMapBufferOES 2194 #define OP_glUnmapBufferOES 2195 #define OP_glTexImage3DOES 2196 #define OP_glTexSubImage3DOES 2197 #define OP_glCopyTexSubImage3DOES 2198 #define OP_glCompressedTexImage3DOES 2199 #define OP_glCompressedTexSubImage3DOES 2200 #define OP_glFramebufferTexture3DOES 2201 #define OP_glBindVertexArrayOES 2202 #define OP_glDeleteVertexArraysOES 2203 #define OP_glGenVertexArraysOES 2204 #define OP_glIsVertexArrayOES 2205 #define OP_glDiscardFramebufferEXT 2206 #define OP_glMultiDrawArraysEXT 2207 #define OP_glMultiDrawElementsEXT 2208 #define OP_glGetPerfMonitorGroupsAMD 2209 #define OP_glGetPerfMonitorCountersAMD 2210 #define OP_glGetPerfMonitorGroupStringAMD 2211 #define OP_glGetPerfMonitorCounterStringAMD 2212 #define OP_glGetPerfMonitorCounterInfoAMD 2213 #define OP_glGenPerfMonitorsAMD 2214 #define OP_glDeletePerfMonitorsAMD 2215 #define OP_glSelectPerfMonitorCountersAMD 2216 #define OP_glBeginPerfMonitorAMD 2217 #define OP_glEndPerfMonitorAMD 2218 #define OP_glGetPerfMonitorCounterDataAMD 2219 #define OP_glRenderbufferStorageMultisampleIMG 2220 #define OP_glFramebufferTexture2DMultisampleIMG 2221 #define OP_glDeleteFencesNV 2222 #define OP_glGenFencesNV 2223 #define OP_glIsFenceNV 2224 #define OP_glTestFenceNV 2225 #define OP_glGetFenceivNV 2226 #define OP_glFinishFenceNV 2227 #define OP_glSetFenceNV 2228 #define OP_glCoverageMaskNV 2229 #define OP_glCoverageOperationNV 2230 #define OP_glGetDriverControlsQCOM 2231 #define OP_glGetDriverControlStringQCOM 2232 #define OP_glEnableDriverControlQCOM 2233 #define OP_glDisableDriverControlQCOM 2234 #define OP_glExtGetTexturesQCOM 2235 #define OP_glExtGetBuffersQCOM 2236 #define OP_glExtGetRenderbuffersQCOM 2237 #define OP_glExtGetFramebuffersQCOM 2238 #define OP_glExtGetTexLevelParameterivQCOM 2239 #define OP_glExtTexObjectStateOverrideiQCOM 2240 #define OP_glExtGetTexSubImageQCOM 2241 #define OP_glExtGetBufferPointervQCOM 2242 #define OP_glExtGetShadersQCOM 2243 #define OP_glExtGetProgramsQCOM 2244 #define OP_glExtIsProgramBinaryQCOM 2245 #define OP_glExtGetProgramBinarySourceQCOM 2246 #define OP_glStartTilingQCOM 2247 #define OP_glEndTilingQCOM 2248 #define OP_glVertexAttribPointerData 2249 #define OP_glVertexAttribPointerOffset 2250 #define OP_glDrawElementsOffset 2251 #define OP_glDrawElementsData 2252 #define OP_glGetCompressedTextureFormats 2253 #define OP_glShaderString 2254 #define OP_glFinishRoundTrip 2255 #define OP_last 2256 #endif anbox-0.0~git20191115/android/opengl/system/GLESv2_enc/gl2_types.h000066400000000000000000000013031356361734700243620ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _GL_2_TYPES_H_ #define _GL_2_TYPES_H_ #include "gl_base_types.h" typedef void *GLvoidptr; #endif anbox-0.0~git20191115/android/opengl/system/OpenglSystemCommon/000077500000000000000000000000001356361734700242575ustar00rootroot00000000000000anbox-0.0~git20191115/android/opengl/system/OpenglSystemCommon/Android.mk000066400000000000000000000005261356361734700261730ustar00rootroot00000000000000LOCAL_PATH := $(call my-dir) $(call emugl-begin-shared-library,libOpenglSystemCommon) $(call emugl-import,libGLESv1_enc libGLESv2_enc lib_renderControl_enc) LOCAL_SRC_FILES := \ HostConnection.cpp \ QemuPipeStream.cpp \ ThreadInfo.cpp $(call emugl-export,C_INCLUDES,$(LOCAL_PATH) bionic/libc/private) $(call emugl-end-module) anbox-0.0~git20191115/android/opengl/system/OpenglSystemCommon/EGLClientIface.h000066400000000000000000000025001356361734700271230ustar00rootroot00000000000000/* * Copyright 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _SYSTEM_COMMON_EGL_CLIENT_IFACE_H #define _SYSTEM_COMMON_EGL_CLIENT_IFACE_H struct EGLThreadInfo; // defined in ThreadInfo.h typedef struct { EGLThreadInfo* (*getThreadInfo)(); const char* (*getGLString)(int glEnum); } EGLClient_eglInterface; typedef struct { void* (*getProcAddress)(const char *funcName); void (*init)(); void (*finish)(); } EGLClient_glesInterface; // // Any GLES/GLES2 client API library should define a function named "init_emul_gles" // with the following prototype, // It will be called by EGL after loading the GLES library for initialization // and exchanging interface function pointers. // typedef EGLClient_glesInterface *(*init_emul_gles_t)(EGLClient_eglInterface *eglIface); #endif anbox-0.0~git20191115/android/opengl/system/OpenglSystemCommon/EGLImage.h000066400000000000000000000016421356361734700260050ustar00rootroot00000000000000/* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __COMMON_EGL_IMAGE_H #define __COMMON_EGL_IMAGE_H #include #include #include #include struct EGLImage_t { EGLDisplay dpy; EGLenum target; union { android_native_buffer_t *native_buffer; uint32_t host_egl_image; }; }; #endif anbox-0.0~git20191115/android/opengl/system/OpenglSystemCommon/HostConnection.cpp000066400000000000000000000132611356361734700277230ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "HostConnection.h" #include "TcpStream.h" #include "QemuPipeStream.h" #include "ThreadInfo.h" #include #include "GLEncoder.h" #include "GL2Encoder.h" #include #define STREAM_BUFFER_SIZE 4*1024*1024 #define STREAM_PORT_NUM 22468 /* Set to 1 to use a QEMU pipe, or 0 for a TCP connection */ #define USE_QEMU_PIPE 1 HostConnection::HostConnection() : m_stream(NULL), m_glEnc(NULL), m_gl2Enc(NULL), m_rcEnc(NULL), m_checksumHelper() { } HostConnection::~HostConnection() { delete m_stream; delete m_glEnc; delete m_gl2Enc; delete m_rcEnc; } HostConnection *HostConnection::get() { /* TODO: Make this configurable with a system property */ const int useQemuPipe = USE_QEMU_PIPE; // Get thread info EGLThreadInfo *tinfo = getEGLThreadInfo(); if (!tinfo) { return NULL; } if (tinfo->hostConn == NULL) { HostConnection *con = new HostConnection(); if (NULL == con) { return NULL; } if (useQemuPipe) { QemuPipeStream *stream = new QemuPipeStream(STREAM_BUFFER_SIZE); if (!stream) { ALOGE("Failed to create QemuPipeStream for host connection!!!\n"); delete con; return NULL; } if (stream->connect() < 0) { ALOGE("Failed to connect to host (QemuPipeStream)!!!\n"); delete stream; delete con; return NULL; } con->m_stream = stream; } else /* !useQemuPipe */ { TcpStream *stream = new TcpStream(STREAM_BUFFER_SIZE); if (!stream) { ALOGE("Failed to create TcpStream for host connection!!!\n"); delete con; return NULL; } if (stream->connect("10.0.2.2", STREAM_PORT_NUM) < 0) { ALOGE("Failed to connect to host (TcpStream)!!!\n"); delete stream; delete con; return NULL; } con->m_stream = stream; } // send zero 'clientFlags' to the host. unsigned int *pClientFlags = (unsigned int *)con->m_stream->allocBuffer(sizeof(unsigned int)); *pClientFlags = 0; con->m_stream->commitBuffer(sizeof(unsigned int)); ALOGD("HostConnection::get() New Host Connection established %p, tid %d\n", con, gettid()); tinfo->hostConn = con; } return tinfo->hostConn; } GLEncoder *HostConnection::glEncoder() { if (!m_glEnc) { m_glEnc = new GLEncoder(m_stream, checksumHelper()); DBG("HostConnection::glEncoder new encoder %p, tid %d", m_glEnc, gettid()); m_glEnc->setContextAccessor(s_getGLContext); } return m_glEnc; } GL2Encoder *HostConnection::gl2Encoder() { if (!m_gl2Enc) { m_gl2Enc = new GL2Encoder(m_stream, checksumHelper()); DBG("HostConnection::gl2Encoder new encoder %p, tid %d", m_gl2Enc, gettid()); m_gl2Enc->setContextAccessor(s_getGL2Context); } return m_gl2Enc; } renderControl_encoder_context_t *HostConnection::rcEncoder() { if (!m_rcEnc) { m_rcEnc = new renderControl_encoder_context_t(m_stream, checksumHelper()); // TODO: disable checksum as a workaround in a glTexSubImage2D problem // Uncomment the following line when the root cause is solved //setChecksumHelper(m_rcEnc); } return m_rcEnc; } gl_client_context_t *HostConnection::s_getGLContext() { EGLThreadInfo *ti = getEGLThreadInfo(); if (ti->hostConn) { return ti->hostConn->m_glEnc; } return NULL; } gl2_client_context_t *HostConnection::s_getGL2Context() { EGLThreadInfo *ti = getEGLThreadInfo(); if (ti->hostConn) { return ti->hostConn->m_gl2Enc; } return NULL; } void HostConnection::setChecksumHelper(renderControl_encoder_context_t *rcEnc) { std::unique_ptr glExtensions; int extensionSize = rcEnc->rcGetGLString(rcEnc, GL_EXTENSIONS, NULL, 0); if (extensionSize < 0) { glExtensions = std::unique_ptr(new char[-extensionSize]); extensionSize = rcEnc->rcGetGLString(rcEnc, GL_EXTENSIONS, glExtensions.get(), -extensionSize); if (extensionSize <= 0) { glExtensions.reset(); } } // check the host supported version uint32_t checksumVersion = 0; const char* checksumPrefix = ChecksumCalculator::getMaxVersionStrPrefix(); const char* glProtocolStr = glExtensions.get() ? strstr(glExtensions.get(), checksumPrefix) : NULL; if (glProtocolStr) { uint32_t maxVersion = ChecksumCalculator::getMaxVersion(); sscanf(glProtocolStr+strlen(checksumPrefix), "%d", &checksumVersion); if (maxVersion < checksumVersion) { checksumVersion = maxVersion; } // The ordering of the following two commands matters! // Must tell the host first before setting it in the guest rcEnc->rcSelectChecksumCalculator(rcEnc, checksumVersion, 0); m_checksumHelper.setVersion(checksumVersion); } } anbox-0.0~git20191115/android/opengl/system/OpenglSystemCommon/HostConnection.h000066400000000000000000000032621356361734700273700ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __COMMON_HOST_CONNECTION_H #define __COMMON_HOST_CONNECTION_H #include "IOStream.h" #include "renderControl_enc.h" #include "ChecksumCalculator.h" class GLEncoder; class gl_client_context_t; class GL2Encoder; class gl2_client_context_t; class HostConnection { public: static HostConnection *get(); ~HostConnection(); GLEncoder *glEncoder(); GL2Encoder *gl2Encoder(); renderControl_encoder_context_t *rcEncoder(); ChecksumCalculator *checksumHelper() { return &m_checksumHelper; } void flush() { if (m_stream) { m_stream->flush(); } } private: HostConnection(); static gl_client_context_t *s_getGLContext(); static gl2_client_context_t *s_getGL2Context(); // setProtocol initilizes GL communication protocol for checksums // should be called when m_rcEnc is created void setChecksumHelper(renderControl_encoder_context_t *rcEnc); private: IOStream *m_stream; GLEncoder *m_glEnc; GL2Encoder *m_gl2Enc; renderControl_encoder_context_t *m_rcEnc; ChecksumCalculator m_checksumHelper; }; #endif anbox-0.0~git20191115/android/opengl/system/OpenglSystemCommon/QemuPipeStream.cpp000066400000000000000000000126131356361734700276670ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "QemuPipeStream.h" #include #include #include #include #include #include QemuPipeStream::QemuPipeStream(size_t bufSize) : IOStream(bufSize), m_sock(-1), m_bufsize(bufSize), m_buf(NULL) { } QemuPipeStream::QemuPipeStream(int sock, size_t bufSize) : IOStream(bufSize), m_sock(sock), m_bufsize(bufSize), m_buf(NULL) { } QemuPipeStream::~QemuPipeStream() { if (m_sock >= 0) { flush(); ::close(m_sock); } if (m_buf != NULL) { free(m_buf); } } int QemuPipeStream::connect(void) { m_sock = qemu_pipe_open("opengles"); if (!valid()) return -1; return 0; } void *QemuPipeStream::allocBuffer(size_t minSize) { size_t allocSize = (m_bufsize < minSize ? minSize : m_bufsize); if (!m_buf) { m_buf = (unsigned char *)malloc(allocSize); } else if (m_bufsize < allocSize) { unsigned char *p = (unsigned char *)realloc(m_buf, allocSize); if (p != NULL) { m_buf = p; m_bufsize = allocSize; } else { ERR("realloc (%d) failed\n", allocSize); free(m_buf); m_buf = NULL; m_bufsize = 0; } } return m_buf; }; int QemuPipeStream::commitBuffer(size_t size) { return writeFully(m_buf, size); } int QemuPipeStream::writeFully(const void *buf, size_t len) { //DBG(">> QemuPipeStream::writeFully %d\n", len); if (!valid()) return -1; if (!buf) { if (len>0) { // If len is non-zero, buf must not be NULL. Otherwise the pipe would be // in a corrupted state, which is lethal for the emulator. ERR("QemuPipeStream::writeFully failed, buf=NULL, len %d," " lethal error, exiting", len); abort(); } return 0; } size_t res = len; int retval = 0; while (res > 0) { ssize_t stat = ::write(m_sock, (const char *)(buf) + (len - res), res); if (stat > 0) { res -= stat; continue; } if (stat == 0) { /* EOF */ ERR("QemuPipeStream::writeFully failed: premature EOF\n"); retval = -1; break; } if (errno == EINTR) { continue; } retval = stat; ERR("QemuPipeStream::writeFully failed: %s, lethal error, exiting.\n", strerror(errno)); abort(); } //DBG("<< QemuPipeStream::writeFully %d\n", len ); return retval; } const unsigned char *QemuPipeStream::readFully(void *buf, size_t len) { //DBG(">> QemuPipeStream::readFully %d\n", len); if (!valid()) return NULL; if (!buf) { if (len > 0) { // If len is non-zero, buf must not be NULL. Otherwise the pipe would be // in a corrupted state, which is lethal for the emulator. ERR("QemuPipeStream::readFully failed, buf=NULL, len %zu, lethal" " error, exiting.", len); abort(); } return NULL; // do not allow NULL buf in that implementation } size_t res = len; while (res > 0) { ssize_t stat = ::read(m_sock, (char *)(buf) + len - res, res); if (stat == 0) { // client shutdown; return NULL; } else if (stat < 0) { if (errno == EINTR) { continue; } else { ERR("QemuPipeStream::readFully failed (buf %p, len %zu" ", res %zu): %s, lethal error, exiting.", buf, len, res, strerror(errno)); abort(); } } else { res -= stat; } } //DBG("<< QemuPipeStream::readFully %d\n", len); return (const unsigned char *)buf; } const unsigned char *QemuPipeStream::read( void *buf, size_t *inout_len) { //DBG(">> QemuPipeStream::read %d\n", *inout_len); if (!valid()) return NULL; if (!buf) { ERR("QemuPipeStream::read failed, buf=NULL"); return NULL; // do not allow NULL buf in that implementation } int n = recv(buf, *inout_len); if (n > 0) { *inout_len = n; return (const unsigned char *)buf; } //DBG("<< QemuPipeStream::read %d\n", *inout_len); return NULL; } int QemuPipeStream::recv(void *buf, size_t len) { if (!valid()) return int(ERR_INVALID_SOCKET); char* p = (char *)buf; int ret = 0; while(len > 0) { int res = ::read(m_sock, p, len); if (res > 0) { p += res; ret += res; len -= res; continue; } if (res == 0) { /* EOF */ break; } if (errno == EINTR) continue; /* A real error */ if (ret == 0) ret = -1; break; } return ret; } anbox-0.0~git20191115/android/opengl/system/OpenglSystemCommon/QemuPipeStream.h000066400000000000000000000030671356361734700273370ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __QEMU_PIPE_STREAM_H #define __QEMU_PIPE_STREAM_H /* This file implements an IOStream that uses a QEMU fast-pipe * to communicate with the emulator's 'opengles' service. See * for more details. */ #include #include "IOStream.h" class QemuPipeStream : public IOStream { public: typedef enum { ERR_INVALID_SOCKET = -1000 } QemuPipeStreamError; explicit QemuPipeStream(size_t bufsize = 10000); ~QemuPipeStream(); int connect(void); virtual void *allocBuffer(size_t minSize); virtual int commitBuffer(size_t size); virtual const unsigned char *readFully( void *buf, size_t len); virtual const unsigned char *read( void *buf, size_t *inout_len); bool valid() { return m_sock >= 0; } int recv(void *buf, size_t len); virtual int writeFully(const void *buf, size_t len); private: int m_sock; size_t m_bufsize; unsigned char *m_buf; QemuPipeStream(int sock, size_t bufSize); }; #endif anbox-0.0~git20191115/android/opengl/system/OpenglSystemCommon/ThreadInfo.cpp000066400000000000000000000021721356361734700270100ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "ThreadInfo.h" #include "cutils/threads.h" thread_store_t s_tls = THREAD_STORE_INITIALIZER; static void tlsDestruct(void *ptr) { if (ptr) { EGLThreadInfo *ti = (EGLThreadInfo *)ptr; delete ti->hostConn; delete ti; ((void **)__get_tls())[TLS_SLOT_OPENGL] = NULL; } } EGLThreadInfo *slow_getEGLThreadInfo() { EGLThreadInfo *ti = (EGLThreadInfo *)thread_store_get(&s_tls); if (ti) return ti; ti = new EGLThreadInfo(); thread_store_set(&s_tls, ti, tlsDestruct); return ti; } anbox-0.0~git20191115/android/opengl/system/OpenglSystemCommon/ThreadInfo.h000066400000000000000000000030241356361734700264520ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _THREAD_INFO_H #define _THREAD_INFO_H #include "HostConnection.h" #include #ifdef __ANDROID__ #include #endif struct EGLContext_t; struct EGLThreadInfo { EGLThreadInfo() : currentContext(NULL), hostConn(NULL), eglError(EGL_SUCCESS) {} EGLContext_t *currentContext; HostConnection *hostConn; int eglError; }; EGLThreadInfo *slow_getEGLThreadInfo(); #ifdef __ANDROID__ // We have a dedicated TLS slot in bionic inline EGLThreadInfo* getEGLThreadInfo() { EGLThreadInfo *tInfo = (EGLThreadInfo *)(((uintptr_t *)__get_tls())[TLS_SLOT_OPENGL]); if (!tInfo) { tInfo = slow_getEGLThreadInfo(); ((uintptr_t *)__get_tls())[TLS_SLOT_OPENGL] = (uintptr_t)tInfo; } return tInfo; } #else inline EGLThreadInfo* getEGLThreadInfo() { return slow_getEGLThreadInfo(); } #endif #endif // of _THREAD_INFO_H anbox-0.0~git20191115/android/opengl/system/OpenglSystemCommon/gralloc_cb.h000066400000000000000000000072341356361734700265250ustar00rootroot00000000000000/* * Copyright 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __GRALLOC_CB_H__ #define __GRALLOC_CB_H__ #include #include #include #define BUFFER_HANDLE_MAGIC ((int)0xabfabfab) #define CB_HANDLE_NUM_INTS(nfds) (int)((sizeof(cb_handle_t) - (nfds)*sizeof(int)) / sizeof(int)) // // Our buffer handle structure // struct cb_handle_t : public native_handle { cb_handle_t(int p_fd, int p_ashmemSize, int p_usage, int p_width, int p_height, int p_frameworkFormat, int p_format, int p_glFormat, int p_glType) : fd(p_fd), magic(BUFFER_HANDLE_MAGIC), usage(p_usage), width(p_width), height(p_height), frameworkFormat(p_frameworkFormat), format(p_format), glFormat(p_glFormat), glType(p_glType), ashmemSize(p_ashmemSize), ashmemBase(0), ashmemBasePid(0), mappedPid(0), lockedLeft(0), lockedTop(0), lockedWidth(0), lockedHeight(0), hostHandle(0) { version = sizeof(native_handle); numFds = 0; numInts = CB_HANDLE_NUM_INTS(numFds); } ~cb_handle_t() { magic = 0; } void setFd(int p_fd) { if (p_fd >= 0) { numFds = 1; } else { numFds = 0; } fd = p_fd; numInts = CB_HANDLE_NUM_INTS(numFds); } static bool validate(const cb_handle_t* hnd) { return (hnd && hnd->version == sizeof(native_handle) && hnd->magic == BUFFER_HANDLE_MAGIC && hnd->numInts == CB_HANDLE_NUM_INTS(hnd->numFds)); } bool canBePosted() { return (0 != (usage & GRALLOC_USAGE_HW_FB)); } // file-descriptors int fd; // ashmem fd (-1 of ashmem region did not allocated, i.e. no SW access needed) // ints int magic; // magic number in order to validate a pointer to be a cb_handle_t int usage; // usage bits the buffer was created with int width; // buffer width int height; // buffer height int frameworkFormat; // format requested by the Android framework int format; // real internal pixel format format int glFormat; // OpenGL format enum used for host h/w color buffer int glType; // OpenGL type enum used when uploading to host int ashmemSize; // ashmem region size for the buffer (0 unless is HW_FB buffer or // s/w access is needed) union { intptr_t ashmemBase; // CPU address of the mapped ashmem region uint64_t padding; // enforce same size on 32-bit/64-bit } __attribute__((aligned(8))); int ashmemBasePid; // process id which mapped the ashmem region int mappedPid; // process id which succeeded gralloc_register call int lockedLeft; // region of buffer locked for s/w write int lockedTop; int lockedWidth; int lockedHeight; uint32_t hostHandle; }; #endif //__GRALLOC_CB_H__ anbox-0.0~git20191115/android/opengl/system/egl/000077500000000000000000000000001356361734700212245ustar00rootroot00000000000000anbox-0.0~git20191115/android/opengl/system/egl/Android.mk000066400000000000000000000023351356361734700231400ustar00rootroot00000000000000ifneq (false,$(BUILD_EMULATOR_OPENGL_DRIVER)) LOCAL_PATH := $(call my-dir) $(call emugl-begin-shared-library,libEGL_emulation) $(call emugl-import,libOpenglSystemCommon) $(call emugl-set-shared-library-subpath,egl) LOCAL_CFLAGS += -DLOG_TAG=\"EGL_emulation\" -DEGL_EGLEXT_PROTOTYPES -DWITH_GLES2 LOCAL_SRC_FILES := \ eglDisplay.cpp \ egl.cpp \ ClientAPIExts.cpp LOCAL_SHARED_LIBRARIES += libdl # Used to access the Bionic private OpenGL TLS slot LOCAL_C_INCLUDES += bionic/libc/private $(call emugl-end-module) #### egl.cfg #### # Ensure that this file is only copied to emulator-specific builds. # Other builds are device-specific and will provide their own # version of this file to point to the appropriate HW EGL libraries. # ifneq (,$(filter aosp_arm aosp_x86 aosp_mips full full_x86 full_mips sdk sdk_x86 sdk_mips google_sdk google_sdk_x86 google_sdk_mips,$(TARGET_PRODUCT))) include $(CLEAR_VARS) LOCAL_MODULE := egl.cfg LOCAL_SRC_FILES := $(LOCAL_MODULE) LOCAL_MODULE_PATH := $(TARGET_OUT)/lib/egl LOCAL_MODULE_CLASS := ETC include $(BUILD_PREBUILT) endif # TARGET_PRODUCT in 'full full_x86 full_mips sdk sdk_x86 sdk_mips google_sdk google_sdk_x86 google_sdk_mips') endif # BUILD_EMULATOR_OPENGL_DRIVER != false anbox-0.0~git20191115/android/opengl/system/egl/ClientAPIExts.cpp000066400000000000000000000104401356361734700243430ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "ClientAPIExts.h" #include "ThreadInfo.h" #include #include #include "eglContext.h" namespace ClientAPIExts { // // define function pointer type for each extention function // typename has the form __egl_{funcname}_t // #define FUNC_TYPE(fname) __egl_ ## fname ## _t #define API_ENTRY(fname,params,args) \ typedef void (GL_APIENTRY *FUNC_TYPE(fname)) params; #define API_ENTRY_RET(rtype,fname,params,args) \ typedef rtype (GL_APIENTRY *FUNC_TYPE(fname)) params; #include "ClientAPIExts.in" #undef API_ENTRY #undef API_ENTRY_RET ///// // Define static table to store the function value for each // client API. functions pointers will get initialized through // ClientAPIExts::initClientFuncs function after each client API has been // loaded. ///// #define API_ENTRY(fname,params,args) \ FUNC_TYPE(fname) fname; #define API_ENTRY_RET(rtype,fname,params,args) \ API_ENTRY(fname,params,args) static struct _ext_table { #include "ClientAPIExts.in" } s_client_extensions[2]; #undef API_ENTRY #undef API_ENTRY_RET // // This function initialized each entry in the s_client_extensions // struct at the givven index using the givven client interface // void initClientFuncs(const EGLClient_glesInterface *iface, int idx) { #define API_ENTRY(fname,params,args) \ s_client_extensions[idx].fname = \ (FUNC_TYPE(fname))iface->getProcAddress(#fname); #define API_ENTRY_RET(rtype,fname,params,args) \ API_ENTRY(fname,params,args) // // reset all func pointers to NULL // memset(&s_client_extensions[idx], 0, sizeof(struct _ext_table)); // // And now query the GLES library for each proc address // #include "ClientAPIExts.in" #undef API_ENTRY #undef API_ENTRY_RET } // // Define implementation for each extension function which checks // the current context version and calls to the correct client API // function. // #define API_ENTRY(fname,params,args) \ static void _egl_ ## fname params \ { \ EGLThreadInfo* thread = getEGLThreadInfo(); \ if (!thread->currentContext) { \ return; \ } \ int idx = (int)thread->currentContext->version - 1; \ if (!s_client_extensions[idx].fname) { \ return; \ } \ (*s_client_extensions[idx].fname) args; \ } #define API_ENTRY_RET(rtype,fname,params,args) \ static rtype _egl_ ## fname params \ { \ EGLThreadInfo* thread = getEGLThreadInfo(); \ if (!thread->currentContext) { \ return (rtype)0; \ } \ int idx = (int)thread->currentContext->version - 1; \ if (!s_client_extensions[idx].fname) { \ return (rtype)0; \ } \ return (*s_client_extensions[idx].fname) args; \ } #include "ClientAPIExts.in" #undef API_ENTRY #undef API_ENTRY_RET // // Define a table to map function names to the local _egl_ version of // the extension function, to be used in eglGetProcAddress. // #define API_ENTRY(fname,params,args) \ { #fname, (void*)_egl_ ## fname}, #define API_ENTRY_RET(rtype,fname,params,args) \ API_ENTRY(fname,params,args) static const struct _client_ext_funcs { const char *fname; void* proc; } s_client_ext_funcs[] = { #include "ClientAPIExts.in" }; static const int numExtFuncs = sizeof(s_client_ext_funcs) / sizeof(s_client_ext_funcs[0]); #undef API_ENTRY #undef API_ENTRY_RET // // returns the __egl_ version of the givven extension function name. // void* getProcAddress(const char *fname) { for (int i=0; i #include "gralloc_cb.h" #include "GLClientState.h" #include "GLSharedGroup.h" #include "eglContext.h" #include "ClientAPIExts.h" #include "EGLImage.h" #include "GLEncoder.h" #ifdef WITH_GLES2 #include "GL2Encoder.h" #endif #include template static T setErrorFunc(GLint error, T returnValue) { getEGLThreadInfo()->eglError = error; return returnValue; } const char * eglStrError(EGLint err) { switch (err){ case EGL_SUCCESS: return "EGL_SUCCESS"; case EGL_NOT_INITIALIZED: return "EGL_NOT_INITIALIZED"; case EGL_BAD_ACCESS: return "EGL_BAD_ACCESS"; case EGL_BAD_ALLOC: return "EGL_BAD_ALLOC"; case EGL_BAD_ATTRIBUTE: return "EGL_BAD_ATTRIBUTE"; case EGL_BAD_CONFIG: return "EGL_BAD_CONFIG"; case EGL_BAD_CONTEXT: return "EGL_BAD_CONTEXT"; case EGL_BAD_CURRENT_SURFACE: return "EGL_BAD_CURRENT_SURFACE"; case EGL_BAD_DISPLAY: return "EGL_BAD_DISPLAY"; case EGL_BAD_MATCH: return "EGL_BAD_MATCH"; case EGL_BAD_NATIVE_PIXMAP: return "EGL_BAD_NATIVE_PIXMAP"; case EGL_BAD_NATIVE_WINDOW: return "EGL_BAD_NATIVE_WINDOW"; case EGL_BAD_PARAMETER: return "EGL_BAD_PARAMETER"; case EGL_BAD_SURFACE: return "EGL_BAD_SURFACE"; case EGL_CONTEXT_LOST: return "EGL_CONTEXT_LOST"; default: return "UNKNOWN"; } } #define LOG_EGL_ERRORS 1 #ifdef LOG_EGL_ERRORS #define setErrorReturn(error, retVal) \ { \ ALOGE("tid %d: %s(%d): error 0x%x (%s)", gettid(), __FUNCTION__, __LINE__, error, eglStrError(error)); \ return setErrorFunc(error, retVal); \ } #define RETURN_ERROR(ret,err) \ ALOGE("tid %d: %s(%d): error 0x%x (%s)", gettid(), __FUNCTION__, __LINE__, err, eglStrError(err)); \ getEGLThreadInfo()->eglError = err; \ return ret; #else //!LOG_EGL_ERRORS #define setErrorReturn(error, retVal) return setErrorFunc(error, retVal); #define RETURN_ERROR(ret,err) \ getEGLThreadInfo()->eglError = err; \ return ret; #endif //LOG_EGL_ERRORS #define VALIDATE_CONFIG(cfg,ret) \ if(((intptr_t)cfg<0)||((intptr_t)cfg>s_display.getNumConfigs())) { \ RETURN_ERROR(ret,EGL_BAD_CONFIG); \ } #define VALIDATE_DISPLAY(dpy,ret) \ if ((dpy) != (EGLDisplay)&s_display) { \ RETURN_ERROR(ret, EGL_BAD_DISPLAY); \ } #define VALIDATE_DISPLAY_INIT(dpy,ret) \ VALIDATE_DISPLAY(dpy, ret) \ if (!s_display.initialized()) { \ RETURN_ERROR(ret, EGL_NOT_INITIALIZED); \ } #define DEFINE_HOST_CONNECTION \ HostConnection *hostCon = HostConnection::get(); \ renderControl_encoder_context_t *rcEnc = (hostCon ? hostCon->rcEncoder() : NULL) #define DEFINE_AND_VALIDATE_HOST_CONNECTION(ret) \ HostConnection *hostCon = HostConnection::get(); \ if (!hostCon) { \ ALOGE("egl: Failed to get host connection\n"); \ return ret; \ } \ renderControl_encoder_context_t *rcEnc = hostCon->rcEncoder(); \ if (!rcEnc) { \ ALOGE("egl: Failed to get renderControl encoder context\n"); \ return ret; \ } #define VALIDATE_CONTEXT_RETURN(context,ret) \ if (!context) { \ RETURN_ERROR(ret,EGL_BAD_CONTEXT); \ } #define VALIDATE_SURFACE_RETURN(surface, ret) \ if (surface != EGL_NO_SURFACE) { \ egl_surface_t* s( static_cast(surface) ); \ if (s->dpy != (EGLDisplay)&s_display) \ setErrorReturn(EGL_BAD_DISPLAY, EGL_FALSE); \ } EGLContext_t::EGLContext_t(EGLDisplay dpy, EGLConfig config, EGLContext_t* shareCtx) : dpy(dpy), config(config), read(EGL_NO_SURFACE), draw(EGL_NO_SURFACE), shareCtx(shareCtx), rcContext(0), versionString(NULL), vendorString(NULL), rendererString(NULL), shaderVersionString(NULL), extensionString(NULL), deletePending(0) { flags = 0; version = 1; clientState = new GLClientState(); if (shareCtx) sharedGroup = shareCtx->getSharedGroup(); else sharedGroup = GLSharedGroupPtr(new GLSharedGroup()); }; EGLContext_t::~EGLContext_t() { delete clientState; delete [] versionString; delete [] vendorString; delete [] rendererString; delete [] shaderVersionString; delete [] extensionString; } // ---------------------------------------------------------------------------- //egl_surface_t //we don't need to handle depth since it's handled when window created on the host struct egl_surface_t { EGLDisplay dpy; EGLConfig config; egl_surface_t(EGLDisplay dpy, EGLConfig config, EGLint surfaceType); virtual ~egl_surface_t(); virtual void setSwapInterval(int interval) = 0; virtual EGLBoolean swapBuffers() = 0; EGLint getSwapBehavior() const; uint32_t getRcSurface() { return rcSurface; } EGLint getSurfaceType() { return surfaceType; } EGLint getWidth(){ return width; } EGLint getHeight(){ return height; } void setTextureFormat(EGLint _texFormat) { texFormat = _texFormat; } EGLint getTextureFormat() { return texFormat; } void setTextureTarget(EGLint _texTarget) { texTarget = _texTarget; } EGLint getTextureTarget() { return texTarget; } private: // //Surface attributes // EGLint width; EGLint height; EGLint texFormat; EGLint texTarget; protected: void setWidth(EGLint w) { width = w; } void setHeight(EGLint h) { height = h; } EGLint surfaceType; uint32_t rcSurface; //handle to surface created via remote control }; egl_surface_t::egl_surface_t(EGLDisplay dpy, EGLConfig config, EGLint surfaceType) : dpy(dpy), config(config), surfaceType(surfaceType), rcSurface(0) { width = 0; height = 0; texFormat = EGL_NO_TEXTURE; texTarget = EGL_NO_TEXTURE; } EGLint egl_surface_t::getSwapBehavior() const { return EGL_BUFFER_PRESERVED; } egl_surface_t::~egl_surface_t() { } // ---------------------------------------------------------------------------- // egl_window_surface_t struct egl_window_surface_t : public egl_surface_t { static egl_window_surface_t* create( EGLDisplay dpy, EGLConfig config, EGLint surfType, ANativeWindow* window); virtual ~egl_window_surface_t(); virtual void setSwapInterval(int interval); virtual EGLBoolean swapBuffers(); private: egl_window_surface_t( EGLDisplay dpy, EGLConfig config, EGLint surfType, ANativeWindow* window); EGLBoolean init(); ANativeWindow* nativeWindow; android_native_buffer_t* buffer; }; egl_window_surface_t::egl_window_surface_t ( EGLDisplay dpy, EGLConfig config, EGLint surfType, ANativeWindow* window) : egl_surface_t(dpy, config, surfType), nativeWindow(window), buffer(NULL) { // keep a reference on the window nativeWindow->common.incRef(&nativeWindow->common); } EGLBoolean egl_window_surface_t::init() { if (nativeWindow->dequeueBuffer_DEPRECATED(nativeWindow, &buffer) != NO_ERROR) { setErrorReturn(EGL_BAD_ALLOC, EGL_FALSE); } setWidth(buffer->width); setHeight(buffer->height); DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE); rcSurface = rcEnc->rcCreateWindowSurface(rcEnc, (uintptr_t)config, getWidth(), getHeight()); if (!rcSurface) { ALOGE("rcCreateWindowSurface returned 0"); return EGL_FALSE; } rcEnc->rcSetWindowColorBuffer(rcEnc, rcSurface, ((cb_handle_t*)(buffer->handle))->hostHandle); return EGL_TRUE; } egl_window_surface_t* egl_window_surface_t::create( EGLDisplay dpy, EGLConfig config, EGLint surfType, ANativeWindow* window) { egl_window_surface_t* wnd = new egl_window_surface_t( dpy, config, surfType, window); if (wnd && !wnd->init()) { delete wnd; wnd = NULL; } return wnd; } egl_window_surface_t::~egl_window_surface_t() { DEFINE_HOST_CONNECTION; if (rcSurface && rcEnc) { rcEnc->rcDestroyWindowSurface(rcEnc, rcSurface); } if (buffer) { nativeWindow->cancelBuffer_DEPRECATED(nativeWindow, buffer); } nativeWindow->common.decRef(&nativeWindow->common); } void egl_window_surface_t::setSwapInterval(int interval) { nativeWindow->setSwapInterval(nativeWindow, interval); } EGLBoolean egl_window_surface_t::swapBuffers() { DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE); rcEnc->rcFlushWindowColorBuffer(rcEnc, rcSurface); nativeWindow->queueBuffer_DEPRECATED(nativeWindow, buffer); if (nativeWindow->dequeueBuffer_DEPRECATED(nativeWindow, &buffer)) { buffer = NULL; setErrorReturn(EGL_BAD_ALLOC, EGL_FALSE); } rcEnc->rcSetWindowColorBuffer(rcEnc, rcSurface, ((cb_handle_t *)(buffer->handle))->hostHandle); setWidth(buffer->width); setHeight(buffer->height); return EGL_TRUE; } // ---------------------------------------------------------------------------- //egl_pbuffer_surface_t struct egl_pbuffer_surface_t : public egl_surface_t { static egl_pbuffer_surface_t* create(EGLDisplay dpy, EGLConfig config, EGLint surfType, int32_t w, int32_t h, GLenum pixelFormat); virtual ~egl_pbuffer_surface_t(); virtual void setSwapInterval(int interval) { (void)interval; } virtual EGLBoolean swapBuffers() { return EGL_TRUE; } uint32_t getRcColorBuffer() { return rcColorBuffer; } private: egl_pbuffer_surface_t(EGLDisplay dpy, EGLConfig config, EGLint surfType, int32_t w, int32_t h); EGLBoolean init(GLenum format); uint32_t rcColorBuffer; }; egl_pbuffer_surface_t::egl_pbuffer_surface_t(EGLDisplay dpy, EGLConfig config, EGLint surfType, int32_t w, int32_t h) : egl_surface_t(dpy, config, surfType), rcColorBuffer(0) { setWidth(w); setHeight(h); } egl_pbuffer_surface_t::~egl_pbuffer_surface_t() { DEFINE_HOST_CONNECTION; if (rcEnc) { if (rcColorBuffer) rcEnc->rcCloseColorBuffer(rcEnc, rcColorBuffer); if (rcSurface) rcEnc->rcDestroyWindowSurface(rcEnc, rcSurface); } } EGLBoolean egl_pbuffer_surface_t::init(GLenum pixelFormat) { DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE); rcSurface = rcEnc->rcCreateWindowSurface(rcEnc, (uintptr_t)config, getWidth(), getHeight()); if (!rcSurface) { ALOGE("rcCreateWindowSurface returned 0"); return EGL_FALSE; } rcColorBuffer = rcEnc->rcCreateColorBuffer(rcEnc, getWidth(), getHeight(), pixelFormat); if (!rcColorBuffer) { ALOGE("rcCreateColorBuffer returned 0"); return EGL_FALSE; } rcEnc->rcSetWindowColorBuffer(rcEnc, rcSurface, rcColorBuffer); return EGL_TRUE; } egl_pbuffer_surface_t* egl_pbuffer_surface_t::create(EGLDisplay dpy, EGLConfig config, EGLint surfType, int32_t w, int32_t h, GLenum pixelFormat) { egl_pbuffer_surface_t* pb = new egl_pbuffer_surface_t(dpy, config, surfType, w, h); if (pb && !pb->init(pixelFormat)) { delete pb; pb = NULL; } return pb; } static const char *getGLString(int glEnum) { EGLThreadInfo *tInfo = getEGLThreadInfo(); if (!tInfo || !tInfo->currentContext) { return NULL; } const char** strPtr = NULL; #define GL_VENDOR 0x1F00 #define GL_RENDERER 0x1F01 #define GL_VERSION 0x1F02 #define GL_SHADING_LANGUAGE_VERSION 0x8B8C #define GL_EXTENSIONS 0x1F03 switch(glEnum) { case GL_VERSION: strPtr = &tInfo->currentContext->versionString; break; case GL_VENDOR: strPtr = &tInfo->currentContext->vendorString; break; case GL_RENDERER: strPtr = &tInfo->currentContext->rendererString; break; case GL_SHADING_LANGUAGE_VERSION: strPtr = &tInfo->currentContext->shaderVersionString; break; case GL_EXTENSIONS: strPtr = &tInfo->currentContext->extensionString; break; } if (!strPtr) { return NULL; } if (*strPtr != NULL) { // // string is already cached // return *strPtr; } // // first query of that string - need to query host // DEFINE_AND_VALIDATE_HOST_CONNECTION(NULL); char *hostStr = NULL; int n = rcEnc->rcGetGLString(rcEnc, glEnum, NULL, 0); if (n < 0) { hostStr = new char[-n+1]; n = rcEnc->rcGetGLString(rcEnc, glEnum, hostStr, -n); if (n <= 0) { delete [] hostStr; hostStr = NULL; } } // // keep the string in the context and return its value // *strPtr = hostStr; return hostStr; } // ---------------------------------------------------------------------------- // The one and only supported display object. static eglDisplay s_display; static EGLClient_eglInterface s_eglIface = { getThreadInfo: getEGLThreadInfo, getGLString: getGLString }; #define DBG_FUNC DBG("%s\n", __FUNCTION__) EGLDisplay eglGetDisplay(EGLNativeDisplayType display_id) { // // we support only EGL_DEFAULT_DISPLAY. // if (display_id != EGL_DEFAULT_DISPLAY) { return EGL_NO_DISPLAY; } return (EGLDisplay)&s_display; } EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor) { VALIDATE_DISPLAY(dpy,EGL_FALSE); if (!s_display.initialize(&s_eglIface)) { return EGL_FALSE; } if (major!=NULL) *major = s_display.getVersionMajor(); if (minor!=NULL) *minor = s_display.getVersionMinor(); return EGL_TRUE; } EGLBoolean eglTerminate(EGLDisplay dpy) { VALIDATE_DISPLAY_INIT(dpy, EGL_FALSE); s_display.terminate(); return EGL_TRUE; } EGLint eglGetError() { EGLint error = getEGLThreadInfo()->eglError; getEGLThreadInfo()->eglError = EGL_SUCCESS; return error; } __eglMustCastToProperFunctionPointerType eglGetProcAddress(const char *procname) { // search in EGL function table for (int i=0; ircChooseConfig(rcEnc, (EGLint*)attrib_list, attribs_size * sizeof(EGLint), (uint32_t*)tempConfigs, config_size); if (configs!=NULL) { EGLint i=0; for (i=0;i<(*num_config);i++) { *((uintptr_t*)configs+i) = *((uint32_t*)tempConfigs+i); } } if (*num_config <= 0) return EGL_FALSE; return EGL_TRUE; } EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value) { VALIDATE_DISPLAY_INIT(dpy, EGL_FALSE); VALIDATE_CONFIG(config, EGL_FALSE); if (s_display.getConfigAttrib(config, attribute, value)) { return EGL_TRUE; } else { RETURN_ERROR(EGL_FALSE, EGL_BAD_ATTRIBUTE); } } EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list) { (void)attrib_list; VALIDATE_DISPLAY_INIT(dpy, NULL); VALIDATE_CONFIG(config, EGL_FALSE); if (win == 0) { setErrorReturn(EGL_BAD_MATCH, EGL_NO_SURFACE); } EGLint surfaceType; if (s_display.getConfigAttrib(config, EGL_SURFACE_TYPE, &surfaceType) == EGL_FALSE) return EGL_FALSE; if (!(surfaceType & EGL_WINDOW_BIT)) { setErrorReturn(EGL_BAD_MATCH, EGL_NO_SURFACE); } if (static_cast(win)->common.magic != ANDROID_NATIVE_WINDOW_MAGIC) { setErrorReturn(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE); } egl_surface_t* surface = egl_window_surface_t::create( &s_display, config, EGL_WINDOW_BIT, static_cast(win)); if (!surface) { setErrorReturn(EGL_BAD_ALLOC, EGL_NO_SURFACE); } return surface; } EGLSurface eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list) { VALIDATE_DISPLAY_INIT(dpy, NULL); VALIDATE_CONFIG(config, EGL_FALSE); EGLint surfaceType; if (s_display.getConfigAttrib(config, EGL_SURFACE_TYPE, &surfaceType) == EGL_FALSE) return EGL_FALSE; if (!(surfaceType & EGL_PBUFFER_BIT)) { setErrorReturn(EGL_BAD_MATCH, EGL_NO_SURFACE); } int32_t w = 0; int32_t h = 0; EGLint texFormat = EGL_NO_TEXTURE; EGLint texTarget = EGL_NO_TEXTURE; while (attrib_list[0] != EGL_NONE) { switch (attrib_list[0]) { case EGL_WIDTH: w = attrib_list[1]; break; case EGL_HEIGHT: h = attrib_list[1]; break; case EGL_TEXTURE_FORMAT: texFormat = attrib_list[1]; break; case EGL_TEXTURE_TARGET: texTarget = attrib_list[1]; break; default: break; }; attrib_list+=2; } if (((texFormat == EGL_NO_TEXTURE)&&(texTarget != EGL_NO_TEXTURE)) || ((texFormat != EGL_NO_TEXTURE)&&(texTarget == EGL_NO_TEXTURE))) { setErrorReturn(EGL_BAD_MATCH, EGL_NO_SURFACE); } // TODO: check EGL_TEXTURE_FORMAT - need to support eglBindTexImage GLenum pixelFormat; if (s_display.getConfigGLPixelFormat(config, &pixelFormat) == EGL_FALSE) setErrorReturn(EGL_BAD_MATCH, EGL_NO_SURFACE); egl_surface_t* surface = egl_pbuffer_surface_t::create(dpy, config, EGL_PBUFFER_BIT, w, h, pixelFormat); if (!surface) { setErrorReturn(EGL_BAD_ALLOC, EGL_NO_SURFACE); } //setup attributes surface->setTextureFormat(texFormat); surface->setTextureTarget(texTarget); return surface; } EGLSurface eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list) { //XXX: Pixmap not supported. The host cannot render to a pixmap resource // located on host. In order to support Pixmaps we should either punt // to s/w rendering -or- let the host render to a buffer that will be // copied back to guest at some sync point. None of those methods not // implemented and pixmaps are not used with OpenGL anyway ... (void)dpy; (void)config; (void)pixmap; (void)attrib_list; return EGL_NO_SURFACE; } EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface eglSurface) { VALIDATE_DISPLAY_INIT(dpy, EGL_FALSE); VALIDATE_SURFACE_RETURN(eglSurface, EGL_FALSE); egl_surface_t* surface(static_cast(eglSurface)); delete surface; return EGL_TRUE; } EGLBoolean eglQuerySurface(EGLDisplay dpy, EGLSurface eglSurface, EGLint attribute, EGLint *value) { VALIDATE_DISPLAY_INIT(dpy, EGL_FALSE); VALIDATE_SURFACE_RETURN(eglSurface, EGL_FALSE); egl_surface_t* surface( static_cast(eglSurface) ); EGLBoolean ret = EGL_TRUE; switch (attribute) { case EGL_CONFIG_ID: ret = s_display.getConfigAttrib(surface->config, EGL_CONFIG_ID, value); break; case EGL_WIDTH: *value = surface->getWidth(); break; case EGL_HEIGHT: *value = surface->getHeight(); break; case EGL_TEXTURE_FORMAT: *value = surface->getTextureFormat(); break; case EGL_TEXTURE_TARGET: *value = surface->getTextureTarget(); break; case EGL_SWAP_BEHAVIOR: *value = surface->getSwapBehavior(); break; case EGL_LARGEST_PBUFFER: // not modified for a window or pixmap surface // and we ignore it when creating a PBuffer surface (default is EGL_FALSE) if (surface->getSurfaceType() & EGL_PBUFFER_BIT) *value = EGL_FALSE; break; case EGL_MIPMAP_LEVEL: // not modified for a window or pixmap surface // and we ignore it when creating a PBuffer surface (default is 0) if (surface->getSurfaceType() & EGL_PBUFFER_BIT) *value = 0; break; case EGL_MULTISAMPLE_RESOLVE: // ignored when creating the surface, return default *value = EGL_MULTISAMPLE_RESOLVE_DEFAULT; break; //TODO: complete other attributes default: ALOGE("eglQuerySurface %x EGL_BAD_ATTRIBUTE", attribute); ret = setErrorFunc(EGL_BAD_ATTRIBUTE, EGL_FALSE); break; } return ret; } EGLBoolean eglBindAPI(EGLenum api) { if (api != EGL_OPENGL_ES_API) setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE); return EGL_TRUE; } EGLenum eglQueryAPI() { return EGL_OPENGL_ES_API; } EGLBoolean eglWaitClient() { return eglWaitGL(); } EGLBoolean eglReleaseThread() { EGLThreadInfo *tInfo = getEGLThreadInfo(); if (tInfo && tInfo->currentContext) { return eglMakeCurrent(&s_display, EGL_NO_CONTEXT, EGL_NO_SURFACE, EGL_NO_SURFACE); } return EGL_TRUE; } EGLSurface eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list) { //TODO (void)dpy; (void)buftype; (void)buffer; (void)config; (void)attrib_list; ALOGW("%s not implemented", __FUNCTION__); return 0; } EGLBoolean eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value) { // Right now we don't do anything when using host GPU. // This is purely just to pass the data through // without issuing a warning. We may benefit from validating the // display and surface for debug purposes. // TODO: Find cases where we actually need to do something. VALIDATE_DISPLAY_INIT(dpy, EGL_FALSE); VALIDATE_SURFACE_RETURN(surface, EGL_FALSE); if (surface == EGL_NO_SURFACE) { setErrorReturn(EGL_BAD_SURFACE, EGL_FALSE); } (void)value; switch (attribute) { case EGL_MIPMAP_LEVEL: case EGL_MULTISAMPLE_RESOLVE: case EGL_SWAP_BEHAVIOR: return true; break; default: ALOGW("%s: attr=0x%x not implemented", __FUNCTION__, attribute); } return false; } EGLBoolean eglBindTexImage(EGLDisplay dpy, EGLSurface eglSurface, EGLint buffer) { VALIDATE_DISPLAY_INIT(dpy, EGL_FALSE); VALIDATE_SURFACE_RETURN(eglSurface, EGL_FALSE); if (eglSurface == EGL_NO_SURFACE) { setErrorReturn(EGL_BAD_SURFACE, EGL_FALSE); } if (buffer != EGL_BACK_BUFFER) { setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE); } egl_surface_t* surface( static_cast(eglSurface) ); if (surface->getTextureFormat() == EGL_NO_TEXTURE) { setErrorReturn(EGL_BAD_MATCH, EGL_FALSE); } if (!(surface->getSurfaceType() & EGL_PBUFFER_BIT)) { setErrorReturn(EGL_BAD_SURFACE, EGL_FALSE); } //It's now safe to cast to pbuffer surface egl_pbuffer_surface_t* pbSurface = (egl_pbuffer_surface_t*)surface; DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE); rcEnc->rcBindTexture(rcEnc, pbSurface->getRcColorBuffer()); return GL_TRUE; } EGLBoolean eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) { //TODO (void)dpy; (void)surface; (void)buffer; ALOGW("%s not implemented", __FUNCTION__); return 0; } EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval) { VALIDATE_DISPLAY_INIT(dpy, EGL_FALSE); DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE); EGLContext_t* ctx = getEGLThreadInfo()->currentContext; if (!ctx) { setErrorReturn(EGL_BAD_CONTEXT, EGL_FALSE); } if (!ctx->draw) { setErrorReturn(EGL_BAD_SURFACE, EGL_FALSE); } egl_surface_t* draw(static_cast(ctx->draw)); draw->setSwapInterval(interval); rcEnc->rcFBSetSwapInterval(rcEnc, interval); //TODO: implement on the host return EGL_TRUE; } EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list) { VALIDATE_DISPLAY_INIT(dpy, EGL_NO_CONTEXT); VALIDATE_CONFIG(config, EGL_NO_CONTEXT); EGLint version = 1; //default while (attrib_list && attrib_list[0] != EGL_NONE) { if (attrib_list[0] == EGL_CONTEXT_CLIENT_VERSION) version = attrib_list[1]; attrib_list+=2; } // Currently only support GLES1 and 2 if (version != 1 && version != 2) { setErrorReturn(EGL_BAD_CONFIG, EGL_NO_CONTEXT); } uint32_t rcShareCtx = 0; EGLContext_t * shareCtx = NULL; if (share_context) { shareCtx = static_cast(share_context); rcShareCtx = shareCtx->rcContext; if (shareCtx->dpy != dpy) setErrorReturn(EGL_BAD_MATCH, EGL_NO_CONTEXT); } DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_NO_CONTEXT); uint32_t rcContext = rcEnc->rcCreateContext(rcEnc, (uintptr_t)config, rcShareCtx, version); if (!rcContext) { ALOGE("rcCreateContext returned 0"); setErrorReturn(EGL_BAD_ALLOC, EGL_NO_CONTEXT); } EGLContext_t * context = new EGLContext_t(dpy, config, shareCtx); if (!context) setErrorReturn(EGL_BAD_ALLOC, EGL_NO_CONTEXT); context->version = version; context->rcContext = rcContext; return context; } EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx) { VALIDATE_DISPLAY_INIT(dpy, EGL_FALSE); VALIDATE_CONTEXT_RETURN(ctx, EGL_FALSE); EGLContext_t * context = static_cast(ctx); if (!context) return EGL_TRUE; if (getEGLThreadInfo()->currentContext == context) { getEGLThreadInfo()->currentContext->deletePending = 1; return EGL_TRUE; } if (context->rcContext) { DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE); rcEnc->rcDestroyContext(rcEnc, context->rcContext); context->rcContext = 0; } delete context; return EGL_TRUE; } EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) { VALIDATE_DISPLAY_INIT(dpy, EGL_FALSE); VALIDATE_SURFACE_RETURN(draw, EGL_FALSE); VALIDATE_SURFACE_RETURN(read, EGL_FALSE); if ((read == EGL_NO_SURFACE && draw == EGL_NO_SURFACE) && (ctx != EGL_NO_CONTEXT)) setErrorReturn(EGL_BAD_MATCH, EGL_FALSE); if ((read != EGL_NO_SURFACE || draw != EGL_NO_SURFACE) && (ctx == EGL_NO_CONTEXT)) setErrorReturn(EGL_BAD_MATCH, EGL_FALSE); EGLContext_t * context = static_cast(ctx); uint32_t ctxHandle = (context) ? context->rcContext : 0; egl_surface_t * drawSurf = static_cast(draw); uint32_t drawHandle = (drawSurf) ? drawSurf->getRcSurface() : 0; egl_surface_t * readSurf = static_cast(read); uint32_t readHandle = (readSurf) ? readSurf->getRcSurface() : 0; // // Nothing to do if no binding change has made // EGLThreadInfo *tInfo = getEGLThreadInfo(); if (tInfo->currentContext == context && (context == NULL || (context && context->draw == draw && context->read == read))) { return EGL_TRUE; } if (tInfo->currentContext && tInfo->currentContext->deletePending) { if (tInfo->currentContext != context) { EGLContext_t * contextToDelete = tInfo->currentContext; tInfo->currentContext = 0; eglDestroyContext(dpy, contextToDelete); } } if (context && (context->flags & EGLContext_t::IS_CURRENT) && (context != tInfo->currentContext)) { //context is current to another thread setErrorReturn(EGL_BAD_ACCESS, EGL_FALSE); } DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE); if (rcEnc->rcMakeCurrent(rcEnc, ctxHandle, drawHandle, readHandle) == EGL_FALSE) { ALOGE("rcMakeCurrent returned EGL_FALSE"); setErrorReturn(EGL_BAD_CONTEXT, EGL_FALSE); } //Now make the local bind if (context) { context->draw = draw; context->read = read; context->flags |= EGLContext_t::IS_CURRENT; //set the client state if (context->version == 2) { hostCon->gl2Encoder()->setClientState(context->getClientState()); hostCon->gl2Encoder()->setSharedGroup(context->getSharedGroup()); } else { hostCon->glEncoder()->setClientState(context->getClientState()); hostCon->glEncoder()->setSharedGroup(context->getSharedGroup()); } } else if (tInfo->currentContext) { //release ClientState & SharedGroup if (tInfo->currentContext->version == 2) { hostCon->gl2Encoder()->setClientState(NULL); hostCon->gl2Encoder()->setSharedGroup(GLSharedGroupPtr(NULL)); } else { hostCon->glEncoder()->setClientState(NULL); hostCon->glEncoder()->setSharedGroup(GLSharedGroupPtr(NULL)); } } if (tInfo->currentContext) tInfo->currentContext->flags &= ~EGLContext_t::IS_CURRENT; //Now make current tInfo->currentContext = context; //Check maybe we need to init the encoder, if it's first eglMakeCurrent if (tInfo->currentContext) { if (tInfo->currentContext->version == 2) { if (!hostCon->gl2Encoder()->isInitialized()) { s_display.gles2_iface()->init(); hostCon->gl2Encoder()->setInitialized(); ClientAPIExts::initClientFuncs(s_display.gles2_iface(), 1); } } else { if (!hostCon->glEncoder()->isInitialized()) { s_display.gles_iface()->init(); hostCon->glEncoder()->setInitialized(); ClientAPIExts::initClientFuncs(s_display.gles_iface(), 0); } } } return EGL_TRUE; } EGLContext eglGetCurrentContext() { return getEGLThreadInfo()->currentContext; } EGLSurface eglGetCurrentSurface(EGLint readdraw) { EGLContext_t * context = getEGLThreadInfo()->currentContext; if (!context) return EGL_NO_SURFACE; //not an error switch (readdraw) { case EGL_READ: return context->read; case EGL_DRAW: return context->draw; default: setErrorReturn(EGL_BAD_PARAMETER, EGL_NO_SURFACE); } } EGLDisplay eglGetCurrentDisplay() { EGLContext_t * context = getEGLThreadInfo()->currentContext; if (!context) return EGL_NO_DISPLAY; //not an error return context->dpy; } EGLBoolean eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value) { VALIDATE_DISPLAY_INIT(dpy, EGL_FALSE); VALIDATE_CONTEXT_RETURN(ctx, EGL_FALSE); EGLContext_t * context = static_cast(ctx); EGLBoolean ret = EGL_TRUE; switch (attribute) { case EGL_CONFIG_ID: ret = s_display.getConfigAttrib(context->config, EGL_CONFIG_ID, value); break; case EGL_CONTEXT_CLIENT_TYPE: *value = EGL_OPENGL_ES_API; break; case EGL_CONTEXT_CLIENT_VERSION: *value = context->version; break; case EGL_RENDER_BUFFER: if (!context->draw) *value = EGL_NONE; else *value = EGL_BACK_BUFFER; //single buffer not supported break; default: ALOGE("eglQueryContext %x EGL_BAD_ATTRIBUTE", attribute); setErrorReturn(EGL_BAD_ATTRIBUTE, EGL_FALSE); break; } return ret; } EGLBoolean eglWaitGL() { EGLThreadInfo *tInfo = getEGLThreadInfo(); if (!tInfo || !tInfo->currentContext) { return EGL_FALSE; } if (tInfo->currentContext->version == 2) { s_display.gles2_iface()->finish(); } else { s_display.gles_iface()->finish(); } return EGL_TRUE; } EGLBoolean eglWaitNative(EGLint engine) { (void)engine; return EGL_TRUE; } EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface eglSurface) { VALIDATE_DISPLAY_INIT(dpy, EGL_FALSE); if (eglSurface == EGL_NO_SURFACE) setErrorReturn(EGL_BAD_SURFACE, EGL_FALSE); DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE); egl_surface_t* d = static_cast(eglSurface); if (d->dpy != dpy) setErrorReturn(EGL_BAD_DISPLAY, EGL_FALSE); // post the surface d->swapBuffers(); hostCon->flush(); return EGL_TRUE; } EGLBoolean eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target) { //TODO :later (void)dpy; (void)surface; (void)target; return 0; } EGLBoolean eglLockSurfaceKHR(EGLDisplay display, EGLSurface surface, const EGLint *attrib_list) { //TODO later (void)display; (void)surface; (void)attrib_list; return 0; } EGLBoolean eglUnlockSurfaceKHR(EGLDisplay display, EGLSurface surface) { //TODO later (void)display; (void)surface; return 0; } EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list) { (void)attrib_list; VALIDATE_DISPLAY_INIT(dpy, EGL_NO_IMAGE_KHR); if (target == EGL_NATIVE_BUFFER_ANDROID) { if (ctx != EGL_NO_CONTEXT) { setErrorReturn(EGL_BAD_CONTEXT, EGL_NO_IMAGE_KHR); } android_native_buffer_t* native_buffer = (android_native_buffer_t*)buffer; if (native_buffer->common.magic != ANDROID_NATIVE_BUFFER_MAGIC) setErrorReturn(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR); if (native_buffer->common.version != sizeof(android_native_buffer_t)) setErrorReturn(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR); cb_handle_t *cb = (cb_handle_t *)(native_buffer->handle); switch (cb->format) { case HAL_PIXEL_FORMAT_RGBA_8888: case HAL_PIXEL_FORMAT_RGBX_8888: case HAL_PIXEL_FORMAT_RGB_888: case HAL_PIXEL_FORMAT_RGB_565: case HAL_PIXEL_FORMAT_BGRA_8888: break; default: setErrorReturn(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR); } native_buffer->common.incRef(&native_buffer->common); EGLImage_t *image = new EGLImage_t(); image->dpy = dpy; image->target = target; image->native_buffer = native_buffer; return (EGLImageKHR)image; } else if (target == EGL_GL_TEXTURE_2D_KHR) { VALIDATE_CONTEXT_RETURN(ctx, EGL_NO_IMAGE_KHR); EGLContext_t *context = static_cast(ctx); DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_NO_IMAGE_KHR); uint32_t ctxHandle = (context) ? context->rcContext : 0; GLuint texture = (GLuint)reinterpret_cast(buffer); uint32_t img = rcEnc->rcCreateClientImage(rcEnc, ctxHandle, target, texture); EGLImage_t *image = new EGLImage_t(); image->dpy = dpy; image->target = target; image->host_egl_image = img; return (EGLImageKHR)image; } setErrorReturn(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR); } EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR img) { VALIDATE_DISPLAY_INIT(dpy, EGL_FALSE); EGLImage_t *image = (EGLImage_t*)img; if (!image || image->dpy != dpy) { RETURN_ERROR(EGL_FALSE, EGL_BAD_PARAMETER); } if (image->target == EGL_NATIVE_BUFFER_ANDROID) { android_native_buffer_t* native_buffer = image->native_buffer; if (native_buffer->common.magic != ANDROID_NATIVE_BUFFER_MAGIC) setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE); if (native_buffer->common.version != sizeof(android_native_buffer_t)) setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE); native_buffer->common.decRef(&native_buffer->common); delete image; return EGL_TRUE; } else if (image->target == EGL_GL_TEXTURE_2D_KHR) { uint32_t host_egl_image = image->host_egl_image; delete image; DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE); return rcEnc->rcDestroyClientImage(rcEnc, host_egl_image); } setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE); } #define FENCE_SYNC_HANDLE (EGLSyncKHR)0xFE4CE EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list) { // TODO: This implementation could be faster. We should require the host EGL // to support KHR_fence_sync, or at least pipe the fence command to the host // and wait for it (probably involving a glFinish on the host) in // eglClientWaitSyncKHR. VALIDATE_DISPLAY(dpy, EGL_NO_SYNC_KHR); if (type != EGL_SYNC_FENCE_KHR || (attrib_list != NULL && attrib_list[0] != EGL_NONE)) { setErrorReturn(EGL_BAD_ATTRIBUTE, EGL_NO_SYNC_KHR); } EGLThreadInfo *tInfo = getEGLThreadInfo(); if (!tInfo || !tInfo->currentContext) { setErrorReturn(EGL_BAD_MATCH, EGL_NO_SYNC_KHR); } if (tInfo->currentContext->version == 2) { s_display.gles2_iface()->finish(); } else { s_display.gles_iface()->finish(); } return FENCE_SYNC_HANDLE; } EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync) { (void)dpy; if (sync != FENCE_SYNC_HANDLE) { setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE); } return EGL_TRUE; } EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout) { (void)dpy; (void)flags; (void)timeout; if (sync != FENCE_SYNC_HANDLE) { setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE); } return EGL_CONDITION_SATISFIED_KHR; } EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value) { (void)dpy; if (sync != FENCE_SYNC_HANDLE) { setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE); } switch (attribute) { case EGL_SYNC_TYPE_KHR: *value = EGL_SYNC_FENCE_KHR; return EGL_TRUE; case EGL_SYNC_STATUS_KHR: *value = EGL_SIGNALED_KHR; return EGL_TRUE; case EGL_SYNC_CONDITION_KHR: *value = EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR; return EGL_TRUE; default: setErrorReturn(EGL_BAD_ATTRIBUTE, EGL_FALSE); } } anbox-0.0~git20191115/android/opengl/system/egl/eglContext.h000066400000000000000000000031471356361734700235160ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _EGL_CONTEXT_H #define _EGL_CONTEXT_H #include "GLClientState.h" #include "GLSharedGroup.h" struct EGLContext_t { enum { IS_CURRENT = 0x00010000, NEVER_CURRENT = 0x00020000 }; EGLContext_t(EGLDisplay dpy, EGLConfig config, EGLContext_t* shareCtx); ~EGLContext_t(); uint32_t flags; EGLDisplay dpy; EGLConfig config; EGLSurface read; EGLSurface draw; EGLContext_t * shareCtx; EGLint version; uint32_t rcContext; const char* versionString; const char* vendorString; const char* rendererString; const char* shaderVersionString; const char* extensionString; EGLint deletePending; GLClientState * getClientState(){ return clientState; } GLSharedGroupPtr getSharedGroup(){ return sharedGroup; } private: GLClientState * clientState; GLSharedGroupPtr sharedGroup; }; #endif anbox-0.0~git20191115/android/opengl/system/egl/eglDisplay.cpp000066400000000000000000000363401356361734700240330ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "eglDisplay.h" #include "HostConnection.h" #include static const int systemEGLVersionMajor = 1; static const int systemEGLVersionMinor = 4; static const char systemEGLVendor[] = "Google Android emulator"; // list of extensions supported by this EGL implementation // NOTE that each extension name should be suffixed with space static const char systemStaticEGLExtensions[] = "EGL_ANDROID_image_native_buffer " "EGL_KHR_fence_sync " "EGL_KHR_image_base " "EGL_KHR_gl_texture_2d_image "; static void *s_gles_lib = NULL; static void *s_gles2_lib = NULL; // The following function will be called when we (libEGL) // gets unloaded // At this point we want to unload the gles libraries we // might have loaded during initialization static void __attribute__ ((destructor)) do_on_unload(void) { if (s_gles_lib) { dlclose(s_gles_lib); } if (s_gles2_lib) { dlclose(s_gles2_lib); } } eglDisplay::eglDisplay() : m_initialized(false), m_major(0), m_minor(0), m_hostRendererVersion(0), m_numConfigs(0), m_numConfigAttribs(0), m_attribs(DefaultKeyedVector(ATTRIBUTE_NONE)), m_configs(NULL), m_gles_iface(NULL), m_gles2_iface(NULL), m_versionString(NULL), m_vendorString(NULL), m_extensionString(NULL) { pthread_mutex_init(&m_lock, NULL); } eglDisplay::~eglDisplay() { pthread_mutex_destroy(&m_lock); } bool eglDisplay::initialize(EGLClient_eglInterface *eglIface) { pthread_mutex_lock(&m_lock); if (!m_initialized) { // // load GLES client API // #if __LP64__ m_gles_iface = loadGLESClientAPI("/system/lib64/egl/libGLESv1_CM_emulation.so", eglIface, &s_gles_lib); #else m_gles_iface = loadGLESClientAPI("/system/lib/egl/libGLESv1_CM_emulation.so", eglIface, &s_gles_lib); #endif if (!m_gles_iface) { pthread_mutex_unlock(&m_lock); ALOGE("Failed to load gles1 iface"); return false; } #ifdef WITH_GLES2 #if __LP64__ m_gles2_iface = loadGLESClientAPI("/system/lib64/egl/libGLESv2_emulation.so", eglIface, &s_gles2_lib); #else m_gles2_iface = loadGLESClientAPI("/system/lib/egl/libGLESv2_emulation.so", eglIface, &s_gles2_lib); #endif // Note that if loading gles2 failed, we can still run with no // GLES2 support, having GLES2 is not mandatory. #endif // // establish connection with the host // HostConnection *hcon = HostConnection::get(); if (!hcon) { pthread_mutex_unlock(&m_lock); ALOGE("Failed to establish connection with the host\n"); return false; } // // get renderControl encoder instance // renderControl_encoder_context_t *rcEnc = hcon->rcEncoder(); if (!rcEnc) { pthread_mutex_unlock(&m_lock); ALOGE("Failed to get renderControl encoder instance"); return false; } // // Query host reneder and EGL version // m_hostRendererVersion = rcEnc->rcGetRendererVersion(rcEnc); EGLint status = rcEnc->rcGetEGLVersion(rcEnc, &m_major, &m_minor); if (status != EGL_TRUE) { // host EGL initialization failed !! pthread_mutex_unlock(&m_lock); return false; } // // Take minimum version beween what we support and what the host support // if (m_major > systemEGLVersionMajor) { m_major = systemEGLVersionMajor; m_minor = systemEGLVersionMinor; } else if (m_major == systemEGLVersionMajor && m_minor > systemEGLVersionMinor) { m_minor = systemEGLVersionMinor; } // // Query the host for the set of configs // m_numConfigs = rcEnc->rcGetNumConfigs(rcEnc, (uint32_t*)&m_numConfigAttribs); if (m_numConfigs <= 0 || m_numConfigAttribs <= 0) { // just sanity check - should never happen pthread_mutex_unlock(&m_lock); return false; } uint32_t nInts = m_numConfigAttribs * (m_numConfigs + 1); EGLint tmp_buf[nInts]; m_configs = new EGLint[nInts-m_numConfigAttribs]; if (!m_configs) { pthread_mutex_unlock(&m_lock); return false; } //EGLint n = rcEnc->rcGetConfigs(rcEnc, nInts*sizeof(EGLint), m_configs); EGLint n = rcEnc->rcGetConfigs(rcEnc, nInts*sizeof(EGLint), (GLuint*)tmp_buf); if (n != m_numConfigs) { pthread_mutex_unlock(&m_lock); return false; } //Fill the attributes vector. //The first m_numConfigAttribs values of tmp_buf are the actual attributes enums. for (int i=0; ircEncoder(); if (rcEnc) { int n = rcEnc->rcQueryEGLString(rcEnc, name, NULL, 0); if (n < 0) { // allocate space for the string with additional // space charachter to be suffixed at the end. char *str = (char *)malloc(-n+2); n = rcEnc->rcQueryEGLString(rcEnc, name, str, -n); if (n > 0) { // add extra space at end of string which will be // needed later when filtering the extension list. strcat(str, " "); return str; } free(str); } } } return NULL; } static bool findExtInList(const char* token, int tokenlen, const char* list) { const char* p = list; while (*p != '\0') { const char* q = strchr(p, ' '); if (q == NULL) { /* should not happen, list must be space-terminated */ break; } if (tokenlen == (q - p) && !memcmp(token, p, tokenlen)) { return true; /* found it */ } p = q+1; } return false; /* not found */ } static char *buildExtensionString() { //Query host extension string char *hostExt = queryHostEGLString(EGL_EXTENSIONS); if (!hostExt || (hostExt[1] == '\0')) { // no extensions on host - only static extension list supported return strdup(systemStaticEGLExtensions); } int n = strlen(hostExt); if (n > 0) { char *str; asprintf(&str,"%s%s", systemStaticEGLExtensions, hostExt); free((char*)hostExt); return str; } else { free((char*)hostExt); return strdup(systemStaticEGLExtensions); } } const char *eglDisplay::queryString(EGLint name) { if (name == EGL_CLIENT_APIS) { return "OpenGL_ES"; } else if (name == EGL_VERSION) { pthread_mutex_lock(&m_lock); if (m_versionString) { pthread_mutex_unlock(&m_lock); return m_versionString; } // build version string asprintf(&m_versionString, "%d.%d", m_major, m_minor); pthread_mutex_unlock(&m_lock); return m_versionString; } else if (name == EGL_VENDOR) { pthread_mutex_lock(&m_lock); if (m_vendorString) { pthread_mutex_unlock(&m_lock); return m_vendorString; } // build vendor string const char *hostVendor = queryHostEGLString(EGL_VENDOR); if (hostVendor) { asprintf(&m_vendorString, "%s Host: %s", systemEGLVendor, hostVendor); free((char*)hostVendor); } else { m_vendorString = (char *)systemEGLVendor; } pthread_mutex_unlock(&m_lock); return m_vendorString; } else if (name == EGL_EXTENSIONS) { pthread_mutex_lock(&m_lock); if (m_extensionString) { pthread_mutex_unlock(&m_lock); return m_extensionString; } // build extension string m_extensionString = buildExtensionString(); pthread_mutex_unlock(&m_lock); return m_extensionString; } else { ALOGE("[%s] Unknown name %d\n", __FUNCTION__, name); return NULL; } } /* To get the value of attribute of config use the following formula: * value = *(m_configs + (int)c*m_numConfigAttribs + a); */ EGLBoolean eglDisplay::getAttribValue(EGLConfig config, EGLint attribIdx, EGLint * value) { if (attribIdx == ATTRIBUTE_NONE) { ALOGE("[%s] Bad attribute idx\n", __FUNCTION__); return EGL_FALSE; } *value = *(m_configs + (intptr_t)config*m_numConfigAttribs + attribIdx); return EGL_TRUE; } EGLBoolean eglDisplay::getConfigAttrib(EGLConfig config, EGLint attrib, EGLint * value) { //Though it seems that valueFor() is thread-safe, we don't take chanses pthread_mutex_lock(&m_lock); EGLBoolean ret = getAttribValue(config, m_attribs.valueFor(attrib), value); pthread_mutex_unlock(&m_lock); return ret; } void eglDisplay::dumpConfig(EGLConfig config) { EGLint value = 0; DBG("^^^^^^^^^^ dumpConfig %d ^^^^^^^^^^^^^^^^^^", (int)config); for (int i=0; i of config use the following formula: * *(m_configs + (int)c*m_numConfigAttribs + a) = value; */ EGLBoolean eglDisplay::setAttribValue(EGLConfig config, EGLint attribIdx, EGLint value) { if (attribIdx == ATTRIBUTE_NONE) { ALOGE("[%s] Bad attribute idx\n", __FUNCTION__); return EGL_FALSE; } *(m_configs + (intptr_t)config*m_numConfigAttribs + attribIdx) = value; return EGL_TRUE; } EGLBoolean eglDisplay::setConfigAttrib(EGLConfig config, EGLint attrib, EGLint value) { //Though it seems that valueFor() is thread-safe, we don't take chanses pthread_mutex_lock(&m_lock); EGLBoolean ret = setAttribValue(config, m_attribs.valueFor(attrib), value); pthread_mutex_unlock(&m_lock); return ret; } EGLBoolean eglDisplay::getConfigNativePixelFormat(EGLConfig config, PixelFormat * format) { EGLint redSize, blueSize, greenSize, alphaSize; if ( !(getAttribValue(config, m_attribs.valueFor(EGL_RED_SIZE), &redSize) && getAttribValue(config, m_attribs.valueFor(EGL_BLUE_SIZE), &blueSize) && getAttribValue(config, m_attribs.valueFor(EGL_GREEN_SIZE), &greenSize) && getAttribValue(config, m_attribs.valueFor(EGL_ALPHA_SIZE), &alphaSize)) ) { ALOGE("Couldn't find value for one of the pixel format attributes"); return EGL_FALSE; } //calculate the GL internal format if ((redSize==8)&&(greenSize==8)&&(blueSize==8)&&(alphaSize==8)) *format = PIXEL_FORMAT_RGBA_8888; //XXX: BGR? else if ((redSize==8)&&(greenSize==8)&&(blueSize==8)&&(alphaSize==0)) *format = PIXEL_FORMAT_RGBX_8888; //XXX or PIXEL_FORMAT_RGB_888 else if ((redSize==5)&&(greenSize==6)&&(blueSize==5)&&(alphaSize==0)) *format = PIXEL_FORMAT_RGB_565; else if ((redSize==5)&&(greenSize==5)&&(blueSize==5)&&(alphaSize==1)) *format = PIXEL_FORMAT_RGBA_5551; else if ((redSize==4)&&(greenSize==4)&&(blueSize==4)&&(alphaSize==4)) *format = PIXEL_FORMAT_RGBA_4444; else { return EGL_FALSE; } return EGL_TRUE; } EGLBoolean eglDisplay::getConfigGLPixelFormat(EGLConfig config, GLenum * format) { EGLint redSize, blueSize, greenSize, alphaSize; if ( !(getAttribValue(config, m_attribs.valueFor(EGL_RED_SIZE), &redSize) && getAttribValue(config, m_attribs.valueFor(EGL_BLUE_SIZE), &blueSize) && getAttribValue(config, m_attribs.valueFor(EGL_GREEN_SIZE), &greenSize) && getAttribValue(config, m_attribs.valueFor(EGL_ALPHA_SIZE), &alphaSize)) ) { ALOGE("Couldn't find value for one of the pixel format attributes"); return EGL_FALSE; } //calculate the GL internal format if ((redSize == greenSize) && (redSize == blueSize) && ((redSize == 8) || (redSize == 16) || (redSize == 32))) { if (alphaSize == 0) *format = GL_RGB; else *format = GL_RGBA; } else if ((redSize==5)&&(greenSize==6)&&(blueSize==5)&&(alphaSize==0)) *format = GL_RGB565_OES; else if ((redSize==5)&&(greenSize==5)&&(blueSize==5)&&(alphaSize==1)) *format = GL_RGB5_A1_OES; else if ((redSize==4)&&(greenSize==4)&&(blueSize==4)&&(alphaSize==4)) *format = GL_RGBA4_OES; else return EGL_FALSE; return EGL_TRUE; } anbox-0.0~git20191115/android/opengl/system/egl/eglDisplay.h000066400000000000000000000060161356361734700234750ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _SYSTEM_EGL_DISPLAY_H #define _SYSTEM_EGL_DISPLAY_H #include #include "glUtils.h" #include #include #include "EGLClientIface.h" #include #include #define ATTRIBUTE_NONE -1 //FIXME: are we in this namespace? using namespace android; class eglDisplay { public: eglDisplay(); ~eglDisplay(); bool initialize(EGLClient_eglInterface *eglIface); void terminate(); int getVersionMajor() const { return m_major; } int getVersionMinor() const { return m_minor; } bool initialized() const { return m_initialized; } const char *queryString(EGLint name); const EGLClient_glesInterface *gles_iface() const { return m_gles_iface; } const EGLClient_glesInterface *gles2_iface() const { return m_gles2_iface; } int getNumConfigs(){ return m_numConfigs; } EGLBoolean getConfigAttrib(EGLConfig config, EGLint attrib, EGLint * value); EGLBoolean setConfigAttrib(EGLConfig config, EGLint attrib, EGLint value); EGLBoolean getConfigGLPixelFormat(EGLConfig config, GLenum * format); EGLBoolean getConfigNativePixelFormat(EGLConfig config, PixelFormat * format); void dumpConfig(EGLConfig config); private: EGLClient_glesInterface *loadGLESClientAPI(const char *libName, EGLClient_eglInterface *eglIface, void **libHandle); EGLBoolean getAttribValue(EGLConfig config, EGLint attribIdxi, EGLint * value); EGLBoolean setAttribValue(EGLConfig config, EGLint attribIdxi, EGLint value); void processConfigs(); private: pthread_mutex_t m_lock; bool m_initialized; int m_major; int m_minor; int m_hostRendererVersion; int m_numConfigs; int m_numConfigAttribs; /* This is the mapping between an attribute name to it's index in any given config */ DefaultKeyedVector m_attribs; /* This is an array of all config's attributes values stored in the following sequencial fasion (read: v[c,a] = the value of attribute of config ) * v[0,0],..,v[0,m_numConfigAttribs-1], *... * v[m_numConfigs-1,0],..,v[m_numConfigs-1,m_numConfigAttribs-1] */ EGLint *m_configs; EGLClient_glesInterface *m_gles_iface; EGLClient_glesInterface *m_gles2_iface; char *m_versionString; char *m_vendorString; char *m_extensionString; }; #endif anbox-0.0~git20191115/android/opengl/system/egl/egl_ftable.h000066400000000000000000000057111356361734700234650ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ static const struct _egl_funcs_by_name { const char *name; void *proc; } egl_funcs_by_name[] = { {"eglGetError", (void *)eglGetError}, {"eglGetDisplay", (void *)eglGetDisplay}, {"eglInitialize", (void *)eglInitialize}, {"eglTerminate", (void *)eglTerminate}, {"eglQueryString", (void *)eglQueryString}, {"eglGetConfigs", (void *)eglGetConfigs}, {"eglChooseConfig", (void *)eglChooseConfig}, {"eglGetConfigAttrib", (void *)eglGetConfigAttrib}, {"eglCreateWindowSurface", (void *)eglCreateWindowSurface}, {"eglCreatePbufferSurface", (void *)eglCreatePbufferSurface}, {"eglCreatePixmapSurface", (void *)eglCreatePixmapSurface}, {"eglDestroySurface", (void *)eglDestroySurface}, {"eglQuerySurface", (void *)eglQuerySurface}, {"eglBindAPI", (void *)eglBindAPI}, {"eglQueryAPI", (void *)eglQueryAPI}, {"eglWaitClient", (void *)eglWaitClient}, {"eglReleaseThread", (void *)eglReleaseThread}, {"eglCreatePbufferFromClientBuffer", (void *)eglCreatePbufferFromClientBuffer}, {"eglSurfaceAttrib", (void *)eglSurfaceAttrib}, {"eglBindTexImage", (void *)eglBindTexImage}, {"eglReleaseTexImage", (void *)eglReleaseTexImage}, {"eglSwapInterval", (void *)eglSwapInterval}, {"eglCreateContext", (void *)eglCreateContext}, {"eglDestroyContext", (void *)eglDestroyContext}, {"eglMakeCurrent", (void *)eglMakeCurrent}, {"eglGetCurrentContext", (void *)eglGetCurrentContext}, {"eglGetCurrentSurface", (void *)eglGetCurrentSurface}, {"eglGetCurrentDisplay", (void *)eglGetCurrentDisplay}, {"eglQueryContext", (void *)eglQueryContext}, {"eglWaitGL", (void *)eglWaitGL}, {"eglWaitNative", (void *)eglWaitNative}, {"eglSwapBuffers", (void *)eglSwapBuffers}, {"eglCopyBuffers", (void *)eglCopyBuffers}, {"eglGetProcAddress", (void *)eglGetProcAddress}, {"eglLockSurfaceKHR", (void *)eglLockSurfaceKHR}, {"eglUnlockSurfaceKHR", (void *)eglUnlockSurfaceKHR}, {"eglCreateImageKHR", (void *)eglCreateImageKHR}, {"eglDestroyImageKHR", (void *)eglDestroyImageKHR}, {"eglCreateSyncKHR", (void *)eglCreateSyncKHR}, {"eglDestroySyncKHR", (void *)eglDestroySyncKHR}, {"eglClientWaitSyncKHR", (void *)eglClientWaitSyncKHR}, {"eglGetSyncAttribKHR", (void *)eglGetSyncAttribKHR} }; static const int egl_num_funcs = sizeof(egl_funcs_by_name) / sizeof(struct _egl_funcs_by_name); anbox-0.0~git20191115/android/opengl/system/gralloc/000077500000000000000000000000001356361734700221005ustar00rootroot00000000000000anbox-0.0~git20191115/android/opengl/system/gralloc/Android.mk000066400000000000000000000010731356361734700240120ustar00rootroot00000000000000ifneq (false,$(BUILD_EMULATOR_OPENGL_DRIVER)) LOCAL_PATH := $(call my-dir) $(call emugl-begin-shared-library,gralloc.goldfish) $(call emugl-import,libGLESv1_enc lib_renderControl_enc libOpenglSystemCommon) $(call emugl-set-shared-library-subpath,hw) LOCAL_CFLAGS += -DLOG_TAG=\"gralloc_goldfish\" LOCAL_CFLAGS += -Wno-missing-field-initializers LOCAL_SRC_FILES := gralloc.cpp # Need to access the special OPENGL TLS Slot LOCAL_C_INCLUDES += bionic/libc/private LOCAL_SHARED_LIBRARIES += libdl $(call emugl-end-module) endif # BUILD_EMULATOR_OPENGL_DRIVER != false anbox-0.0~git20191115/android/opengl/system/gralloc/gralloc.cpp000066400000000000000000000777771356361734700242600ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include #include #include #include "gralloc_cb.h" #include "HostConnection.h" #include "glUtils.h" #include #include /* Set to 1 or 2 to enable debug traces */ #define DEBUG 0 #if DEBUG >= 1 # define D(...) ALOGD(__VA_ARGS__) #else # define D(...) ((void)0) #endif #if DEBUG >= 2 # define DD(...) ALOGD(__VA_ARGS__) #else # define DD(...) ((void)0) #endif #define DBG_FUNC DBG("%s\n", __FUNCTION__) // // our private gralloc module structure // struct private_module_t { gralloc_module_t base; }; /* If not NULL, this is a pointer to the fallback module. * This really is gralloc.default, which we'll use if we detect * that the emulator we're running in does not support GPU emulation. */ static gralloc_module_t* sFallback; static pthread_once_t sFallbackOnce = PTHREAD_ONCE_INIT; static void fallback_init(void); // forward typedef struct _alloc_list_node { buffer_handle_t handle; _alloc_list_node *next; _alloc_list_node *prev; } AllocListNode; // // Our gralloc device structure (alloc interface) // struct gralloc_device_t { alloc_device_t device; AllocListNode *allocListHead; // double linked list of allocated buffers pthread_mutex_t lock; }; // // Our framebuffer device structure // struct fb_device_t { framebuffer_device_t device; }; static int map_buffer(cb_handle_t *cb, void **vaddr) { if (cb->fd < 0 || cb->ashmemSize <= 0) { return -EINVAL; } void *addr = mmap(0, cb->ashmemSize, PROT_READ | PROT_WRITE, MAP_SHARED, cb->fd, 0); if (addr == MAP_FAILED) { return -errno; } cb->ashmemBase = intptr_t(addr); cb->ashmemBasePid = getpid(); *vaddr = addr; return 0; } #define DEFINE_HOST_CONNECTION \ HostConnection *hostCon = HostConnection::get(); \ renderControl_encoder_context_t *rcEnc = (hostCon ? hostCon->rcEncoder() : NULL) #define DEFINE_AND_VALIDATE_HOST_CONNECTION \ HostConnection *hostCon = HostConnection::get(); \ if (!hostCon) { \ ALOGE("gralloc: Failed to get host connection\n"); \ return -EIO; \ } \ renderControl_encoder_context_t *rcEnc = hostCon->rcEncoder(); \ if (!rcEnc) { \ ALOGE("gralloc: Failed to get renderControl encoder context\n"); \ return -EIO; \ } // // gralloc device functions (alloc interface) // static int gralloc_alloc(alloc_device_t* dev, int w, int h, int format, int usage, buffer_handle_t* pHandle, int* pStride) { D("gralloc_alloc w=%d h=%d usage=0x%x\n", w, h, usage); gralloc_device_t *grdev = (gralloc_device_t *)dev; if (!grdev || !pHandle || !pStride) { ALOGE("gralloc_alloc: Bad inputs (grdev: %p, pHandle: %p, pStride: %p", grdev, pHandle, pStride); return -EINVAL; } // // Note: in screen capture mode, both sw_write and hw_write will be on // and this is a valid usage // bool sw_write = (0 != (usage & GRALLOC_USAGE_SW_WRITE_MASK)); bool hw_write = (usage & GRALLOC_USAGE_HW_RENDER); bool sw_read = (0 != (usage & GRALLOC_USAGE_SW_READ_MASK)); bool hw_cam_write = usage & GRALLOC_USAGE_HW_CAMERA_WRITE; bool hw_cam_read = usage & GRALLOC_USAGE_HW_CAMERA_READ; bool hw_vid_enc_read = usage & GRALLOC_USAGE_HW_VIDEO_ENCODER; // Keep around original requested format for later validation int frameworkFormat = format; // Pick the right concrete pixel format given the endpoints as encoded in // the usage bits. Every end-point pair needs explicit listing here. if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) { // Camera as producer if (usage & GRALLOC_USAGE_HW_CAMERA_WRITE) { if (usage & GRALLOC_USAGE_HW_TEXTURE) { // Camera-to-display is RGBA format = HAL_PIXEL_FORMAT_RGBA_8888; } else if (usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) { // Camera-to-encoder is NV21 format = HAL_PIXEL_FORMAT_YCrCb_420_SP; } else if ((usage & GRALLOC_USAGE_HW_CAMERA_MASK) == GRALLOC_USAGE_HW_CAMERA_ZSL) { // Camera-to-ZSL-queue is RGB_888 format = HAL_PIXEL_FORMAT_RGB_888; } } if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) { ALOGE("gralloc_alloc: Requested auto format selection, " "but no known format for this usage: %d x %d, usage %x", w, h, usage); return -EINVAL; } } else if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) { // Flexible framework-accessible YUV format; map to NV21 for now if (usage & GRALLOC_USAGE_HW_CAMERA_WRITE) { format = HAL_PIXEL_FORMAT_YCrCb_420_SP; } if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) { ALOGE("gralloc_alloc: Requested YCbCr_420_888, but no known " "specific format for this usage: %d x %d, usage %x", w, h, usage); } } bool yuv_format = false; int ashmem_size = 0; int stride = w; GLenum glFormat = 0; GLenum glType = 0; int bpp = 0; int align = 1; switch (format) { case HAL_PIXEL_FORMAT_RGBA_8888: case HAL_PIXEL_FORMAT_RGBX_8888: case HAL_PIXEL_FORMAT_BGRA_8888: bpp = 4; glFormat = GL_RGBA; glType = GL_UNSIGNED_BYTE; break; case HAL_PIXEL_FORMAT_RGB_888: bpp = 3; glFormat = GL_RGB; glType = GL_UNSIGNED_BYTE; break; case HAL_PIXEL_FORMAT_RGB_565: bpp = 2; glFormat = GL_RGB; glType = GL_UNSIGNED_SHORT_5_6_5; break; case HAL_PIXEL_FORMAT_RAW16: case HAL_PIXEL_FORMAT_Y16: bpp = 2; align = 16*bpp; if (! ((sw_read || hw_cam_read) && (sw_write || hw_cam_write) ) ) { // Raw sensor data or Y16 only goes between camera and CPU return -EINVAL; } // Not expecting to actually create any GL surfaces for this glFormat = GL_LUMINANCE; glType = GL_UNSIGNED_SHORT; break; case HAL_PIXEL_FORMAT_BLOB: bpp = 1; if (! (sw_read && hw_cam_write) ) { // Blob data cannot be used by HW other than camera emulator return -EINVAL; } // Not expecting to actually create any GL surfaces for this glFormat = GL_LUMINANCE; glType = GL_UNSIGNED_BYTE; break; case HAL_PIXEL_FORMAT_YCrCb_420_SP: align = 1; bpp = 1; // per-channel bpp yuv_format = true; // Not expecting to actually create any GL surfaces for this break; case HAL_PIXEL_FORMAT_YV12: align = 16; bpp = 1; // per-channel bpp yuv_format = true; // Not expecting to actually create any GL surfaces for this break; default: ALOGE("gralloc_alloc: Unknown format %d", format); return -EINVAL; } if (usage & GRALLOC_USAGE_HW_FB) { // keep space for postCounter ashmem_size += sizeof(uint32_t); } if (sw_read || sw_write || hw_cam_write || hw_vid_enc_read) { // keep space for image on guest memory if SW access is needed // or if the camera is doing writing if (yuv_format) { size_t yStride = (w*bpp + (align - 1)) & ~(align-1); size_t uvStride = (yStride / 2 + (align - 1)) & ~(align-1); size_t uvHeight = h / 2; ashmem_size += yStride * h + 2 * (uvHeight * uvStride); stride = yStride / bpp; } else { size_t bpr = (w*bpp + (align-1)) & ~(align-1); ashmem_size += (bpr * h); stride = bpr / bpp; } } D("gralloc_alloc format=%d, ashmem_size=%d, stride=%d, tid %d\n", format, ashmem_size, stride, gettid()); // // Allocate space in ashmem if needed // int fd = -1; if (ashmem_size > 0) { // round to page size; ashmem_size = (ashmem_size + (PAGE_SIZE-1)) & ~(PAGE_SIZE-1); fd = ashmem_create_region("gralloc-buffer", ashmem_size); if (fd < 0) { ALOGE("gralloc_alloc failed to create ashmem region: %s\n", strerror(errno)); return -errno; } } cb_handle_t *cb = new cb_handle_t(fd, ashmem_size, usage, w, h, frameworkFormat, format, glFormat, glType); if (ashmem_size > 0) { // // map ashmem region if exist // void *vaddr; int err = map_buffer(cb, &vaddr); if (err) { close(fd); delete cb; return err; } cb->setFd(fd); } // // Allocate ColorBuffer handle on the host (only if h/w access is allowed) // Only do this for some h/w usages, not all. // Also do this if we need to read from the surface, in this case the // rendering will still happen on the host but we also need to be able to // read back from the color buffer, which requires that there is a buffer // if (usage & (GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_2D | GRALLOC_USAGE_HW_COMPOSER | GRALLOC_USAGE_HW_FB | GRALLOC_USAGE_SW_READ_MASK) ) { DEFINE_HOST_CONNECTION; if (hostCon && rcEnc) { cb->hostHandle = rcEnc->rcCreateColorBuffer(rcEnc, w, h, glFormat); D("Created host ColorBuffer 0x%x\n", cb->hostHandle); } if (!cb->hostHandle) { // Could not create colorbuffer on host !!! close(fd); delete cb; return -EIO; } } // // alloc succeeded - insert the allocated handle to the allocated list // AllocListNode *node = new AllocListNode(); pthread_mutex_lock(&grdev->lock); node->handle = cb; node->next = grdev->allocListHead; node->prev = NULL; if (grdev->allocListHead) { grdev->allocListHead->prev = node; } grdev->allocListHead = node; pthread_mutex_unlock(&grdev->lock); *pHandle = cb; if (frameworkFormat == HAL_PIXEL_FORMAT_YCbCr_420_888) { *pStride = 0; } else { *pStride = stride; } return 0; } static int gralloc_free(alloc_device_t* dev, buffer_handle_t handle) { const cb_handle_t *cb = (const cb_handle_t *)handle; if (!cb_handle_t::validate((cb_handle_t*)cb)) { ERR("gralloc_free: invalid handle"); return -EINVAL; } if (cb->hostHandle != 0) { DEFINE_AND_VALIDATE_HOST_CONNECTION; D("Closing host ColorBuffer 0x%x\n", cb->hostHandle); rcEnc->rcCloseColorBuffer(rcEnc, cb->hostHandle); } // // detach and unmap ashmem area if present // if (cb->fd > 0) { if (cb->ashmemSize > 0 && cb->ashmemBase) { munmap((void *)cb->ashmemBase, cb->ashmemSize); } close(cb->fd); } // remove it from the allocated list gralloc_device_t *grdev = (gralloc_device_t *)dev; pthread_mutex_lock(&grdev->lock); AllocListNode *n = grdev->allocListHead; while( n && n->handle != cb ) { n = n->next; } if (n) { // buffer found on list - remove it from list if (n->next) { n->next->prev = n->prev; } if (n->prev) { n->prev->next = n->next; } else { grdev->allocListHead = n->next; } delete n; } pthread_mutex_unlock(&grdev->lock); delete cb; return 0; } static int gralloc_device_close(struct hw_device_t *dev) { gralloc_device_t* d = reinterpret_cast(dev); if (d) { // free still allocated buffers while( d->allocListHead != NULL ) { gralloc_free(&d->device, d->allocListHead->handle); } // free device free(d); } return 0; } static int fb_compositionComplete(struct framebuffer_device_t* dev) { (void)dev; return 0; } // // Framebuffer device functions // static int fb_post(struct framebuffer_device_t* dev, buffer_handle_t buffer) { fb_device_t *fbdev = (fb_device_t *)dev; cb_handle_t *cb = (cb_handle_t *)buffer; if (!fbdev || !cb_handle_t::validate(cb) || !cb->canBePosted()) { return -EINVAL; } // Make sure we have host connection DEFINE_AND_VALIDATE_HOST_CONNECTION; // increment the post count of the buffer intptr_t *postCountPtr = (intptr_t *)cb->ashmemBase; if (!postCountPtr) { // This should not happen return -EINVAL; } (*postCountPtr)++; // send post request to host rcEnc->rcFBPost(rcEnc, cb->hostHandle); hostCon->flush(); return 0; } static int fb_setUpdateRect(struct framebuffer_device_t* dev, int l, int t, int w, int h) { fb_device_t *fbdev = (fb_device_t *)dev; (void)l; (void)t; (void)w; (void)h; if (!fbdev) { return -EINVAL; } // Make sure we have host connection DEFINE_AND_VALIDATE_HOST_CONNECTION; // send request to host // TODO: XXX - should be implemented //rcEnc->rc_XXX return 0; } static int fb_setSwapInterval(struct framebuffer_device_t* dev, int interval) { fb_device_t *fbdev = (fb_device_t *)dev; if (!fbdev) { return -EINVAL; } // Make sure we have host connection DEFINE_AND_VALIDATE_HOST_CONNECTION; // send request to host rcEnc->rcFBSetSwapInterval(rcEnc, interval); hostCon->flush(); return 0; } static int fb_close(struct hw_device_t *dev) { fb_device_t *fbdev = (fb_device_t *)dev; delete fbdev; return 0; } // // gralloc module functions - refcount + locking interface // static int gralloc_register_buffer(gralloc_module_t const* module, buffer_handle_t handle) { pthread_once(&sFallbackOnce, fallback_init); if (sFallback != NULL) { return sFallback->registerBuffer(sFallback, handle); } D("gralloc_register_buffer(%p) called", handle); private_module_t *gr = (private_module_t *)module; cb_handle_t *cb = (cb_handle_t *)handle; if (!gr || !cb_handle_t::validate(cb)) { ERR("gralloc_register_buffer(%p): invalid buffer", cb); return -EINVAL; } if (cb->hostHandle != 0) { DEFINE_AND_VALIDATE_HOST_CONNECTION; D("Opening host ColorBuffer 0x%x\n", cb->hostHandle); rcEnc->rcOpenColorBuffer2(rcEnc, cb->hostHandle); } // // if the color buffer has ashmem region and it is not mapped in this // process map it now. // if (cb->ashmemSize > 0 && cb->mappedPid != getpid()) { void *vaddr; int err = map_buffer(cb, &vaddr); if (err) { ERR("gralloc_register_buffer(%p): map failed: %s", cb, strerror(-err)); return -err; } cb->mappedPid = getpid(); } return 0; } static int gralloc_unregister_buffer(gralloc_module_t const* module, buffer_handle_t handle) { if (sFallback != NULL) { return sFallback->unregisterBuffer(sFallback, handle); } private_module_t *gr = (private_module_t *)module; cb_handle_t *cb = (cb_handle_t *)handle; if (!gr || !cb_handle_t::validate(cb)) { ERR("gralloc_unregister_buffer(%p): invalid buffer", cb); return -EINVAL; } if (cb->hostHandle != 0) { DEFINE_AND_VALIDATE_HOST_CONNECTION; D("Closing host ColorBuffer 0x%x\n", cb->hostHandle); rcEnc->rcCloseColorBuffer(rcEnc, cb->hostHandle); } // // unmap ashmem region if it was previously mapped in this process // (through register_buffer) // if (cb->ashmemSize > 0 && cb->mappedPid == getpid()) { void *vaddr; int err = munmap((void *)cb->ashmemBase, cb->ashmemSize); if (err) { ERR("gralloc_unregister_buffer(%p): unmap failed", cb); return -EINVAL; } cb->ashmemBase = 0; cb->mappedPid = 0; } D("gralloc_unregister_buffer(%p) done\n", cb); return 0; } static int gralloc_lock(gralloc_module_t const* module, buffer_handle_t handle, int usage, int l, int t, int w, int h, void** vaddr) { if (sFallback != NULL) { return sFallback->lock(sFallback, handle, usage, l, t, w, h, vaddr); } private_module_t *gr = (private_module_t *)module; cb_handle_t *cb = (cb_handle_t *)handle; if (!gr || !cb_handle_t::validate(cb)) { ALOGE("gralloc_lock bad handle\n"); return -EINVAL; } // validate format if (cb->frameworkFormat == HAL_PIXEL_FORMAT_YCbCr_420_888) { ALOGE("gralloc_lock can't be used with YCbCr_420_888 format"); return -EINVAL; } // Validate usage, // 1. cannot be locked for hw access // 2. lock for either sw read or write. // 3. locked sw access must match usage during alloc time. bool sw_read = (0 != (usage & GRALLOC_USAGE_SW_READ_MASK)); bool sw_write = (0 != (usage & GRALLOC_USAGE_SW_WRITE_MASK)); bool hw_read = (usage & GRALLOC_USAGE_HW_TEXTURE); bool hw_write = (usage & GRALLOC_USAGE_HW_RENDER); bool hw_vid_enc_read = (usage & GRALLOC_USAGE_HW_VIDEO_ENCODER); bool hw_cam_write = (usage & GRALLOC_USAGE_HW_CAMERA_WRITE); bool hw_cam_read = (usage & GRALLOC_USAGE_HW_CAMERA_READ); bool sw_read_allowed = (0 != (cb->usage & GRALLOC_USAGE_SW_READ_MASK)); bool sw_write_allowed = (0 != (cb->usage & GRALLOC_USAGE_SW_WRITE_MASK)); if ( (hw_read || hw_write) || (!sw_read && !sw_write && !hw_cam_write && !hw_cam_read && !hw_vid_enc_read) || (sw_read && !sw_read_allowed) || (sw_write && !sw_write_allowed) ) { ALOGE("gralloc_lock usage mismatch usage=0x%x cb->usage=0x%x\n", usage, cb->usage); return -EINVAL; } intptr_t postCount = 0; void *cpu_addr = NULL; // // make sure ashmem area is mapped if needed // if (cb->canBePosted() || sw_read || sw_write || hw_cam_write || hw_cam_read || hw_vid_enc_read) { if (cb->ashmemBasePid != getpid() || !cb->ashmemBase) { return -EACCES; } if (cb->canBePosted()) { postCount = *((intptr_t *)cb->ashmemBase); cpu_addr = (void *)(cb->ashmemBase + sizeof(intptr_t)); } else { cpu_addr = (void *)(cb->ashmemBase); } } if (cb->hostHandle) { // Make sure we have host connection DEFINE_AND_VALIDATE_HOST_CONNECTION; // // flush color buffer write cache on host and get its sync status. // int hostSyncStatus = rcEnc->rcColorBufferCacheFlush(rcEnc, cb->hostHandle, postCount, sw_read); if (hostSyncStatus < 0) { // host failed the color buffer sync - probably since it was already // locked for write access. fail the lock. ALOGE("gralloc_lock cacheFlush failed postCount=%d sw_read=%d\n", postCount, sw_read); return -EBUSY; } if (sw_read) { D("gralloc_lock read back color buffer %d %d\n", cb->width, cb->height); rcEnc->rcReadColorBuffer(rcEnc, cb->hostHandle, 0, 0, cb->width, cb->height, cb->glFormat, cb->glType, cpu_addr); } } // // is virtual address required ? // if (sw_read || sw_write || hw_cam_write || hw_cam_read || hw_vid_enc_read) { *vaddr = cpu_addr; } if (sw_write || hw_cam_write) { // // Keep locked region if locked for s/w write access. // cb->lockedLeft = l; cb->lockedTop = t; cb->lockedWidth = w; cb->lockedHeight = h; } DD("gralloc_lock success. vaddr: %p, *vaddr: %p, usage: %x, cpu_addr: %p", vaddr, vaddr ? *vaddr : 0, usage, cpu_addr); return 0; } static int gralloc_unlock(gralloc_module_t const* module, buffer_handle_t handle) { if (sFallback != NULL) { return sFallback->unlock(sFallback, handle); } private_module_t *gr = (private_module_t *)module; cb_handle_t *cb = (cb_handle_t *)handle; if (!gr || !cb_handle_t::validate(cb)) { return -EINVAL; } // // if buffer was locked for s/w write, we need to update the host with // the updated data // if (cb->hostHandle) { // Make sure we have host connection DEFINE_AND_VALIDATE_HOST_CONNECTION; void *cpu_addr; if (cb->canBePosted()) { cpu_addr = (void *)(cb->ashmemBase + sizeof(int)); } else { cpu_addr = (void *)(cb->ashmemBase); } if (cb->lockedWidth < cb->width || cb->lockedHeight < cb->height) { int bpp = glUtilsPixelBitSize(cb->glFormat, cb->glType) >> 3; char *tmpBuf = new char[cb->lockedWidth * cb->lockedHeight * bpp]; int dst_line_len = cb->lockedWidth * bpp; int src_line_len = cb->width * bpp; char *src = (char *)cpu_addr + cb->lockedTop*src_line_len + cb->lockedLeft*bpp; char *dst = tmpBuf; for (int y=0; ylockedHeight; y++) { memcpy(dst, src, dst_line_len); src += src_line_len; dst += dst_line_len; } rcEnc->rcUpdateColorBuffer(rcEnc, cb->hostHandle, cb->lockedLeft, cb->lockedTop, cb->lockedWidth, cb->lockedHeight, cb->glFormat, cb->glType, tmpBuf); delete [] tmpBuf; } else { rcEnc->rcUpdateColorBuffer(rcEnc, cb->hostHandle, 0, 0, cb->width, cb->height, cb->glFormat, cb->glType, cpu_addr); } } cb->lockedWidth = cb->lockedHeight = 0; return 0; } static int gralloc_lock_ycbcr(gralloc_module_t const* module, buffer_handle_t handle, int usage, int l, int t, int w, int h, android_ycbcr *ycbcr) { // Not supporting fallback module for YCbCr if (sFallback != NULL) { return -EINVAL; } if (!ycbcr) { ALOGE("gralloc_lock_ycbcr got NULL ycbcr struct"); return -EINVAL; } private_module_t *gr = (private_module_t *)module; cb_handle_t *cb = (cb_handle_t *)handle; if (!gr || !cb_handle_t::validate(cb)) { ALOGE("gralloc_lock_ycbcr bad handle\n"); return -EINVAL; } if (cb->frameworkFormat != HAL_PIXEL_FORMAT_YCbCr_420_888) { ALOGE("gralloc_lock_ycbcr can only be used with " "HAL_PIXEL_FORMAT_YCbCr_420_888, got %x instead", cb->frameworkFormat); return -EINVAL; } // Validate usage // For now, only allow camera write, software read. bool sw_read = (0 != (usage & GRALLOC_USAGE_SW_READ_MASK)); bool hw_cam_write = (usage & GRALLOC_USAGE_HW_CAMERA_WRITE); bool sw_read_allowed = (0 != (cb->usage & GRALLOC_USAGE_SW_READ_MASK)); if ( (!hw_cam_write && !sw_read) || (sw_read && !sw_read_allowed) ) { ALOGE("gralloc_lock_ycbcr usage mismatch usage:0x%x cb->usage:0x%x\n", usage, cb->usage); return -EINVAL; } // Make sure memory is mapped, get address if (cb->ashmemBasePid != getpid() || !cb->ashmemBase) { return -EACCES; } uint8_t *cpu_addr = NULL; if (cb->canBePosted()) { cpu_addr = (uint8_t *)(cb->ashmemBase + sizeof(int)); } else { cpu_addr = (uint8_t *)(cb->ashmemBase); } // Calculate offsets to underlying YUV data size_t yStride; size_t cStride; size_t yOffset; size_t uOffset; size_t vOffset; size_t cStep; switch (cb->format) { case HAL_PIXEL_FORMAT_YCrCb_420_SP: yStride = cb->width; cStride = cb->width; yOffset = 0; vOffset = yStride * cb->height; uOffset = vOffset + 1; cStep = 2; break; default: ALOGE("gralloc_lock_ycbcr unexpected internal format %x", cb->format); return -EINVAL; } ycbcr->y = cpu_addr + yOffset; ycbcr->cb = cpu_addr + uOffset; ycbcr->cr = cpu_addr + vOffset; ycbcr->ystride = yStride; ycbcr->cstride = cStride; ycbcr->chroma_step = cStep; // Zero out reserved fields memset(ycbcr->reserved, 0, sizeof(ycbcr->reserved)); // // Keep locked region if locked for s/w write access. // cb->lockedLeft = l; cb->lockedTop = t; cb->lockedWidth = w; cb->lockedHeight = h; DD("gralloc_lock_ycbcr success. usage: %x, ycbcr.y: %p, .cb: %p, .cr: %p, " ".ystride: %d , .cstride: %d, .chroma_step: %d", usage, ycbcr->y, ycbcr->cb, ycbcr->cr, ycbcr->ystride, ycbcr->cstride, ycbcr->chroma_step); return 0; } static int gralloc_device_open(const hw_module_t* module, const char* name, hw_device_t** device) { int status = -EINVAL; D("gralloc_device_open %s\n", name); pthread_once( &sFallbackOnce, fallback_init ); if (sFallback != NULL) { return sFallback->common.methods->open(&sFallback->common, name, device); } if (!strcmp(name, GRALLOC_HARDWARE_GPU0)) { // Create host connection and keep it in the TLS. // return error if connection with host can not be established HostConnection *hostCon = HostConnection::get(); if (!hostCon) { ALOGE("gralloc: failed to get host connection while opening %s\n", name); return -EIO; } // // Allocate memory for the gralloc device (alloc interface) // gralloc_device_t *dev; dev = (gralloc_device_t*)malloc(sizeof(gralloc_device_t)); if (NULL == dev) { return -ENOMEM; } // Initialize our device structure // dev->device.common.tag = HARDWARE_DEVICE_TAG; dev->device.common.version = 0; dev->device.common.module = const_cast(module); dev->device.common.close = gralloc_device_close; dev->device.alloc = gralloc_alloc; dev->device.free = gralloc_free; dev->allocListHead = NULL; pthread_mutex_init(&dev->lock, NULL); *device = &dev->device.common; status = 0; } else if (!strcmp(name, GRALLOC_HARDWARE_FB0)) { // return error if connection with host can not be established DEFINE_AND_VALIDATE_HOST_CONNECTION; // // Query the host for Framebuffer attributes // D("gralloc: query Frabuffer attribs\n"); EGLint width = rcEnc->rcGetFBParam(rcEnc, FB_WIDTH); D("gralloc: width=%d\n", width); EGLint height = rcEnc->rcGetFBParam(rcEnc, FB_HEIGHT); D("gralloc: height=%d\n", height); EGLint xdpi = rcEnc->rcGetFBParam(rcEnc, FB_XDPI); D("gralloc: xdpi=%d\n", xdpi); EGLint ydpi = rcEnc->rcGetFBParam(rcEnc, FB_YDPI); D("gralloc: ydpi=%d\n", ydpi); EGLint fps = rcEnc->rcGetFBParam(rcEnc, FB_FPS); D("gralloc: fps=%d\n", fps); EGLint min_si = rcEnc->rcGetFBParam(rcEnc, FB_MIN_SWAP_INTERVAL); D("gralloc: min_swap=%d\n", min_si); EGLint max_si = rcEnc->rcGetFBParam(rcEnc, FB_MAX_SWAP_INTERVAL); D("gralloc: max_swap=%d\n", max_si); // // Allocate memory for the framebuffer device // fb_device_t *dev; dev = (fb_device_t*)malloc(sizeof(fb_device_t)); if (NULL == dev) { return -ENOMEM; } memset(dev, 0, sizeof(fb_device_t)); // Initialize our device structure // dev->device.common.tag = HARDWARE_DEVICE_TAG; dev->device.common.version = 0; dev->device.common.module = const_cast(module); dev->device.common.close = fb_close; dev->device.setSwapInterval = fb_setSwapInterval; dev->device.post = fb_post; dev->device.setUpdateRect = 0; //fb_setUpdateRect; dev->device.compositionComplete = fb_compositionComplete; //XXX: this is a dummy const_cast(dev->device.flags) = 0; const_cast(dev->device.width) = width; const_cast(dev->device.height) = height; const_cast(dev->device.stride) = width; const_cast(dev->device.format) = HAL_PIXEL_FORMAT_RGBA_8888; const_cast(dev->device.xdpi) = xdpi; const_cast(dev->device.ydpi) = ydpi; const_cast(dev->device.fps) = fps; const_cast(dev->device.minSwapInterval) = min_si; const_cast(dev->device.maxSwapInterval) = max_si; *device = &dev->device.common; status = 0; } return status; } // // define the HMI symbol - our module interface // static struct hw_module_methods_t gralloc_module_methods = { open: gralloc_device_open }; struct private_module_t HAL_MODULE_INFO_SYM = { base: { common: { tag: HARDWARE_MODULE_TAG, module_api_version: GRALLOC_MODULE_API_VERSION_0_2, hal_api_version: 0, id: GRALLOC_HARDWARE_MODULE_ID, name: "Graphics Memory Allocator Module", author: "The Android Open Source Project", methods: &gralloc_module_methods, dso: NULL, reserved: {0, } }, registerBuffer: gralloc_register_buffer, unregisterBuffer: gralloc_unregister_buffer, lock: gralloc_lock, unlock: gralloc_unlock, perform: NULL, lock_ycbcr: gralloc_lock_ycbcr, } }; /* This function is called once to detect whether the emulator supports * GPU emulation (this is done by looking at the qemu.gles kernel * parameter, which must be == 1 if this is the case). * * If not, then load gralloc.default instead as a fallback. */ static void fallback_init(void) { char prop[PROPERTY_VALUE_MAX]; void* module; // qemu.gles=0 -> no GLES 2.x support (only 1.x through software). // qemu.gles=1 -> host-side GPU emulation through EmuGL // qemu.gles=2 -> guest-side GPU emulation. property_get("ro.kernel.qemu.gles", prop, "0"); if (atoi(prop) == 1) { return; } ALOGD("Emulator without host-side GPU emulation detected."); #if __LP64__ module = dlopen("/system/lib64/hw/gralloc.default.so", RTLD_LAZY|RTLD_LOCAL); #else module = dlopen("/system/lib/hw/gralloc.default.so", RTLD_LAZY|RTLD_LOCAL); #endif if (module != NULL) { sFallback = reinterpret_cast(dlsym(module, HAL_MODULE_INFO_SYM_AS_STR)); if (sFallback == NULL) { dlclose(module); } } if (sFallback == NULL) { ALOGE("Could not find software fallback module!?"); } } anbox-0.0~git20191115/android/opengl/system/renderControl_enc/000077500000000000000000000000001356361734700241225ustar00rootroot00000000000000anbox-0.0~git20191115/android/opengl/system/renderControl_enc/Android.mk000066400000000000000000000004761356361734700260420ustar00rootroot00000000000000LOCAL_PATH := $(call my-dir) $(call emugl-begin-shared-library,lib_renderControl_enc) LOCAL_SRC_FILES := \ renderControl_client_context.cpp \ renderControl_enc.cpp \ renderControl_entry.cpp $(call emugl-export,C_INCLUDES,$(LOCAL_PATH)) $(call emugl-import,libOpenglCodecCommon) $(call emugl-end-module) anbox-0.0~git20191115/android/opengl/system/renderControl_enc/README000066400000000000000000000161241356361734700250060ustar00rootroot00000000000000The renderControl.in file in this directory defines an API which is decoded on the android guest into a stream and get decoded and executed on the host. It is used in order to query the host renderer as well as send the host renderer control commands. The following describes each of the entries defined by this renderControl API. GLint rcGetRendererVersion(); This function queries the host renderer version number. EGLint rcGetEGLVersion(EGLint* major, EGLint* minor); This function queries the host renderer for the EGL version it supports. returns EGL_FALSE on failure. EGLint rcQueryEGLString(EGLenum name, void* buffer, EGLint bufferSize); This function queries the host for EGL string (.i.e EGL_EXTENSIONS). if buffer is NULL or the bufferSize is not big enough the return value is the negative number of bytes required to store the string value otherwise the string value is copied to buffer and its size is returned. EGLint rcGetNumConfigs(uint32_t* numAttribs); queries the host for the number of supported EGL configs. The function returns the number of supported configs and returns in numAttribs the number of attributes available for each config. EGLint rcGetConfigs(uint32_t bufSize, GLuint* buffer); This function queries the host for the all set of supported configs with their attribute values. bufSize is the size of buffer, the size should be at least equal to (numConfigs + 1) * numAttribs * sizeof(GLuint) where numConfigs and numAttribs are the values returned in rcGetNumConfigs. if bufSize is not big enough then the negative number of required bytes is returned otherwise the function returns the number of configs and buffer is filled as follows: The first 'numAttribs' integer values are filled with the EGL enumerant describing a config attribute, next for each config there are 'numAttribs' integer values holding the attribute values for that config, the values are specified in the same order as the attribute vector. EGLint rcChooseConfig(EGLint *attribs, uint32_t attribs_size, uint32_t *configs, uint32_t configs_size) This function triggers an eglChooseConfig on the host, to get a list of configs matching the given attribs values. attribs - a list of attribute names followed by the desired values, terminated by EGL_NONE attribs_size - the size of the list configs - the returned matching configuration names (same names as familiar to the client in rcGetConfigs) configs_size - the size of the configs buffers returns - the actual number of matching configurations (<= configs_size) EGLint rcGetFBParam(EGLint param); queries the host for framebuffer parameter, see renderControl_types.h for possible values of 'param'. uint32_t rcCreateContext(uint32_t config, uint32_t share, uint32_t glVersion); This function creates a rendering context on the host and returns its handle. config is the config index for the context, share is either zero or a handle to a sharing context. glVersion is either 1 or 2 for GLES1 or GLES2 context respectively. void rcDestroyContext(uint32_t context); This function destroys a rendering context on the host. context is a handle returned in rcCreateContext. uint32_t rcCreateWindowSurface(uint32_t config, uint32_t width, uint32_t height); This function creates a 'window' surface on the host which can be then bind for rendering through rcMakeCurrent. The function returns a handle to the created window surface. void rcDestroyWindowSurface(uint32_t windowSurface); This function destoys a window surface. uint32_t rcCreateColorBuffer(uint32_t width, uint32_t height, GLenum internalFormat); This function creates a colorBuffer object on the host which can be then be specified as a render target for a window surface through rcSetWindowColorBuffer or to be displayed on the framebuffer window through rcFBPost. The function returns a handle to the colorBuffer object, with an initial reference count of 1. void rcOpenColorBuffer(uint32_t colorbuffer); Adds an additional reference to the colorbuffer, typically from a different Android process than the one which created it. void rcCloseColorBuffer(uint32_t colorbuffer); Removes a reference to the colorbuffer. When the reference count drops to zero the colorbuffer is automatically destroyed. void rcFlushWindowColorBuffer(uint32_t windowSurface, uint32_t colorBuffer); This flushes the current window color buffer void rcSetWindowColorBuffer(uint32_t windowSurface, uint32_t colorBuffer); This set the target color buffer for a windowSurface, when set the previous target colorBuffer gets updated before switching to the new colorBuffer. EGLint rcMakeCurrent(uint32_t context, uint32_t drawSurf, uint32_t readSurf); Binds a windowSurface(s) and current rendering context for the calling thread. void rcFBPost(uint32_t colorBuffer); This function causes the content of the colorBuffer object to be displayed on the host framebuffer window. The function returns immediatly, the buffer will be displayed at the next swap interval. void rcFBSetSwapInterval(EGLint interval); Sets the swap interval for the host framebuffer window. void rcBindTexture(uint32_t colorBuffer); This function instruct the host to bind the content of the specified colorBuffer to the current binded texture object of the calling thread. This function should be used to implement eglBindTexImage. EGLint rcColorBufferCacheFlush(uint32_t colorbuffer, EGLint postCount, int forRead); This function returns only after all rendering requests for the specified colorBuffer rendering target has been processed and after all 'postCount' posts for the buffer requested previously through rcFBPost has been processed. if 'forRead' is not-zero, the function returns positive value in case there was rendering done to the buffer since the last CacheFlush request with non-zero 'forRead' value, otherwise the function returns zero or negative value on failure. void rcReadColorBuffer(uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels); This function queries the host for the pixel content of a colorBuffer's subregion. It act the same as OpenGL glReadPixels however pixels are always packed with alignment of 1. void rcUpdateColorBuffer(uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels); Updates the content of a subregion of a colorBuffer object. pixels are always unpacked with alignment of 1. uint32_t rcCreateClientImage(uint32_t context, EGLenum target, GLuint buffer) Create an EGLImage from a client object. int rcDestroyClientImage(uint32_t image) Destroy an EGLImage object. anbox-0.0~git20191115/android/opengl/system/renderControl_enc/renderControl.attrib000066400000000000000000000016161356361734700301550ustar00rootroot00000000000000GLOBAL base_opcode 10000 encoder_headers "glUtils.h" rcGetEGLVersion dir major out len major sizeof(EGLint) dir minor out len minor sizeof(EGLint) rcQueryEGLString dir buffer out len buffer bufferSize rcGetGLString dir buffer out len buffer bufferSize rcGetNumConfigs dir numAttribs out len numAttribs sizeof(uint32_t) rcGetConfigs dir buffer out len buffer bufSize rcChooseConfig dir attribs in len attribs attribs_size dir configs out var_flag configs nullAllowed len configs configs_size*sizeof(uint32_t) rcReadColorBuffer dir pixels out len pixels (((glUtilsPixelBitSize(format, type) * width) >> 3) * height) rcUpdateColorBuffer dir pixels in len pixels (((glUtilsPixelBitSize(format, type) * width) >> 3) * height) var_flag pixels isLarge rcCloseColorBuffer flag flushOnEncode anbox-0.0~git20191115/android/opengl/system/renderControl_enc/renderControl.in000066400000000000000000000046261356361734700273020ustar00rootroot00000000000000GL_ENRTY(GLint, rcGetRendererVersion) GL_ENTRY(EGLint, rcGetEGLVersion, EGLint *major, EGLint *minor) GL_ENTRY(EGLint, rcQueryEGLString, EGLenum name, void *buffer, EGLint bufferSize) GL_ENTRY(EGLint, rcGetGLString, EGLenum name, void *buffer, EGLint bufferSize) GL_ENTRY(EGLint, rcGetNumConfigs, uint32_t *numAttribs) GL_ENTRY(EGLint, rcGetConfigs, uint32_t bufSize, GLuint *buffer) GL_ENTRY(EGLint, rcChooseConfig, EGLint *attribs, uint32_t attribs_size, uint32_t *configs, uint32_t configs_size) GL_ENTRY(EGLint, rcGetFBParam, EGLint param) GL_ENTRY(uint32_t, rcCreateContext, uint32_t config, uint32_t share, uint32_t glVersion) GL_ENTRY(void, rcDestroyContext, uint32_t context) GL_ENTRY(uint32_t, rcCreateWindowSurface, uint32_t config, uint32_t width, uint32_t height) GL_ENTRY(void, rcDestroyWindowSurface, uint32_t windowSurface) GL_ENTRY(uint32_t, rcCreateColorBuffer, uint32_t width, uint32_t height, GLenum internalFormat) GL_ENTRY(void, rcOpenColorBuffer, uint32_t colorbuffer) GL_ENTRY(void, rcCloseColorBuffer, uint32_t colorbuffer) GL_ENTRY(void, rcSetWindowColorBuffer, uint32_t windowSurface, uint32_t colorBuffer) GL_ENTRY(int, rcFlushWindowColorBuffer, uint32_t windowSurface) GL_ENTRY(EGLint, rcMakeCurrent, uint32_t context, uint32_t drawSurf, uint32_t readSurf) GL_ENTRY(void, rcFBPost, uint32_t colorBuffer) GL_ENTRY(void, rcFBSetSwapInterval, EGLint interval) GL_ENTRY(void, rcBindTexture, uint32_t colorBuffer) GL_ENTRY(void, rcBindRenderbuffer, uint32_t colorBuffer) GL_ENTRY(EGLint, rcColorBufferCacheFlush, uint32_t colorbuffer, EGLint postCount,int forRead) GL_ENTRY(void, rcReadColorBuffer, uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void *pixels) GL_ENTRY(int, rcUpdateColorBuffer, uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void *pixels) GL_ENTRY(int, rcOpenColorBuffer2, uint32_t colorbuffer) GL_ENTRY(uint32_t, rcCreateClientImage, uint32_t context, EGLenum target, GLuint buffer) GL_ENTRY(int, rcDestroyClientImage, uint32_t image) GL_ENTRY(void, rcSelectChecksumHelper, uint32_t newProtocol, uint32_t reserved) GL_ENTRY(int, rcGetNumDisplays) GL_ENTRY(int, rcGetDisplayWidth, uint32_t displayId) GL_ENTRY(int, rcGetDisplayHeight, uint32_t displayId) GL_ENTRY(int, rcGetDisplayDpiX, uint32_t displayId) GL_ENTRY(int, rcGetDisplayDpiY, uint32_t displayId) GL_ENTRY(int, rcGetDisplayVsyncPeriod, uint32_t displayId) anbox-0.0~git20191115/android/opengl/system/renderControl_enc/renderControl.types000066400000000000000000000003761356361734700300360ustar00rootroot00000000000000uint32_t 32 0x%08x false EGLint 32 0x%08x false GLint 32 0x%08x false GLuint 32 0x%08x false GLenum 32 0x%08x false EGLenum 32 0x%08x false uint32_t* 32 0x%08x true EGLint* 32 0x%08x true GLint* 32 0x%08x true GLuint* 32 0x%08x true void* 32 0x%08x true anbox-0.0~git20191115/android/opengl/system/renderControl_enc/renderControl_client_base.h000066400000000000000000000032331356361734700314440ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef __renderControl_client_base_t_h #define __renderControl_client_base_t_h #include "renderControl_client_proc.h" struct renderControl_client_base_t { rcGetRendererVersion_client_proc_t rcGetRendererVersion; rcGetEGLVersion_client_proc_t rcGetEGLVersion; rcQueryEGLString_client_proc_t rcQueryEGLString; rcGetGLString_client_proc_t rcGetGLString; rcGetNumConfigs_client_proc_t rcGetNumConfigs; rcGetConfigs_client_proc_t rcGetConfigs; rcChooseConfig_client_proc_t rcChooseConfig; rcGetFBParam_client_proc_t rcGetFBParam; rcCreateContext_client_proc_t rcCreateContext; rcDestroyContext_client_proc_t rcDestroyContext; rcCreateWindowSurface_client_proc_t rcCreateWindowSurface; rcDestroyWindowSurface_client_proc_t rcDestroyWindowSurface; rcCreateColorBuffer_client_proc_t rcCreateColorBuffer; rcOpenColorBuffer_client_proc_t rcOpenColorBuffer; rcCloseColorBuffer_client_proc_t rcCloseColorBuffer; rcSetWindowColorBuffer_client_proc_t rcSetWindowColorBuffer; rcFlushWindowColorBuffer_client_proc_t rcFlushWindowColorBuffer; rcMakeCurrent_client_proc_t rcMakeCurrent; rcFBPost_client_proc_t rcFBPost; rcFBSetSwapInterval_client_proc_t rcFBSetSwapInterval; rcBindTexture_client_proc_t rcBindTexture; rcBindRenderbuffer_client_proc_t rcBindRenderbuffer; rcColorBufferCacheFlush_client_proc_t rcColorBufferCacheFlush; rcReadColorBuffer_client_proc_t rcReadColorBuffer; rcUpdateColorBuffer_client_proc_t rcUpdateColorBuffer; rcOpenColorBuffer2_client_proc_t rcOpenColorBuffer2; rcCreateClientImage_client_proc_t rcCreateClientImage; rcDestroyClientImage_client_proc_t rcDestroyClientImage; }; #endif anbox-0.0~git20191115/android/opengl/system/renderControl_enc/renderControl_client_context.cpp000066400000000000000000000073651356361734700325630ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #include #include "renderControl_client_context.h" #include int renderControl_client_context_t::initDispatchByName(void *(*getProc)(const char *, void *userData), void *userData) { rcGetRendererVersion = (rcGetRendererVersion_client_proc_t) getProc("rcGetRendererVersion", userData); rcGetEGLVersion = (rcGetEGLVersion_client_proc_t) getProc("rcGetEGLVersion", userData); rcQueryEGLString = (rcQueryEGLString_client_proc_t) getProc("rcQueryEGLString", userData); rcGetGLString = (rcGetGLString_client_proc_t) getProc("rcGetGLString", userData); rcGetNumConfigs = (rcGetNumConfigs_client_proc_t) getProc("rcGetNumConfigs", userData); rcGetConfigs = (rcGetConfigs_client_proc_t) getProc("rcGetConfigs", userData); rcChooseConfig = (rcChooseConfig_client_proc_t) getProc("rcChooseConfig", userData); rcGetFBParam = (rcGetFBParam_client_proc_t) getProc("rcGetFBParam", userData); rcCreateContext = (rcCreateContext_client_proc_t) getProc("rcCreateContext", userData); rcDestroyContext = (rcDestroyContext_client_proc_t) getProc("rcDestroyContext", userData); rcCreateWindowSurface = (rcCreateWindowSurface_client_proc_t) getProc("rcCreateWindowSurface", userData); rcDestroyWindowSurface = (rcDestroyWindowSurface_client_proc_t) getProc("rcDestroyWindowSurface", userData); rcCreateColorBuffer = (rcCreateColorBuffer_client_proc_t) getProc("rcCreateColorBuffer", userData); rcOpenColorBuffer = (rcOpenColorBuffer_client_proc_t) getProc("rcOpenColorBuffer", userData); rcCloseColorBuffer = (rcCloseColorBuffer_client_proc_t) getProc("rcCloseColorBuffer", userData); rcSetWindowColorBuffer = (rcSetWindowColorBuffer_client_proc_t) getProc("rcSetWindowColorBuffer", userData); rcFlushWindowColorBuffer = (rcFlushWindowColorBuffer_client_proc_t) getProc("rcFlushWindowColorBuffer", userData); rcMakeCurrent = (rcMakeCurrent_client_proc_t) getProc("rcMakeCurrent", userData); rcFBPost = (rcFBPost_client_proc_t) getProc("rcFBPost", userData); rcFBSetSwapInterval = (rcFBSetSwapInterval_client_proc_t) getProc("rcFBSetSwapInterval", userData); rcBindTexture = (rcBindTexture_client_proc_t) getProc("rcBindTexture", userData); rcBindRenderbuffer = (rcBindRenderbuffer_client_proc_t) getProc("rcBindRenderbuffer", userData); rcColorBufferCacheFlush = (rcColorBufferCacheFlush_client_proc_t) getProc("rcColorBufferCacheFlush", userData); rcReadColorBuffer = (rcReadColorBuffer_client_proc_t) getProc("rcReadColorBuffer", userData); rcUpdateColorBuffer = (rcUpdateColorBuffer_client_proc_t) getProc("rcUpdateColorBuffer", userData); rcOpenColorBuffer2 = (rcOpenColorBuffer2_client_proc_t) getProc("rcOpenColorBuffer2", userData); rcCreateClientImage = (rcCreateClientImage_client_proc_t) getProc("rcCreateClientImage", userData); rcDestroyClientImage = (rcDestroyClientImage_client_proc_t) getProc("rcDestroyClientImage", userData); rcSelectChecksumCalculator = (rcSelectChecksumCalculator_client_proc_t) getProc("rcSelectChecksumCalculator", userData); rcGetNumDisplays = (rcGetNumDisplays_client_proc_t) getProc("rcGetNumDisplays", userData); rcGetDisplayWidth = (rcGetDisplayWidth_client_proc_t) getProc("rcGetDisplayWidth", userData); rcGetDisplayHeight = (rcGetDisplayHeight_client_proc_t) getProc("rcGetDisplayHeight", userData); rcGetDisplayDpiX = (rcGetDisplayDpiX_client_proc_t) getProc("rcGetDisplayDpiX", userData); rcGetDisplayDpiY = (rcGetDisplayDpiY_client_proc_t) getProc("rcGetDisplayDpiY", userData); rcGetDisplayVsyncPeriod = (rcGetDisplayVsyncPeriod_client_proc_t) getProc("rcGetDisplayVsyncPeriod", userData); rcPostLayer = (rcPostLayer_client_proc_t) getProc("rcPostLayer", userData); rcPostAllLayersDone = (rcPostAllLayersDone_client_proc_t) getProc("rcPostAllLayersDone", userData); return 0; } anbox-0.0~git20191115/android/opengl/system/renderControl_enc/renderControl_client_context.h000066400000000000000000000050471356361734700322230ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef __renderControl_client_context_t_h #define __renderControl_client_context_t_h #include "renderControl_client_proc.h" #include "renderControl_types.h" struct renderControl_client_context_t { rcGetRendererVersion_client_proc_t rcGetRendererVersion; rcGetEGLVersion_client_proc_t rcGetEGLVersion; rcQueryEGLString_client_proc_t rcQueryEGLString; rcGetGLString_client_proc_t rcGetGLString; rcGetNumConfigs_client_proc_t rcGetNumConfigs; rcGetConfigs_client_proc_t rcGetConfigs; rcChooseConfig_client_proc_t rcChooseConfig; rcGetFBParam_client_proc_t rcGetFBParam; rcCreateContext_client_proc_t rcCreateContext; rcDestroyContext_client_proc_t rcDestroyContext; rcCreateWindowSurface_client_proc_t rcCreateWindowSurface; rcDestroyWindowSurface_client_proc_t rcDestroyWindowSurface; rcCreateColorBuffer_client_proc_t rcCreateColorBuffer; rcOpenColorBuffer_client_proc_t rcOpenColorBuffer; rcCloseColorBuffer_client_proc_t rcCloseColorBuffer; rcSetWindowColorBuffer_client_proc_t rcSetWindowColorBuffer; rcFlushWindowColorBuffer_client_proc_t rcFlushWindowColorBuffer; rcMakeCurrent_client_proc_t rcMakeCurrent; rcFBPost_client_proc_t rcFBPost; rcFBSetSwapInterval_client_proc_t rcFBSetSwapInterval; rcBindTexture_client_proc_t rcBindTexture; rcBindRenderbuffer_client_proc_t rcBindRenderbuffer; rcColorBufferCacheFlush_client_proc_t rcColorBufferCacheFlush; rcReadColorBuffer_client_proc_t rcReadColorBuffer; rcUpdateColorBuffer_client_proc_t rcUpdateColorBuffer; rcOpenColorBuffer2_client_proc_t rcOpenColorBuffer2; rcCreateClientImage_client_proc_t rcCreateClientImage; rcDestroyClientImage_client_proc_t rcDestroyClientImage; rcSelectChecksumCalculator_client_proc_t rcSelectChecksumCalculator; rcGetNumDisplays_client_proc_t rcGetNumDisplays; rcGetDisplayWidth_client_proc_t rcGetDisplayWidth; rcGetDisplayHeight_client_proc_t rcGetDisplayHeight; rcGetDisplayDpiX_client_proc_t rcGetDisplayDpiX; rcGetDisplayDpiY_client_proc_t rcGetDisplayDpiY; rcGetDisplayVsyncPeriod_client_proc_t rcGetDisplayVsyncPeriod; rcPostLayer_client_proc_t rcPostLayer; rcPostAllLayersDone_client_proc_t rcPostAllLayersDone; virtual ~renderControl_client_context_t() {} typedef renderControl_client_context_t *CONTEXT_ACCESSOR_TYPE(void); static void setContextAccessor(CONTEXT_ACCESSOR_TYPE *f); int initDispatchByName( void *(*getProc)(const char *name, void *userData), void *userData); virtual void setError(unsigned int error){ (void)error; }; virtual unsigned int getError(){ return 0; }; }; #endif anbox-0.0~git20191115/android/opengl/system/renderControl_enc/renderControl_client_proc.h000066400000000000000000000101121356361734700314670ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef __renderControl_client_proc_t_h #define __renderControl_client_proc_t_h #include "renderControl_types.h" #ifndef renderControl_APIENTRY #define renderControl_APIENTRY #endif typedef GLint (renderControl_APIENTRY *rcGetRendererVersion_client_proc_t) (void * ctx); typedef EGLint (renderControl_APIENTRY *rcGetEGLVersion_client_proc_t) (void * ctx, EGLint*, EGLint*); typedef EGLint (renderControl_APIENTRY *rcQueryEGLString_client_proc_t) (void * ctx, EGLenum, void*, EGLint); typedef EGLint (renderControl_APIENTRY *rcGetGLString_client_proc_t) (void * ctx, EGLenum, void*, EGLint); typedef EGLint (renderControl_APIENTRY *rcGetNumConfigs_client_proc_t) (void * ctx, uint32_t*); typedef EGLint (renderControl_APIENTRY *rcGetConfigs_client_proc_t) (void * ctx, uint32_t, GLuint*); typedef EGLint (renderControl_APIENTRY *rcChooseConfig_client_proc_t) (void * ctx, EGLint*, uint32_t, uint32_t*, uint32_t); typedef EGLint (renderControl_APIENTRY *rcGetFBParam_client_proc_t) (void * ctx, EGLint); typedef uint32_t (renderControl_APIENTRY *rcCreateContext_client_proc_t) (void * ctx, uint32_t, uint32_t, uint32_t); typedef void (renderControl_APIENTRY *rcDestroyContext_client_proc_t) (void * ctx, uint32_t); typedef uint32_t (renderControl_APIENTRY *rcCreateWindowSurface_client_proc_t) (void * ctx, uint32_t, uint32_t, uint32_t); typedef void (renderControl_APIENTRY *rcDestroyWindowSurface_client_proc_t) (void * ctx, uint32_t); typedef uint32_t (renderControl_APIENTRY *rcCreateColorBuffer_client_proc_t) (void * ctx, uint32_t, uint32_t, GLenum); typedef void (renderControl_APIENTRY *rcOpenColorBuffer_client_proc_t) (void * ctx, uint32_t); typedef void (renderControl_APIENTRY *rcCloseColorBuffer_client_proc_t) (void * ctx, uint32_t); typedef void (renderControl_APIENTRY *rcSetWindowColorBuffer_client_proc_t) (void * ctx, uint32_t, uint32_t); typedef int (renderControl_APIENTRY *rcFlushWindowColorBuffer_client_proc_t) (void * ctx, uint32_t); typedef EGLint (renderControl_APIENTRY *rcMakeCurrent_client_proc_t) (void * ctx, uint32_t, uint32_t, uint32_t); typedef void (renderControl_APIENTRY *rcFBPost_client_proc_t) (void * ctx, uint32_t); typedef void (renderControl_APIENTRY *rcFBSetSwapInterval_client_proc_t) (void * ctx, EGLint); typedef void (renderControl_APIENTRY *rcBindTexture_client_proc_t) (void * ctx, uint32_t); typedef void (renderControl_APIENTRY *rcBindRenderbuffer_client_proc_t) (void * ctx, uint32_t); typedef EGLint (renderControl_APIENTRY *rcColorBufferCacheFlush_client_proc_t) (void * ctx, uint32_t, EGLint, int); typedef void (renderControl_APIENTRY *rcReadColorBuffer_client_proc_t) (void * ctx, uint32_t, GLint, GLint, GLint, GLint, GLenum, GLenum, void*); typedef int (renderControl_APIENTRY *rcUpdateColorBuffer_client_proc_t) (void * ctx, uint32_t, GLint, GLint, GLint, GLint, GLenum, GLenum, void*); typedef int (renderControl_APIENTRY *rcOpenColorBuffer2_client_proc_t) (void * ctx, uint32_t); typedef uint32_t (renderControl_APIENTRY *rcCreateClientImage_client_proc_t) (void * ctx, uint32_t, EGLenum, GLuint); typedef int (renderControl_APIENTRY *rcDestroyClientImage_client_proc_t) (void * ctx, uint32_t); typedef void (renderControl_APIENTRY *rcSelectChecksumCalculator_client_proc_t) (void * ctx, uint32_t, uint32_t); typedef int (renderControl_APIENTRY *rcGetNumDisplays_client_proc_t) (void * ctx); typedef int (renderControl_APIENTRY *rcGetDisplayWidth_client_proc_t) (void * ctx, uint32_t); typedef int (renderControl_APIENTRY *rcGetDisplayHeight_client_proc_t) (void * ctx, uint32_t); typedef int (renderControl_APIENTRY *rcGetDisplayDpiX_client_proc_t) (void * ctx, uint32_t); typedef int (renderControl_APIENTRY *rcGetDisplayDpiY_client_proc_t) (void * ctx, uint32_t); typedef int (renderControl_APIENTRY *rcGetDisplayVsyncPeriod_client_proc_t) (void * ctx, uint32_t); typedef void (renderControl_APIENTRY *rcPostLayer_client_proc_t) (void * ctx, const char*, uint32_t, float, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t); typedef void (renderControl_APIENTRY *rcPostAllLayersDone_client_proc_t) (void * ctx); #endif anbox-0.0~git20191115/android/opengl/system/renderControl_enc/renderControl_enc.cpp000066400000000000000000001445661356361734700303130ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #include #include #include "renderControl_opcodes.h" #include "renderControl_enc.h" #include namespace { void enc_unsupported() { ALOGE("Function is unsupported\n"); } GLint rcGetRendererVersion_enc(void *self ) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcGetRendererVersion;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; GLint retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcGetRendererVersion: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } EGLint rcGetEGLVersion_enc(void *self , EGLint* major, EGLint* minor) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_major = sizeof(EGLint); const unsigned int __size_minor = sizeof(EGLint); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_major + __size_minor + 2*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcGetEGLVersion;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_major; ptr += 4; *(unsigned int *)(ptr) = __size_minor; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(major, __size_major); if (useChecksum) checksumCalculator->addBuffer(major, __size_major); stream->readback(minor, __size_minor); if (useChecksum) checksumCalculator->addBuffer(minor, __size_minor); EGLint retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcGetEGLVersion: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } EGLint rcQueryEGLString_enc(void *self , EGLenum name, void* buffer, EGLint bufferSize) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_buffer = bufferSize; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_buffer + 4 + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcQueryEGLString;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &name, 4); ptr += 4; *(unsigned int *)(ptr) = __size_buffer; ptr += 4; memcpy(ptr, &bufferSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(buffer, __size_buffer); if (useChecksum) checksumCalculator->addBuffer(buffer, __size_buffer); EGLint retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcQueryEGLString: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } EGLint rcGetGLString_enc(void *self , EGLenum name, void* buffer, EGLint bufferSize) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_buffer = bufferSize; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_buffer + 4 + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcGetGLString;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &name, 4); ptr += 4; *(unsigned int *)(ptr) = __size_buffer; ptr += 4; memcpy(ptr, &bufferSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(buffer, __size_buffer); if (useChecksum) checksumCalculator->addBuffer(buffer, __size_buffer); EGLint retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcGetGLString: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } EGLint rcGetNumConfigs_enc(void *self , uint32_t* numAttribs) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_numAttribs = sizeof(uint32_t); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_numAttribs + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcGetNumConfigs;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_numAttribs; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(numAttribs, __size_numAttribs); if (useChecksum) checksumCalculator->addBuffer(numAttribs, __size_numAttribs); EGLint retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcGetNumConfigs: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } EGLint rcGetConfigs_enc(void *self , uint32_t bufSize, GLuint* buffer) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_buffer = bufSize; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + __size_buffer + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcGetConfigs;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &bufSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_buffer; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(buffer, __size_buffer); if (useChecksum) checksumCalculator->addBuffer(buffer, __size_buffer); EGLint retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcGetConfigs: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } EGLint rcChooseConfig_enc(void *self , EGLint* attribs, uint32_t attribs_size, uint32_t* configs, uint32_t configs_size) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_attribs = attribs_size; const unsigned int __size_configs = ((configs != NULL) ? configs_size*sizeof(uint32_t) : 0); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_attribs + 4 + __size_configs + 4 + 2*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcChooseConfig;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_attribs; ptr += 4; memcpy(ptr, attribs, __size_attribs);ptr += __size_attribs; memcpy(ptr, &attribs_size, 4); ptr += 4; *(unsigned int *)(ptr) = __size_configs; ptr += 4; memcpy(ptr, &configs_size, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; if (configs != NULL) { stream->readback(configs, __size_configs); if (useChecksum) checksumCalculator->addBuffer(configs, __size_configs); } EGLint retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcChooseConfig: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } EGLint rcGetFBParam_enc(void *self , EGLint param) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcGetFBParam;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; EGLint retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcGetFBParam: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } uint32_t rcCreateContext_enc(void *self , uint32_t config, uint32_t share, uint32_t glVersion) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcCreateContext;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &config, 4); ptr += 4; memcpy(ptr, &share, 4); ptr += 4; memcpy(ptr, &glVersion, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; uint32_t retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcCreateContext: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void rcDestroyContext_enc(void *self , uint32_t context) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcDestroyContext;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &context, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } uint32_t rcCreateWindowSurface_enc(void *self , uint32_t config, uint32_t width, uint32_t height) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcCreateWindowSurface;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &config, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; uint32_t retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcCreateWindowSurface: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void rcDestroyWindowSurface_enc(void *self , uint32_t windowSurface) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcDestroyWindowSurface;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &windowSurface, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } uint32_t rcCreateColorBuffer_enc(void *self , uint32_t width, uint32_t height, GLenum internalFormat) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcCreateColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; memcpy(ptr, &internalFormat, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; uint32_t retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcCreateColorBuffer: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void rcOpenColorBuffer_enc(void *self , uint32_t colorbuffer) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcOpenColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &colorbuffer, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void rcCloseColorBuffer_enc(void *self , uint32_t colorbuffer) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcCloseColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &colorbuffer, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->flush(); } void rcSetWindowColorBuffer_enc(void *self , uint32_t windowSurface, uint32_t colorBuffer) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcSetWindowColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &windowSurface, 4); ptr += 4; memcpy(ptr, &colorBuffer, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } int rcFlushWindowColorBuffer_enc(void *self , uint32_t windowSurface) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcFlushWindowColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &windowSurface, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; int retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcFlushWindowColorBuffer: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } EGLint rcMakeCurrent_enc(void *self , uint32_t context, uint32_t drawSurf, uint32_t readSurf) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcMakeCurrent;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &context, 4); ptr += 4; memcpy(ptr, &drawSurf, 4); ptr += 4; memcpy(ptr, &readSurf, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; EGLint retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcMakeCurrent: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void rcFBPost_enc(void *self , uint32_t colorBuffer) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcFBPost;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &colorBuffer, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void rcFBSetSwapInterval_enc(void *self , EGLint interval) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcFBSetSwapInterval;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &interval, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void rcBindTexture_enc(void *self , uint32_t colorBuffer) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcBindTexture;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &colorBuffer, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void rcBindRenderbuffer_enc(void *self , uint32_t colorBuffer) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcBindRenderbuffer;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &colorBuffer, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } EGLint rcColorBufferCacheFlush_enc(void *self , uint32_t colorbuffer, EGLint postCount, int forRead) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcColorBufferCacheFlush;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &colorbuffer, 4); ptr += 4; memcpy(ptr, &postCount, 4); ptr += 4; memcpy(ptr, &forRead, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; EGLint retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcColorBufferCacheFlush: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void rcReadColorBuffer_enc(void *self , uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_pixels = (((glUtilsPixelBitSize(format, type) * width) >> 3) * height); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcReadColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &colorbuffer, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; memcpy(ptr, &format, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; *(unsigned int *)(ptr) = __size_pixels; ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->readback(pixels, __size_pixels); if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcReadColorBuffer: GL communication error, please report this issue to b.android.com.\n"); abort(); } } } int rcUpdateColorBuffer_enc(void *self , uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_pixels = (((glUtilsPixelBitSize(format, type) * width) >> 3) * height); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4); ptr = buf; int tmp = OP_rcUpdateColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &colorbuffer, 4); ptr += 4; memcpy(ptr, &x, 4); ptr += 4; memcpy(ptr, &y, 4); ptr += 4; memcpy(ptr, &width, 4); ptr += 4; memcpy(ptr, &height, 4); ptr += 4; memcpy(ptr, &format, 4); ptr += 4; memcpy(ptr, &type, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); stream->flush(); stream->writeFully(&__size_pixels,4); if (useChecksum) checksumCalculator->addBuffer(&__size_pixels,4); stream->writeFully(pixels, __size_pixels); if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels); buf = stream->alloc(checksumSize); if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize); int retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcUpdateColorBuffer: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } int rcOpenColorBuffer2_enc(void *self , uint32_t colorbuffer) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcOpenColorBuffer2;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &colorbuffer, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; int retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcOpenColorBuffer2: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } uint32_t rcCreateClientImage_enc(void *self , uint32_t context, EGLenum target, GLuint buffer) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcCreateClientImage;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &context, 4); ptr += 4; memcpy(ptr, &target, 4); ptr += 4; memcpy(ptr, &buffer, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; uint32_t retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcCreateClientImage: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } int rcDestroyClientImage_enc(void *self , uint32_t image) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcDestroyClientImage;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &image, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; int retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcDestroyClientImage: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void rcSelectChecksumCalculator_enc(void *self , uint32_t newProtocol, uint32_t reserved) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcSelectChecksumCalculator;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &newProtocol, 4); ptr += 4; memcpy(ptr, &reserved, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } int rcGetNumDisplays_enc(void *self ) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcGetNumDisplays;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; int retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcGetNumDisplays: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } int rcGetDisplayWidth_enc(void *self , uint32_t displayId) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcGetDisplayWidth;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &displayId, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; int retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcGetDisplayWidth: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } int rcGetDisplayHeight_enc(void *self , uint32_t displayId) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcGetDisplayHeight;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &displayId, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; int retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcGetDisplayHeight: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } int rcGetDisplayDpiX_enc(void *self , uint32_t displayId) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcGetDisplayDpiX;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &displayId, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; int retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcGetDisplayDpiX: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } int rcGetDisplayDpiY_enc(void *self , uint32_t displayId) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcGetDisplayDpiY;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &displayId, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; int retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcGetDisplayDpiY: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } int rcGetDisplayVsyncPeriod_enc(void *self , uint32_t displayId) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcGetDisplayVsyncPeriod;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &displayId, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; int retval; stream->readback(&retval, 4); if (useChecksum) checksumCalculator->addBuffer(&retval, 4); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("rcGetDisplayVsyncPeriod: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void rcPostLayer_enc(void *self , const char* name, uint32_t colorBuffer, float alpha, int32_t sourceCropLeft, int32_t sourceCropTop, int32_t sourceCropRight, int32_t sourceCropBottom, int32_t displayFrameLeft, int32_t displayFrameTop, int32_t displayFrameRight, int32_t displayFrameBottom) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_name = (strlen(name) + 1); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_name + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcPostLayer;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_name; ptr += 4; memcpy(ptr, name, __size_name);ptr += __size_name; memcpy(ptr, &colorBuffer, 4); ptr += 4; memcpy(ptr, &alpha, 4); ptr += 4; memcpy(ptr, &sourceCropLeft, 4); ptr += 4; memcpy(ptr, &sourceCropTop, 4); ptr += 4; memcpy(ptr, &sourceCropRight, 4); ptr += 4; memcpy(ptr, &sourceCropBottom, 4); ptr += 4; memcpy(ptr, &displayFrameLeft, 4); ptr += 4; memcpy(ptr, &displayFrameTop, 4); ptr += 4; memcpy(ptr, &displayFrameRight, 4); ptr += 4; memcpy(ptr, &displayFrameBottom, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } void rcPostAllLayersDone_enc(void *self ) { renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_rcPostAllLayersDone;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } } // namespace renderControl_encoder_context_t::renderControl_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator) { m_stream = stream; m_checksumCalculator = checksumCalculator; this->rcGetRendererVersion = &rcGetRendererVersion_enc; this->rcGetEGLVersion = &rcGetEGLVersion_enc; this->rcQueryEGLString = &rcQueryEGLString_enc; this->rcGetGLString = &rcGetGLString_enc; this->rcGetNumConfigs = &rcGetNumConfigs_enc; this->rcGetConfigs = &rcGetConfigs_enc; this->rcChooseConfig = &rcChooseConfig_enc; this->rcGetFBParam = &rcGetFBParam_enc; this->rcCreateContext = &rcCreateContext_enc; this->rcDestroyContext = &rcDestroyContext_enc; this->rcCreateWindowSurface = &rcCreateWindowSurface_enc; this->rcDestroyWindowSurface = &rcDestroyWindowSurface_enc; this->rcCreateColorBuffer = &rcCreateColorBuffer_enc; this->rcOpenColorBuffer = &rcOpenColorBuffer_enc; this->rcCloseColorBuffer = &rcCloseColorBuffer_enc; this->rcSetWindowColorBuffer = &rcSetWindowColorBuffer_enc; this->rcFlushWindowColorBuffer = &rcFlushWindowColorBuffer_enc; this->rcMakeCurrent = &rcMakeCurrent_enc; this->rcFBPost = &rcFBPost_enc; this->rcFBSetSwapInterval = &rcFBSetSwapInterval_enc; this->rcBindTexture = &rcBindTexture_enc; this->rcBindRenderbuffer = &rcBindRenderbuffer_enc; this->rcColorBufferCacheFlush = &rcColorBufferCacheFlush_enc; this->rcReadColorBuffer = &rcReadColorBuffer_enc; this->rcUpdateColorBuffer = &rcUpdateColorBuffer_enc; this->rcOpenColorBuffer2 = &rcOpenColorBuffer2_enc; this->rcCreateClientImage = &rcCreateClientImage_enc; this->rcDestroyClientImage = &rcDestroyClientImage_enc; this->rcSelectChecksumCalculator = &rcSelectChecksumCalculator_enc; this->rcGetNumDisplays = &rcGetNumDisplays_enc; this->rcGetDisplayWidth = &rcGetDisplayWidth_enc; this->rcGetDisplayHeight = &rcGetDisplayHeight_enc; this->rcGetDisplayDpiX = &rcGetDisplayDpiX_enc; this->rcGetDisplayDpiY = &rcGetDisplayDpiY_enc; this->rcGetDisplayVsyncPeriod = &rcGetDisplayVsyncPeriod_enc; this->rcPostLayer = &rcPostLayer_enc; this->rcPostAllLayersDone = &rcPostAllLayersDone_enc; } anbox-0.0~git20191115/android/opengl/system/renderControl_enc/renderControl_enc.h000066400000000000000000000011361356361734700277410ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef GUARD_renderControl_encoder_context_t #define GUARD_renderControl_encoder_context_t #include "IOStream.h" #include "ChecksumCalculator.h" #include "renderControl_client_context.h" #include #include #include "glUtils.h" struct renderControl_encoder_context_t : public renderControl_client_context_t { IOStream *m_stream; ChecksumCalculator *m_checksumCalculator; renderControl_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator); }; #endif // GUARD_renderControl_encoder_context_tanbox-0.0~git20191115/android/opengl/system/renderControl_enc/renderControl_entry.cpp000066400000000000000000000177171356361734700307040ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #include #include #include "renderControl_client_context.h" #ifndef GL_TRUE extern "C" { GLint rcGetRendererVersion(); EGLint rcGetEGLVersion(EGLint* major, EGLint* minor); EGLint rcQueryEGLString(EGLenum name, void* buffer, EGLint bufferSize); EGLint rcGetGLString(EGLenum name, void* buffer, EGLint bufferSize); EGLint rcGetNumConfigs(uint32_t* numAttribs); EGLint rcGetConfigs(uint32_t bufSize, GLuint* buffer); EGLint rcChooseConfig(EGLint* attribs, uint32_t attribs_size, uint32_t* configs, uint32_t configs_size); EGLint rcGetFBParam(EGLint param); uint32_t rcCreateContext(uint32_t config, uint32_t share, uint32_t glVersion); void rcDestroyContext(uint32_t context); uint32_t rcCreateWindowSurface(uint32_t config, uint32_t width, uint32_t height); void rcDestroyWindowSurface(uint32_t windowSurface); uint32_t rcCreateColorBuffer(uint32_t width, uint32_t height, GLenum internalFormat); void rcOpenColorBuffer(uint32_t colorbuffer); void rcCloseColorBuffer(uint32_t colorbuffer); void rcSetWindowColorBuffer(uint32_t windowSurface, uint32_t colorBuffer); int rcFlushWindowColorBuffer(uint32_t windowSurface); EGLint rcMakeCurrent(uint32_t context, uint32_t drawSurf, uint32_t readSurf); void rcFBPost(uint32_t colorBuffer); void rcFBSetSwapInterval(EGLint interval); void rcBindTexture(uint32_t colorBuffer); void rcBindRenderbuffer(uint32_t colorBuffer); EGLint rcColorBufferCacheFlush(uint32_t colorbuffer, EGLint postCount, int forRead); void rcReadColorBuffer(uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels); int rcUpdateColorBuffer(uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels); int rcOpenColorBuffer2(uint32_t colorbuffer); uint32_t rcCreateClientImage(uint32_t context, EGLenum target, GLuint buffer); int rcDestroyClientImage(uint32_t image); void rcSelectChecksumCalculator(uint32_t newProtocol, uint32_t reserved); int rcGetNumDisplays(); int rcGetDisplayWidth(uint32_t displayId); int rcGetDisplayHeight(uint32_t displayId); int rcGetDisplayDpiX(uint32_t displayId); int rcGetDisplayDpiY(uint32_t displayId); int rcGetDisplayVsyncPeriod(uint32_t displayId); void rcPostLayer(const char* name, uint32_t colorBuffer, float alpha, int32_t sourceCropLeft, int32_t sourceCropTop, int32_t sourceCropRight, int32_t sourceCropBottom, int32_t displayFrameLeft, int32_t displayFrameTop, int32_t displayFrameRight, int32_t displayFrameBottom); void rcPostAllLayersDone(); }; #endif #ifndef GET_CONTEXT static renderControl_client_context_t::CONTEXT_ACCESSOR_TYPE *getCurrentContext = NULL; void renderControl_client_context_t::setContextAccessor(CONTEXT_ACCESSOR_TYPE *f) { getCurrentContext = f; } #define GET_CONTEXT renderControl_client_context_t * ctx = getCurrentContext() #endif GLint rcGetRendererVersion() { GET_CONTEXT; return ctx->rcGetRendererVersion(ctx); } EGLint rcGetEGLVersion(EGLint* major, EGLint* minor) { GET_CONTEXT; return ctx->rcGetEGLVersion(ctx, major, minor); } EGLint rcQueryEGLString(EGLenum name, void* buffer, EGLint bufferSize) { GET_CONTEXT; return ctx->rcQueryEGLString(ctx, name, buffer, bufferSize); } EGLint rcGetGLString(EGLenum name, void* buffer, EGLint bufferSize) { GET_CONTEXT; return ctx->rcGetGLString(ctx, name, buffer, bufferSize); } EGLint rcGetNumConfigs(uint32_t* numAttribs) { GET_CONTEXT; return ctx->rcGetNumConfigs(ctx, numAttribs); } EGLint rcGetConfigs(uint32_t bufSize, GLuint* buffer) { GET_CONTEXT; return ctx->rcGetConfigs(ctx, bufSize, buffer); } EGLint rcChooseConfig(EGLint* attribs, uint32_t attribs_size, uint32_t* configs, uint32_t configs_size) { GET_CONTEXT; return ctx->rcChooseConfig(ctx, attribs, attribs_size, configs, configs_size); } EGLint rcGetFBParam(EGLint param) { GET_CONTEXT; return ctx->rcGetFBParam(ctx, param); } uint32_t rcCreateContext(uint32_t config, uint32_t share, uint32_t glVersion) { GET_CONTEXT; return ctx->rcCreateContext(ctx, config, share, glVersion); } void rcDestroyContext(uint32_t context) { GET_CONTEXT; ctx->rcDestroyContext(ctx, context); } uint32_t rcCreateWindowSurface(uint32_t config, uint32_t width, uint32_t height) { GET_CONTEXT; return ctx->rcCreateWindowSurface(ctx, config, width, height); } void rcDestroyWindowSurface(uint32_t windowSurface) { GET_CONTEXT; ctx->rcDestroyWindowSurface(ctx, windowSurface); } uint32_t rcCreateColorBuffer(uint32_t width, uint32_t height, GLenum internalFormat) { GET_CONTEXT; return ctx->rcCreateColorBuffer(ctx, width, height, internalFormat); } void rcOpenColorBuffer(uint32_t colorbuffer) { GET_CONTEXT; ctx->rcOpenColorBuffer(ctx, colorbuffer); } void rcCloseColorBuffer(uint32_t colorbuffer) { GET_CONTEXT; ctx->rcCloseColorBuffer(ctx, colorbuffer); } void rcSetWindowColorBuffer(uint32_t windowSurface, uint32_t colorBuffer) { GET_CONTEXT; ctx->rcSetWindowColorBuffer(ctx, windowSurface, colorBuffer); } int rcFlushWindowColorBuffer(uint32_t windowSurface) { GET_CONTEXT; return ctx->rcFlushWindowColorBuffer(ctx, windowSurface); } EGLint rcMakeCurrent(uint32_t context, uint32_t drawSurf, uint32_t readSurf) { GET_CONTEXT; return ctx->rcMakeCurrent(ctx, context, drawSurf, readSurf); } void rcFBPost(uint32_t colorBuffer) { GET_CONTEXT; ctx->rcFBPost(ctx, colorBuffer); } void rcFBSetSwapInterval(EGLint interval) { GET_CONTEXT; ctx->rcFBSetSwapInterval(ctx, interval); } void rcBindTexture(uint32_t colorBuffer) { GET_CONTEXT; ctx->rcBindTexture(ctx, colorBuffer); } void rcBindRenderbuffer(uint32_t colorBuffer) { GET_CONTEXT; ctx->rcBindRenderbuffer(ctx, colorBuffer); } EGLint rcColorBufferCacheFlush(uint32_t colorbuffer, EGLint postCount, int forRead) { GET_CONTEXT; return ctx->rcColorBufferCacheFlush(ctx, colorbuffer, postCount, forRead); } void rcReadColorBuffer(uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels) { GET_CONTEXT; ctx->rcReadColorBuffer(ctx, colorbuffer, x, y, width, height, format, type, pixels); } int rcUpdateColorBuffer(uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels) { GET_CONTEXT; return ctx->rcUpdateColorBuffer(ctx, colorbuffer, x, y, width, height, format, type, pixels); } int rcOpenColorBuffer2(uint32_t colorbuffer) { GET_CONTEXT; return ctx->rcOpenColorBuffer2(ctx, colorbuffer); } uint32_t rcCreateClientImage(uint32_t context, EGLenum target, GLuint buffer) { GET_CONTEXT; return ctx->rcCreateClientImage(ctx, context, target, buffer); } int rcDestroyClientImage(uint32_t image) { GET_CONTEXT; return ctx->rcDestroyClientImage(ctx, image); } void rcSelectChecksumCalculator(uint32_t newProtocol, uint32_t reserved) { GET_CONTEXT; ctx->rcSelectChecksumCalculator(ctx, newProtocol, reserved); } int rcGetNumDisplays() { GET_CONTEXT; return ctx->rcGetNumDisplays(ctx); } int rcGetDisplayWidth(uint32_t displayId) { GET_CONTEXT; return ctx->rcGetDisplayWidth(ctx, displayId); } int rcGetDisplayHeight(uint32_t displayId) { GET_CONTEXT; return ctx->rcGetDisplayHeight(ctx, displayId); } int rcGetDisplayDpiX(uint32_t displayId) { GET_CONTEXT; return ctx->rcGetDisplayDpiX(ctx, displayId); } int rcGetDisplayDpiY(uint32_t displayId) { GET_CONTEXT; return ctx->rcGetDisplayDpiY(ctx, displayId); } int rcGetDisplayVsyncPeriod(uint32_t displayId) { GET_CONTEXT; return ctx->rcGetDisplayVsyncPeriod(ctx, displayId); } void rcPostLayer(const char* name, uint32_t colorBuffer, float alpha, int32_t sourceCropLeft, int32_t sourceCropTop, int32_t sourceCropRight, int32_t sourceCropBottom, int32_t displayFrameLeft, int32_t displayFrameTop, int32_t displayFrameRight, int32_t displayFrameBottom) { GET_CONTEXT; ctx->rcPostLayer(ctx, name, colorBuffer, alpha, sourceCropLeft, sourceCropTop, sourceCropRight, sourceCropBottom, displayFrameLeft, displayFrameTop, displayFrameRight, displayFrameBottom); } void rcPostAllLayersDone() { GET_CONTEXT; ctx->rcPostAllLayersDone(ctx); } anbox-0.0~git20191115/android/opengl/system/renderControl_enc/renderControl_ftable.h000066400000000000000000000043431356361734700304340ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef __renderControl_client_ftable_t_h #define __renderControl_client_ftable_t_h static const struct _renderControl_funcs_by_name { const char *name; void *proc; } renderControl_funcs_by_name[] = { {"rcGetRendererVersion", (void*)rcGetRendererVersion}, {"rcGetEGLVersion", (void*)rcGetEGLVersion}, {"rcQueryEGLString", (void*)rcQueryEGLString}, {"rcGetGLString", (void*)rcGetGLString}, {"rcGetNumConfigs", (void*)rcGetNumConfigs}, {"rcGetConfigs", (void*)rcGetConfigs}, {"rcChooseConfig", (void*)rcChooseConfig}, {"rcGetFBParam", (void*)rcGetFBParam}, {"rcCreateContext", (void*)rcCreateContext}, {"rcDestroyContext", (void*)rcDestroyContext}, {"rcCreateWindowSurface", (void*)rcCreateWindowSurface}, {"rcDestroyWindowSurface", (void*)rcDestroyWindowSurface}, {"rcCreateColorBuffer", (void*)rcCreateColorBuffer}, {"rcOpenColorBuffer", (void*)rcOpenColorBuffer}, {"rcCloseColorBuffer", (void*)rcCloseColorBuffer}, {"rcSetWindowColorBuffer", (void*)rcSetWindowColorBuffer}, {"rcFlushWindowColorBuffer", (void*)rcFlushWindowColorBuffer}, {"rcMakeCurrent", (void*)rcMakeCurrent}, {"rcFBPost", (void*)rcFBPost}, {"rcFBSetSwapInterval", (void*)rcFBSetSwapInterval}, {"rcBindTexture", (void*)rcBindTexture}, {"rcBindRenderbuffer", (void*)rcBindRenderbuffer}, {"rcColorBufferCacheFlush", (void*)rcColorBufferCacheFlush}, {"rcReadColorBuffer", (void*)rcReadColorBuffer}, {"rcUpdateColorBuffer", (void*)rcUpdateColorBuffer}, {"rcOpenColorBuffer2", (void*)rcOpenColorBuffer2}, {"rcCreateClientImage", (void*)rcCreateClientImage}, {"rcDestroyClientImage", (void*)rcDestroyClientImage}, {"rcSelectChecksumCalculator", (void*)rcSelectChecksumCalculator}, {"rcGetNumDisplays", (void*)rcGetNumDisplays}, {"rcGetDisplayWidth", (void*)rcGetDisplayWidth}, {"rcGetDisplayHeight", (void*)rcGetDisplayHeight}, {"rcGetDisplayDpiX", (void*)rcGetDisplayDpiX}, {"rcGetDisplayDpiY", (void*)rcGetDisplayDpiY}, {"rcGetDisplayVsyncPeriod", (void*)rcGetDisplayVsyncPeriod}, {"rcPostLayer", (void*)rcPostLayer}, {"rcPostAllLayersDone", (void*)rcPostAllLayersDone}, }; static const int renderControl_num_funcs = sizeof(renderControl_funcs_by_name) / sizeof(struct _renderControl_funcs_by_name); #endif anbox-0.0~git20191115/android/opengl/system/renderControl_enc/renderControl_opcodes.h000066400000000000000000000032061356361734700306300ustar00rootroot00000000000000// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef __GUARD_renderControl_opcodes_h_ #define __GUARD_renderControl_opcodes_h_ #define OP_rcGetRendererVersion 10000 #define OP_rcGetEGLVersion 10001 #define OP_rcQueryEGLString 10002 #define OP_rcGetGLString 10003 #define OP_rcGetNumConfigs 10004 #define OP_rcGetConfigs 10005 #define OP_rcChooseConfig 10006 #define OP_rcGetFBParam 10007 #define OP_rcCreateContext 10008 #define OP_rcDestroyContext 10009 #define OP_rcCreateWindowSurface 10010 #define OP_rcDestroyWindowSurface 10011 #define OP_rcCreateColorBuffer 10012 #define OP_rcOpenColorBuffer 10013 #define OP_rcCloseColorBuffer 10014 #define OP_rcSetWindowColorBuffer 10015 #define OP_rcFlushWindowColorBuffer 10016 #define OP_rcMakeCurrent 10017 #define OP_rcFBPost 10018 #define OP_rcFBSetSwapInterval 10019 #define OP_rcBindTexture 10020 #define OP_rcBindRenderbuffer 10021 #define OP_rcColorBufferCacheFlush 10022 #define OP_rcReadColorBuffer 10023 #define OP_rcUpdateColorBuffer 10024 #define OP_rcOpenColorBuffer2 10025 #define OP_rcCreateClientImage 10026 #define OP_rcDestroyClientImage 10027 #define OP_rcSelectChecksumCalculator 10028 #define OP_rcGetNumDisplays 10029 #define OP_rcGetDisplayWidth 10030 #define OP_rcGetDisplayHeight 10031 #define OP_rcGetDisplayDpiX 10032 #define OP_rcGetDisplayDpiY 10033 #define OP_rcGetDisplayVsyncPeriod 10034 #define OP_rcPostLayer 10035 #define OP_rcPostAllLayersDone 10036 #define OP_last 10037 #endif anbox-0.0~git20191115/android/opengl/system/renderControl_enc/renderControl_types.h000066400000000000000000000015601356361734700303410ustar00rootroot00000000000000/* * Copyright 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include "glUtils.h" // values for 'param' argument of rcGetFBParam #define FB_WIDTH 1 #define FB_HEIGHT 2 #define FB_XDPI 3 #define FB_YDPI 4 #define FB_FPS 5 #define FB_MIN_SWAP_INTERVAL 6 #define FB_MAX_SWAP_INTERVAL 7 anbox-0.0~git20191115/android/opengl/tests/000077500000000000000000000000001356361734700202735ustar00rootroot00000000000000anbox-0.0~git20191115/android/opengl/tests/gles_android_wrapper/000077500000000000000000000000001356361734700244655ustar00rootroot00000000000000anbox-0.0~git20191115/android/opengl/tests/gles_android_wrapper/Android.mk000066400000000000000000000040121356361734700263730ustar00rootroot00000000000000LOCAL_PATH := $(call my-dir) #### libGLESv1_CM_emul.so $(call emugl-begin-shared-library,libGLESv1_CM_emul) $(call emugl-import,libGLESv1_enc) $(call emugl-gen-wrapper,$(EMUGL_PATH)/system/GLESv1_enc,gl) $(call emugl-set-shared-library-subpath,egl) LOCAL_SRC_FILES += glesv1_emul_ifc.cpp $(call emugl-end-module) emulatorOpengl := $(LOCAL_PATH)/../.. logTag := -DLOG_TAG=\"eglWrapper\" EMUGEN = $(BUILD_OUT_EXECUTABLES)/emugen ## comment for no debug #debugFlags = -g -O0 #### libGLESv2_CM_emul.so $(call emugl-begin-shared-library, libGLESv2_emul) $(call emugl-import,libGLESv2_enc) $(call emugl-gen-wrapper,$(EMUGL_PATH)/system/GLESv2_enc,gl2) LOCAL_SRC_FILES += glesv2_emul_ifc.cpp $(call emugl-set-shared-library-subpath,egl) $(call emugl-end-module) ##### libEGL_emul.so ########### # THE FOLLOWING DOESN'T WORK YET # $(call emugl-begin-shared-library,libEGL_emul) $(call emugl-import,libut_rendercontrol_enc libGLESv1_CM_emul libGLESv2_emul libOpenglSystemCommon) $(call emugl-set-shared-library-subpath,egl) LOCAL_CFLAGS += $(logTag) LOCAL_SRC_FILES := \ egl.cpp \ egl_dispatch.cpp \ ServerConnection.cpp \ ThreadInfo.cpp $(call emugl-end-module) #### egl.cfg #### # Ensure that this file is only copied to emulator-specific builds. # Other builds are device-specific and will provide their own # version of this file to point to the appropriate HW EGL libraries. # ifneq (,$(filter full full_x86 full_mips sdk sdk_x86 sdk_mips,$(TARGET_PRODUCT))) ifeq (,$(BUILD_EMULATOR_OPENGL_DRIVER)) include $(CLEAR_VARS) LOCAL_MODULE := egl.cfg LOCAL_SRC_FILES := $(LOCAL_MODULE) LOCAL_MODULE_PATH := $(TARGET_OUT)/lib/egl LOCAL_MODULE_CLASS := ETC include $(BUILD_PREBUILT) endif # building 'real' driver BUILD_EMULATOR_OPENGL_DRIVER endif # TARGET_PRODUCT in 'full sdk full_x86 sdk_x86 full_mips sdk_mips' #### gles_emul.cfg #### include $(CLEAR_VARS) LOCAL_MODULE := gles_emul.cfg LOCAL_SRC_FILES := $(LOCAL_MODULE) LOCAL_MODULE_PATH := $(TARGET_OUT)/etc LOCAL_MODULE_CLASS := ETC include $(BUILD_PREBUILT) anbox-0.0~git20191115/android/opengl/tests/gles_android_wrapper/ApiInitializer.h000066400000000000000000000022011356361734700275460ustar00rootroot00000000000000/* * Copyright 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _API_INITIALIZER_H_ #define _API_INITIALIZER_H_ #include #include class ApiInitializer { public: ApiInitializer(void *dso) : m_dso(dso) { } static void *s_getProc(const char *name, void *userData) { ApiInitializer *self = (ApiInitializer *)userData; return self->getProc(name); } private: void *m_dso; void *getProc(const char *name) { void *symbol = NULL; if (m_dso) { symbol = dlsym(m_dso, name); } return symbol; } }; #endif anbox-0.0~git20191115/android/opengl/tests/gles_android_wrapper/CleanSpec.mk000066400000000000000000000044331356361734700266570ustar00rootroot00000000000000# Copyright (C) 2007 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # If you don't need to do a full clean build but would like to touch # a file or delete some intermediate files, add a clean step to the end # of the list. These steps will only be run once, if they haven't been # run before. # # E.g.: # $(call add-clean-step, touch -c external/sqlite/sqlite3.h) # $(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/STATIC_LIBRARIES/libz_intermediates) # # Always use "touch -c" and "rm -f" or "rm -rf" to gracefully deal with # files that are missing or have been moved. # # Use $(PRODUCT_OUT) to get to the "out/target/product/blah/" directory. # Use $(OUT_DIR) to refer to the "out" directory. # # If you need to re-do something that's already mentioned, just copy # the command and add it to the bottom of the list. E.g., if a change # that you made last week required touching a file and a change you # made today requires touching the same file, just copy the old # touch step and add it to the end of the list. # # ************************************************ # NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST # ************************************************ # For example: #$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/APPS/AndroidTests_intermediates) #$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/JAVA_LIBRARIES/core_intermediates) #$(call add-clean-step, find $(OUT_DIR) -type f -name "IGTalkSession*" -print0 | xargs -0 rm -f) #$(call add-clean-step, rm -rf $(PRODUCT_OUT)/data/*) # ************************************************ # NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST # ************************************************ $(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/SHARED_LIBRARIES/libGLES_emul_intermediates) anbox-0.0~git20191115/android/opengl/tests/gles_android_wrapper/ServerConnection.cpp000066400000000000000000000060621356361734700304630ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include "ServerConnection.h" #include "TcpStream.h" #include "QemuPipeStream.h" #include #include "ThreadInfo.h" gl_client_context_t *ServerConnection::s_getGlContext() { EGLThreadInfo *ti = getEGLThreadInfo(); if (ti->serverConn) { return ti->serverConn->m_glEnc; } return NULL; } gl2_client_context_t *ServerConnection::s_getGl2Context() { EGLThreadInfo *ti = getEGLThreadInfo(); if (ti->serverConn) { return ti->serverConn->m_gl2Enc; } return NULL; } ServerConnection *ServerConnection::s_getServerConnection() { EGLThreadInfo *ti = getEGLThreadInfo(); if (!ti->serverConn) { ti->serverConn = new ServerConnection(); if (ti->serverConn->create() < 0) { delete ti->serverConn; ti->serverConn = NULL; } } return ti->serverConn; } ServerConnection::ServerConnection() : m_stream(NULL), m_glEnc(NULL), m_ut_enc(NULL) { } ServerConnection::~ServerConnection() { delete m_ut_enc; delete m_glEnc; delete m_stream; } int ServerConnection::create(size_t bufsize, const char *defaultServer) { /* XXX: Make configurable through system property */ int useQemuPipe = 1; if (m_stream != NULL) delete(m_stream); if (useQemuPipe) { QemuPipeStream* pipeStream = new QemuPipeStream(bufsize); if (pipeStream->connect() < 0) { ALOGE("couldn't connect to host server\n"); delete pipeStream; return -1; } m_stream = pipeStream; } else /* !useQemuPipe */ { TcpStream* tcpStream = new TcpStream(bufsize); char *s = getenv(ENV_RGL_SERVER); char *hostname; if (s == NULL) { hostname = strdup(defaultServer); } else { hostname = strdup(s); } if (tcpStream->connect(hostname, CODEC_SERVER_PORT) < 0) { ALOGE("couldn't connect to %s\n", hostname); free(hostname); delete tcpStream; return -1; } LOGI("connecting to server %s\n", hostname); free(hostname); m_stream = tcpStream; } m_glEnc = new GLEncoder(m_stream); m_glEnc->setContextAccessor(s_getGlContext); m_gl2Enc = new GL2Encoder(m_stream); m_gl2Enc->setContextAccessor(s_getGl2Context); m_ut_enc = new ut_rendercontrol_encoder_context_t(m_stream); return 0; } anbox-0.0~git20191115/android/opengl/tests/gles_android_wrapper/ServerConnection.h000066400000000000000000000031631356361734700301270ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _SERVER_CONNECTION_H #define _SERVER_CONNECTION_H #include "GLEncoder.h" #include "GL2Encoder.h" #include "IOStream.h" #include "codec_defs.h" #include "ut_rendercontrol_enc.h" #include #define ENV_RGL_SERVER "RGL_SERVER" #define RGL_DEFAULT_SERVER "10.0.2.2" class ServerConnection { public: ~ServerConnection(); int create(size_t buf_size = 4 * 1024 * 1024, const char *defaultServer = RGL_DEFAULT_SERVER); static gl_client_context_t *s_getGlContext(); static ServerConnection *s_getServerConnection(); static gl2_client_context_t *s_getGl2Context(); GLEncoder *glEncoder() { return m_glEnc; } GL2Encoder *gl2Encoder() { return m_gl2Enc; } ut_rendercontrol_encoder_context_t * utEnc() { return m_ut_enc; } private: ServerConnection(); private: static pthread_key_t s_glKey; static pthread_key_t s_connectionKey; static void s_initKeys(); IOStream *m_stream; GLEncoder *m_glEnc; GL2Encoder *m_gl2Enc; ut_rendercontrol_encoder_context_t *m_ut_enc; }; #endif anbox-0.0~git20191115/android/opengl/tests/gles_android_wrapper/ThreadInfo.cpp000066400000000000000000000020771356361734700272220ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "ThreadInfo.h" #include "cutils/threads.h" thread_store_t s_tls = THREAD_STORE_INITIALIZER; static void tlsDestruct(void *ptr) { if (ptr) { EGLThreadInfo *ti = (EGLThreadInfo *)ptr; delete ti->serverConn; delete ti; } } EGLThreadInfo *getEGLThreadInfo() { EGLThreadInfo *ti = (EGLThreadInfo *)thread_store_get(&s_tls); if (ti) return ti; ti = new EGLThreadInfo(); thread_store_set(&s_tls, ti, tlsDestruct); return ti; } anbox-0.0~git20191115/android/opengl/tests/gles_android_wrapper/ThreadInfo.h000066400000000000000000000023261356361734700266640ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _THREAD_INFO_H #define _THREAD_INFO_H #include "ServerConnection.h" #include struct EGLWrapperContext { EGLWrapperContext(EGLContext p_aglContext, int _version) { aglContext = p_aglContext; clientState = NULL; version = _version; } ~EGLWrapperContext() { delete clientState; } EGLContext aglContext; GLClientState *clientState; int version; }; struct EGLThreadInfo { EGLThreadInfo() : currentContext(NULL), serverConn(NULL) {} EGLWrapperContext *currentContext; ServerConnection *serverConn; }; EGLThreadInfo *getEGLThreadInfo(); #endif anbox-0.0~git20191115/android/opengl/tests/gles_android_wrapper/egl.cfg000066400000000000000000000000101356361734700257040ustar00rootroot000000000000000 0 emulanbox-0.0~git20191115/android/opengl/tests/gles_android_wrapper/egl.cpp000066400000000000000000000513221356361734700257430ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ // // WARNING -------------------------- WARNING // This code meant to be used for testing purposes only. It is not production // level quality. // Use on your own risk !! // #include #include #include #include #include "egl_dispatch.h" #include "egl_ftable.h" #include #include #include "ServerConnection.h" #include "ThreadInfo.h" #include #include "gl_wrapper_context.h" #include "gl2_wrapper_context.h" #define GLES_EMUL_TARGETS_FILE "/system/etc/gles_emul.cfg" // implementation libraries; #define GLESv1_enc_LIB "/system/lib/libGLESv1_enc.so" #define GLESv2_enc_LIB "/system/lib/libGLESv2_enc.so" #define GLES_android_LIB "/system/lib/egl/libGLES_android.so" // driver libraries; #define GLESv1_DRIVER "/system/lib/egl/libGLESv1_CM_emul.so" #define GLESv2_DRIVER "/system/lib/egl/libGLESv2_emul.so" static struct egl_dispatch *s_dispatch = NULL; pthread_once_t dispatchTablesInitialized = PTHREAD_ONCE_INIT; static bool s_needEncode = false; static gl_wrapper_context_t *g_gl_dispatch = NULL; static gl2_wrapper_context_t *g_gl2_dispatch = NULL; template int initApi(const char *driverLibName, const char *implLibName, T **dispatchTable, T *(*accessor)()) { void *driverLib = dlopen(driverLibName, RTLD_NOW | RTLD_LOCAL); if (driverLib == NULL) { ALOGE("failed to load %s : %s\n", driverLibName, dlerror()); return -1; } typedef T *(*createFcn_t)(void *, T *(*accessor)()); createFcn_t createFcn; createFcn = (createFcn_t) dlsym(driverLib, "createFromLib"); if (createFcn == NULL) { ALOGE("failed to load createFromLib constructor function\n"); return -1; } void *implLib = dlopen(implLibName, RTLD_NOW | RTLD_LOCAL); if (implLib == NULL) { ALOGE("couldn't open %s", implLibName); return -2; } *dispatchTable = createFcn(implLib, accessor); if (*dispatchTable == NULL) { return -3; } // XXX - we do close the impl library since it doesn't have data, as far as we concern. dlclose(implLib); // XXX - we do not dlclose the driver library, so its not initialized when // later loaded by android - is this required? ALOGD("loading %s into %s complete\n", implLibName, driverLibName); return 0; } static gl_wrapper_context_t *getGLContext() { return g_gl_dispatch; } static gl2_wrapper_context_t *getGL2Context() { return g_gl2_dispatch; } const char *getProcName() { static const char *procname = NULL; if (procname == NULL) { const char *str = get_process_name(); if (strcmp(str, "unknown") != 0) { procname = str; } else { // we need to obtain our process name from the command line; FILE *fp = fopen("/proc/self/cmdline", "rt"); if (fp == NULL) { ALOGE("couldn't open /proc/self/cmdline\n"); return NULL; } char line[1000]; if (fgets(line, sizeof(line), fp) == NULL) { ALOGE("couldn't read the self cmdline from \n"); fclose(fp); return NULL; } fclose(fp); if (line[0] == '\0') { ALOGE("cmdline is empty\n"); return NULL; } //obtain the basename; line[sizeof(line) - 1] = '\0'; char *p = line; while (*p != '\0' && *p != '\t' && *p != ' ' && *p != '\n') { p++; } *p = '\0'; p--; while (p > line && *p != '/') p--; if (*p == '/') p++; procname = strdup(p); } } return procname; } bool isNeedEncode() { const char *procname = getProcName(); if (procname == NULL) return false; ALOGD("isNeedEncode? for %s\n", procname); // check on our whitelist FILE *fp = fopen(GLES_EMUL_TARGETS_FILE, "rt"); if (fp == NULL) { ALOGE("couldn't open %s\n", GLES_EMUL_TARGETS_FILE); return false; } char line[100]; bool found = false; size_t procnameLen = strlen(procname); while (fgets(line, sizeof(line), fp) != NULL) { if (strlen(line) >= procnameLen && !strncmp(procname, line, procnameLen)) { char c = line[procnameLen]; if (c == '\0' || c == ' ' || c == '\t' || c == '\n') { found = true; ALOGD("should use encoder for %s\n", procname); break; } } } fclose(fp); return found; } void initDispatchTables() { // // Load our back-end implementation of EGL/GLES // ALOGD("Loading egl dispatch for %s\n", getProcName()); void *gles_android = dlopen("/system/lib/egl/libGLES_android.so", RTLD_NOW | RTLD_LOCAL); if (!gles_android) { fprintf(stderr,"FATAL ERROR: Could not load libGLES_android lib\n"); exit(-1); } // // Load back-end EGL implementation library // s_dispatch = create_egl_dispatch( gles_android ); if (!s_dispatch) { fprintf(stderr,"FATAL ERROR: Could not create egl dispatch\n"); exit(-1); } // // initialize gles // s_needEncode = isNeedEncode(); void *gles_encoder = NULL; if (s_needEncode) { // initialize a connection to the server, and the GLESv1/v2 encoders; ServerConnection * connection = ServerConnection::s_getServerConnection(); if (connection == NULL) { ALOGE("couldn't create server connection\n"); s_needEncode = false; } } // init dispatch tabels for GLESv1 & GLESv2 if (s_needEncode) { // XXX - we do not check the retrun value because there isn't much we can do here on failure. if (initApi(GLESv1_DRIVER, GLESv1_enc_LIB, &g_gl_dispatch, getGLContext) < 0) { // fallback to android on faluire s_needEncode = false; } else { initApi(GLESv2_DRIVER, GLESv2_enc_LIB, &g_gl2_dispatch, getGL2Context); } } if (!s_needEncode) { ALOGD("Initializing native opengl for %s\n", getProcName()); initApi(GLESv1_DRIVER, GLES_android_LIB, &g_gl_dispatch, getGLContext); // try to initialize gl2 from GLES, though its probably going to fail initApi(GLESv2_DRIVER, GLES_android_LIB, &g_gl2_dispatch, getGL2Context); } } static struct egl_dispatch *getDispatch() { pthread_once(&dispatchTablesInitialized, initDispatchTables); return s_dispatch; } __eglMustCastToProperFunctionPointerType eglGetProcAddress(const char *procname) { // search in EGL function table for (int i=0; ieglGetError(); } EGLDisplay eglGetDisplay(EGLNativeDisplayType display_id) { return getDispatch()->eglGetDisplay(display_id); } EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor) { return getDispatch()->eglInitialize(dpy, major, minor); } EGLBoolean eglTerminate(EGLDisplay dpy) { return getDispatch()->eglTerminate(dpy); } const char* eglQueryString(EGLDisplay dpy, EGLint name) { return getDispatch()->eglQueryString(dpy, name); } EGLBoolean eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config) { return getDispatch()->eglGetConfigs(dpy, configs, config_size, num_config); } static EGLint * filter_es2_bit(const EGLint *attrib_list, bool *isES2) { if (attrib_list == NULL) { if (isES2 != NULL) *isES2 = false; return NULL; } EGLint *attribs = NULL; int nAttribs = 0; while(attrib_list[nAttribs] != EGL_NONE) nAttribs++; nAttribs++; attribs = new EGLint[nAttribs]; memcpy(attribs, attrib_list, nAttribs * sizeof(EGLint)); if (isES2 != NULL) *isES2 = false; // scan the attribute list for ES2 request and replace with ES1. for (int i = 0; i < nAttribs; i++) { if (attribs[i] == EGL_RENDERABLE_TYPE) { if (attribs[i + 1] & EGL_OPENGL_ES2_BIT) { attribs[i + 1] &= ~EGL_OPENGL_ES2_BIT; attribs[i + 1] |= EGL_OPENGL_ES_BIT; ALOGD("removing ES2 bit 0x%x\n", attribs[i + 1]); if (isES2 != NULL) *isES2 = true; } } } return attribs; } EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config) { EGLBoolean res; if (s_needEncode) { EGLint *attribs = filter_es2_bit(attrib_list, NULL); res = getDispatch()->eglChooseConfig(dpy, attribs, configs, config_size, num_config); ALOGD("eglChooseConfig: %d configs found\n", *num_config); if (*num_config == 0 && attribs != NULL) { ALOGD("requested attributes:\n"); for (int i = 0; attribs[i] != EGL_NONE; i++) { ALOGD("%d: 0x%x\n", i, attribs[i]); } } delete attribs; } else { res = getDispatch()->eglChooseConfig(dpy, attrib_list, configs, config_size, num_config); } return res; } EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value) { if (s_needEncode && attribute == EGL_RENDERABLE_TYPE) { *value = EGL_OPENGL_ES_BIT | EGL_OPENGL_ES2_BIT; return EGL_TRUE; } else { return getDispatch()->eglGetConfigAttrib(dpy, config, attribute, value); } } EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list) { EGLSurface surface = getDispatch()->eglCreateWindowSurface(dpy, config, win, attrib_list); if (surface != EGL_NO_SURFACE) { ServerConnection *server; if (s_needEncode && (server = ServerConnection::s_getServerConnection()) != NULL) { server->utEnc()->createSurface(server->utEnc(), getpid(), (uint32_t)surface); } } return surface; } EGLSurface eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list) { EGLSurface surface = getDispatch()->eglCreatePbufferSurface(dpy, config, attrib_list); if (surface != EGL_NO_SURFACE) { ServerConnection *server; if (s_needEncode && (server = ServerConnection::s_getServerConnection()) != NULL) { server->utEnc()->createSurface(server->utEnc(), getpid(), (uint32_t)surface); } } return surface; } EGLSurface eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list) { EGLSurface surface = getDispatch()->eglCreatePixmapSurface(dpy, config, pixmap, attrib_list); if (surface != EGL_NO_SURFACE) { ServerConnection *server; if (s_needEncode && (server = ServerConnection::s_getServerConnection()) != NULL) { server->utEnc()->createSurface(server->utEnc(), getpid(), (uint32_t)surface); } } return surface; } EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface) { EGLBoolean res = getDispatch()->eglDestroySurface(dpy, surface); if (res && surface != EGL_NO_SURFACE) { ServerConnection *server; if (s_needEncode && (server = ServerConnection::s_getServerConnection()) != NULL) { server->utEnc()->destroySurface(server->utEnc(), getpid(), (uint32_t)surface); } } return res; } EGLBoolean eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value) { EGLBoolean res = getDispatch()->eglQuerySurface(dpy, surface, attribute, value); if (res && attribute == EGL_RENDERABLE_TYPE) { *value |= EGL_OPENGL_ES2_BIT; } return res; } EGLBoolean eglBindAPI(EGLenum api) { return getDispatch()->eglBindAPI(api); } EGLenum eglQueryAPI() { return getDispatch()->eglQueryAPI(); } EGLBoolean eglWaitClient() { return getDispatch()->eglWaitClient(); } EGLBoolean eglReleaseThread() { return getDispatch()->eglReleaseThread(); } EGLSurface eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list) { return getDispatch()->eglCreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list); } EGLBoolean eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value) { return getDispatch()->eglSurfaceAttrib(dpy, surface, attribute, value); } EGLBoolean eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) { return getDispatch()->eglBindTexImage(dpy, surface, buffer); } EGLBoolean eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) { return getDispatch()->eglReleaseTexImage(dpy, surface, buffer); } EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval) { return getDispatch()->eglSwapInterval(dpy, interval); } EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list) { EGLContext share = share_context; if (share) share = ((EGLWrapperContext *)share_context)->aglContext; // check if are ES2, and convert it to ES1. int nAttribs = 0; if (attrib_list != NULL) { while(attrib_list[nAttribs] != EGL_NONE) { nAttribs++; } nAttribs++; } EGLint *attrib = NULL; if (nAttribs > 0) { attrib = new EGLint[nAttribs]; memcpy(attrib, attrib_list, nAttribs * sizeof(EGLint)); } int version = 1; for (int i = 0; i < nAttribs; i++) { if (attrib[i] == EGL_CONTEXT_CLIENT_VERSION && attrib[i + 1] == 2) { version = 2; attrib[i + 1] = 1; // replace to version 1 } } EGLContext ctx = getDispatch()->eglCreateContext(dpy, config, share, attrib); delete attrib; EGLWrapperContext *wctx = new EGLWrapperContext(ctx, version); if (ctx != EGL_NO_CONTEXT) { ServerConnection *server; if (s_needEncode && (server = ServerConnection::s_getServerConnection()) != NULL) { wctx->clientState = new GLClientState(); server->utEnc()->createContext(server->utEnc(), getpid(), (uint32_t)wctx, (uint32_t)(share_context == EGL_NO_CONTEXT ? 0 : share_context), wctx->version); } } return (EGLContext)wctx; } EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx) { EGLWrapperContext *wctx = (EGLWrapperContext *)ctx; EGLBoolean res = EGL_FALSE; if (ctx && ctx != EGL_NO_CONTEXT) { res = getDispatch()->eglDestroyContext(dpy, wctx->aglContext); if (res) { EGLThreadInfo *ti = getEGLThreadInfo(); ServerConnection *server; if (s_needEncode && (server = ServerConnection::s_getServerConnection())) { server->utEnc()->destroyContext(ti->serverConn->utEnc(), getpid(), (uint32_t)ctx); } if (ti->currentContext == wctx) ti->currentContext = NULL; delete wctx; } } return res; } EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) { EGLWrapperContext *wctx = (EGLWrapperContext *)ctx; EGLContext aglContext = (ctx == EGL_NO_CONTEXT ? EGL_NO_CONTEXT : wctx->aglContext); EGLThreadInfo *ti = getEGLThreadInfo(); EGLBoolean res = getDispatch()->eglMakeCurrent(dpy, draw, read, aglContext); if (res ) { // NOTE - we do get a pointer to the server connection, (rather then using ti->serverConn) // for cases that this is the first egl call of the current thread. ServerConnection *server; if (s_needEncode && (server = ServerConnection::s_getServerConnection())) { server->utEnc()->makeCurrentContext(server->utEnc(), getpid(), (uint32_t) (draw == EGL_NO_SURFACE ? 0 : draw), (uint32_t) (read == EGL_NO_SURFACE ? 0 : read), (uint32_t) (ctx == EGL_NO_CONTEXT ? 0 : ctx)); server->glEncoder()->setClientState( wctx ? wctx->clientState : NULL ); server->gl2Encoder()->setClientState( wctx ? wctx->clientState : NULL ); } // set current context in our thread info ti->currentContext = wctx; } return res; } EGLContext eglGetCurrentContext() { EGLThreadInfo *ti = getEGLThreadInfo(); return (ti->currentContext ? ti->currentContext : EGL_NO_CONTEXT); } EGLSurface eglGetCurrentSurface(EGLint readdraw) { return getDispatch()->eglGetCurrentSurface(readdraw); } EGLDisplay eglGetCurrentDisplay() { return getDispatch()->eglGetCurrentDisplay(); } EGLBoolean eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value) { EGLWrapperContext *wctx = (EGLWrapperContext *)ctx; if (wctx) { if (attribute == EGL_CONTEXT_CLIENT_VERSION) { *value = wctx->version; return EGL_TRUE; } else { return getDispatch()->eglQueryContext(dpy, wctx->aglContext, attribute, value); } } else { return EGL_BAD_CONTEXT; } } EGLBoolean eglWaitGL() { return getDispatch()->eglWaitGL(); } EGLBoolean eglWaitNative(EGLint engine) { return getDispatch()->eglWaitNative(engine); } EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface surface) { ServerConnection *server; if (s_needEncode && (server = ServerConnection::s_getServerConnection()) != NULL) { server->utEnc()->swapBuffers(server->utEnc(), getpid(), (uint32_t)surface); server->glEncoder()->flush(); server->gl2Encoder()->flush(); return 1; } return getDispatch()->eglSwapBuffers(dpy, surface); } EGLBoolean eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target) { return getDispatch()->eglCopyBuffers(dpy, surface, target); } EGLBoolean eglLockSurfaceKHR(EGLDisplay display, EGLSurface surface, const EGLint *attrib_list) { return getDispatch()->eglLockSurfaceKHR(display, surface, attrib_list); } EGLBoolean eglUnlockSurfaceKHR(EGLDisplay display, EGLSurface surface) { return getDispatch()->eglUnlockSurfaceKHR(display, surface); } EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list) { EGLWrapperContext *wctx = (EGLWrapperContext *)ctx; EGLContext aglContext = (wctx ? wctx->aglContext : EGL_NO_CONTEXT); return getDispatch()->eglCreateImageKHR(dpy, aglContext, target, buffer, attrib_list); } EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image) { return getDispatch()->eglDestroyImageKHR(dpy, image); } EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list) { return getDispatch()->eglCreateSyncKHR(dpy, type, attrib_list); } EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync) { return getDispatch()->eglDestroySyncKHR(dpy, sync); } EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout) { return getDispatch()->eglClientWaitSyncKHR(dpy, sync, flags, timeout); } EGLBoolean eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode) { return getDispatch()->eglSignalSyncKHR(dpy, sync, mode); } EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value) { return getDispatch()->eglGetSyncAttribKHR(dpy, sync, attribute, value); } EGLBoolean eglSetSwapRectangleANDROID(EGLDisplay dpy, EGLSurface draw, EGLint left, EGLint top, EGLint width, EGLint height) { return getDispatch()->eglSetSwapRectangleANDROID(dpy, draw, left, top, width, height); } anbox-0.0~git20191115/android/opengl/tests/gles_android_wrapper/egl_dispatch.cpp000066400000000000000000000124451356361734700276250ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include "egl_dispatch.h" #include egl_dispatch *create_egl_dispatch(void *gles_android) { egl_dispatch *disp = new egl_dispatch; void *ptr; ptr = dlsym(gles_android,"eglGetError"); disp->set_eglGetError((eglGetError_t)ptr); ptr = dlsym(gles_android,"eglGetDisplay"); disp->set_eglGetDisplay((eglGetDisplay_t)ptr); ptr = dlsym(gles_android,"eglInitialize"); disp->set_eglInitialize((eglInitialize_t)ptr); ptr = dlsym(gles_android,"eglTerminate"); disp->set_eglTerminate((eglTerminate_t)ptr); ptr = dlsym(gles_android,"eglQueryString"); disp->set_eglQueryString((eglQueryString_t)ptr); ptr = dlsym(gles_android,"eglGetConfigs"); disp->set_eglGetConfigs((eglGetConfigs_t)ptr); ptr = dlsym(gles_android,"eglChooseConfig"); disp->set_eglChooseConfig((eglChooseConfig_t)ptr); ptr = dlsym(gles_android,"eglGetConfigAttrib"); disp->set_eglGetConfigAttrib((eglGetConfigAttrib_t)ptr); ptr = dlsym(gles_android,"eglCreateWindowSurface"); disp->set_eglCreateWindowSurface((eglCreateWindowSurface_t)ptr); ptr = dlsym(gles_android,"eglCreatePbufferSurface"); disp->set_eglCreatePbufferSurface((eglCreatePbufferSurface_t)ptr); ptr = dlsym(gles_android,"eglCreatePixmapSurface"); disp->set_eglCreatePixmapSurface((eglCreatePixmapSurface_t)ptr); ptr = dlsym(gles_android,"eglDestroySurface"); disp->set_eglDestroySurface((eglDestroySurface_t)ptr); ptr = dlsym(gles_android,"eglQuerySurface"); disp->set_eglQuerySurface((eglQuerySurface_t)ptr); ptr = dlsym(gles_android,"eglBindAPI"); disp->set_eglBindAPI((eglBindAPI_t)ptr); ptr = dlsym(gles_android,"eglQueryAPI"); disp->set_eglQueryAPI((eglQueryAPI_t)ptr); ptr = dlsym(gles_android,"eglWaitClient"); disp->set_eglWaitClient((eglWaitClient_t)ptr); ptr = dlsym(gles_android,"eglReleaseThread"); disp->set_eglReleaseThread((eglReleaseThread_t)ptr); ptr = dlsym(gles_android,"eglCreatePbufferFromClientBuffer"); disp->set_eglCreatePbufferFromClientBuffer((eglCreatePbufferFromClientBuffer_t)ptr); ptr = dlsym(gles_android,"eglSurfaceAttrib"); disp->set_eglSurfaceAttrib((eglSurfaceAttrib_t)ptr); ptr = dlsym(gles_android,"eglBindTexImage"); disp->set_eglBindTexImage((eglBindTexImage_t)ptr); ptr = dlsym(gles_android,"eglReleaseTexImage"); disp->set_eglReleaseTexImage((eglReleaseTexImage_t)ptr); ptr = dlsym(gles_android,"eglSwapInterval"); disp->set_eglSwapInterval((eglSwapInterval_t)ptr); ptr = dlsym(gles_android,"eglCreateContext"); disp->set_eglCreateContext((eglCreateContext_t)ptr); ptr = dlsym(gles_android,"eglDestroyContext"); disp->set_eglDestroyContext((eglDestroyContext_t)ptr); ptr = dlsym(gles_android,"eglMakeCurrent"); disp->set_eglMakeCurrent((eglMakeCurrent_t)ptr); ptr = dlsym(gles_android,"eglGetCurrentContext"); disp->set_eglGetCurrentContext((eglGetCurrentContext_t)ptr); ptr = dlsym(gles_android,"eglGetCurrentSurface"); disp->set_eglGetCurrentSurface((eglGetCurrentSurface_t)ptr); ptr = dlsym(gles_android,"eglGetCurrentDisplay"); disp->set_eglGetCurrentDisplay((eglGetCurrentDisplay_t)ptr); ptr = dlsym(gles_android,"eglQueryContext"); disp->set_eglQueryContext((eglQueryContext_t)ptr); ptr = dlsym(gles_android,"eglWaitGL"); disp->set_eglWaitGL((eglWaitGL_t)ptr); ptr = dlsym(gles_android,"eglWaitNative"); disp->set_eglWaitNative((eglWaitNative_t)ptr); ptr = dlsym(gles_android,"eglSwapBuffers"); disp->set_eglSwapBuffers((eglSwapBuffers_t)ptr); ptr = dlsym(gles_android,"eglCopyBuffers"); disp->set_eglCopyBuffers((eglCopyBuffers_t)ptr); ptr = dlsym(gles_android,"eglGetProcAddress"); disp->set_eglGetProcAddress((eglGetProcAddress_t)ptr); ptr = dlsym(gles_android,"eglLockSurfaceKHR"); disp->set_eglLockSurfaceKHR((eglLockSurfaceKHR_t)ptr); ptr = dlsym(gles_android,"eglUnlockSurfaceKHR"); disp->set_eglUnlockSurfaceKHR((eglUnlockSurfaceKHR_t)ptr); ptr = dlsym(gles_android,"eglCreateImageKHR"); disp->set_eglCreateImageKHR((eglCreateImageKHR_t)ptr); ptr = dlsym(gles_android,"eglDestroyImageKHR"); disp->set_eglDestroyImageKHR((eglDestroyImageKHR_t)ptr); ptr = dlsym(gles_android,"eglCreateSyncKHR"); disp->set_eglCreateSyncKHR((eglCreateSyncKHR_t)ptr); ptr = dlsym(gles_android,"eglDestroySyncKHR"); disp->set_eglDestroySyncKHR((eglDestroySyncKHR_t)ptr); ptr = dlsym(gles_android,"eglClientWaitSyncKHR"); disp->set_eglClientWaitSyncKHR((eglClientWaitSyncKHR_t)ptr); ptr = dlsym(gles_android,"eglSignalSyncKHR"); disp->set_eglSignalSyncKHR((eglSignalSyncKHR_t)ptr); ptr = dlsym(gles_android,"eglGetSyncAttribKHR"); disp->set_eglGetSyncAttribKHR((eglGetSyncAttribKHR_t)ptr); ptr = dlsym(gles_android,"eglSetSwapRectangleANDROID"); disp->set_eglSetSwapRectangleANDROID((eglSetSwapRectangleANDROID_t)ptr); return disp; } anbox-0.0~git20191115/android/opengl/tests/gles_android_wrapper/egl_dispatch.h000066400000000000000000000223661356361734700272750ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _EGL_DISPATCH_H #define _EGL_DISPATCH_H #include "egl_proc.h" struct egl_dispatch { eglGetError_t eglGetError; eglGetDisplay_t eglGetDisplay; eglInitialize_t eglInitialize; eglTerminate_t eglTerminate; eglQueryString_t eglQueryString; eglGetConfigs_t eglGetConfigs; eglChooseConfig_t eglChooseConfig; eglGetConfigAttrib_t eglGetConfigAttrib; eglCreateWindowSurface_t eglCreateWindowSurface; eglCreatePbufferSurface_t eglCreatePbufferSurface; eglCreatePixmapSurface_t eglCreatePixmapSurface; eglDestroySurface_t eglDestroySurface; eglQuerySurface_t eglQuerySurface; eglBindAPI_t eglBindAPI; eglQueryAPI_t eglQueryAPI; eglWaitClient_t eglWaitClient; eglReleaseThread_t eglReleaseThread; eglCreatePbufferFromClientBuffer_t eglCreatePbufferFromClientBuffer; eglSurfaceAttrib_t eglSurfaceAttrib; eglBindTexImage_t eglBindTexImage; eglReleaseTexImage_t eglReleaseTexImage; eglSwapInterval_t eglSwapInterval; eglCreateContext_t eglCreateContext; eglDestroyContext_t eglDestroyContext; eglMakeCurrent_t eglMakeCurrent; eglGetCurrentContext_t eglGetCurrentContext; eglGetCurrentSurface_t eglGetCurrentSurface; eglGetCurrentDisplay_t eglGetCurrentDisplay; eglQueryContext_t eglQueryContext; eglWaitGL_t eglWaitGL; eglWaitNative_t eglWaitNative; eglSwapBuffers_t eglSwapBuffers; eglCopyBuffers_t eglCopyBuffers; eglGetProcAddress_t eglGetProcAddress; eglLockSurfaceKHR_t eglLockSurfaceKHR; eglUnlockSurfaceKHR_t eglUnlockSurfaceKHR; eglCreateImageKHR_t eglCreateImageKHR; eglDestroyImageKHR_t eglDestroyImageKHR; eglCreateSyncKHR_t eglCreateSyncKHR; eglDestroySyncKHR_t eglDestroySyncKHR; eglClientWaitSyncKHR_t eglClientWaitSyncKHR; eglSignalSyncKHR_t eglSignalSyncKHR; eglGetSyncAttribKHR_t eglGetSyncAttribKHR; eglSetSwapRectangleANDROID_t eglSetSwapRectangleANDROID; //Accessors eglGetError_t set_eglGetError(eglGetError_t f) { eglGetError_t retval = eglGetError; eglGetError = f; return retval;} eglGetDisplay_t set_eglGetDisplay(eglGetDisplay_t f) { eglGetDisplay_t retval = eglGetDisplay; eglGetDisplay = f; return retval;} eglInitialize_t set_eglInitialize(eglInitialize_t f) { eglInitialize_t retval = eglInitialize; eglInitialize = f; return retval;} eglTerminate_t set_eglTerminate(eglTerminate_t f) { eglTerminate_t retval = eglTerminate; eglTerminate = f; return retval;} eglQueryString_t set_eglQueryString(eglQueryString_t f) { eglQueryString_t retval = eglQueryString; eglQueryString = f; return retval;} eglGetConfigs_t set_eglGetConfigs(eglGetConfigs_t f) { eglGetConfigs_t retval = eglGetConfigs; eglGetConfigs = f; return retval;} eglChooseConfig_t set_eglChooseConfig(eglChooseConfig_t f) { eglChooseConfig_t retval = eglChooseConfig; eglChooseConfig = f; return retval;} eglGetConfigAttrib_t set_eglGetConfigAttrib(eglGetConfigAttrib_t f) { eglGetConfigAttrib_t retval = eglGetConfigAttrib; eglGetConfigAttrib = f; return retval;} eglCreateWindowSurface_t set_eglCreateWindowSurface(eglCreateWindowSurface_t f) { eglCreateWindowSurface_t retval = eglCreateWindowSurface; eglCreateWindowSurface = f; return retval;} eglCreatePbufferSurface_t set_eglCreatePbufferSurface(eglCreatePbufferSurface_t f) { eglCreatePbufferSurface_t retval = eglCreatePbufferSurface; eglCreatePbufferSurface = f; return retval;} eglCreatePixmapSurface_t set_eglCreatePixmapSurface(eglCreatePixmapSurface_t f) { eglCreatePixmapSurface_t retval = eglCreatePixmapSurface; eglCreatePixmapSurface = f; return retval;} eglDestroySurface_t set_eglDestroySurface(eglDestroySurface_t f) { eglDestroySurface_t retval = eglDestroySurface; eglDestroySurface = f; return retval;} eglQuerySurface_t set_eglQuerySurface(eglQuerySurface_t f) { eglQuerySurface_t retval = eglQuerySurface; eglQuerySurface = f; return retval;} eglBindAPI_t set_eglBindAPI(eglBindAPI_t f) { eglBindAPI_t retval = eglBindAPI; eglBindAPI = f; return retval;} eglQueryAPI_t set_eglQueryAPI(eglQueryAPI_t f) { eglQueryAPI_t retval = eglQueryAPI; eglQueryAPI = f; return retval;} eglWaitClient_t set_eglWaitClient(eglWaitClient_t f) { eglWaitClient_t retval = eglWaitClient; eglWaitClient = f; return retval;} eglReleaseThread_t set_eglReleaseThread(eglReleaseThread_t f) { eglReleaseThread_t retval = eglReleaseThread; eglReleaseThread = f; return retval;} eglCreatePbufferFromClientBuffer_t set_eglCreatePbufferFromClientBuffer(eglCreatePbufferFromClientBuffer_t f) { eglCreatePbufferFromClientBuffer_t retval = eglCreatePbufferFromClientBuffer; eglCreatePbufferFromClientBuffer = f; return retval;} eglSurfaceAttrib_t set_eglSurfaceAttrib(eglSurfaceAttrib_t f) { eglSurfaceAttrib_t retval = eglSurfaceAttrib; eglSurfaceAttrib = f; return retval;} eglBindTexImage_t set_eglBindTexImage(eglBindTexImage_t f) { eglBindTexImage_t retval = eglBindTexImage; eglBindTexImage = f; return retval;} eglReleaseTexImage_t set_eglReleaseTexImage(eglReleaseTexImage_t f) { eglReleaseTexImage_t retval = eglReleaseTexImage; eglReleaseTexImage = f; return retval;} eglSwapInterval_t set_eglSwapInterval(eglSwapInterval_t f) { eglSwapInterval_t retval = eglSwapInterval; eglSwapInterval = f; return retval;} eglCreateContext_t set_eglCreateContext(eglCreateContext_t f) { eglCreateContext_t retval = eglCreateContext; eglCreateContext = f; return retval;} eglDestroyContext_t set_eglDestroyContext(eglDestroyContext_t f) { eglDestroyContext_t retval = eglDestroyContext; eglDestroyContext = f; return retval;} eglMakeCurrent_t set_eglMakeCurrent(eglMakeCurrent_t f) { eglMakeCurrent_t retval = eglMakeCurrent; eglMakeCurrent = f; return retval;} eglGetCurrentContext_t set_eglGetCurrentContext(eglGetCurrentContext_t f) { eglGetCurrentContext_t retval = eglGetCurrentContext; eglGetCurrentContext = f; return retval;} eglGetCurrentSurface_t set_eglGetCurrentSurface(eglGetCurrentSurface_t f) { eglGetCurrentSurface_t retval = eglGetCurrentSurface; eglGetCurrentSurface = f; return retval;} eglGetCurrentDisplay_t set_eglGetCurrentDisplay(eglGetCurrentDisplay_t f) { eglGetCurrentDisplay_t retval = eglGetCurrentDisplay; eglGetCurrentDisplay = f; return retval;} eglQueryContext_t set_eglQueryContext(eglQueryContext_t f) { eglQueryContext_t retval = eglQueryContext; eglQueryContext = f; return retval;} eglWaitGL_t set_eglWaitGL(eglWaitGL_t f) { eglWaitGL_t retval = eglWaitGL; eglWaitGL = f; return retval;} eglWaitNative_t set_eglWaitNative(eglWaitNative_t f) { eglWaitNative_t retval = eglWaitNative; eglWaitNative = f; return retval;} eglSwapBuffers_t set_eglSwapBuffers(eglSwapBuffers_t f) { eglSwapBuffers_t retval = eglSwapBuffers; eglSwapBuffers = f; return retval;} eglCopyBuffers_t set_eglCopyBuffers(eglCopyBuffers_t f) { eglCopyBuffers_t retval = eglCopyBuffers; eglCopyBuffers = f; return retval;} eglGetProcAddress_t set_eglGetProcAddress(eglGetProcAddress_t f) { eglGetProcAddress_t retval = eglGetProcAddress; eglGetProcAddress = f; return retval;} eglLockSurfaceKHR_t set_eglLockSurfaceKHR(eglLockSurfaceKHR_t f) { eglLockSurfaceKHR_t retval = eglLockSurfaceKHR; eglLockSurfaceKHR = f; return retval;} eglUnlockSurfaceKHR_t set_eglUnlockSurfaceKHR(eglUnlockSurfaceKHR_t f) { eglUnlockSurfaceKHR_t retval = eglUnlockSurfaceKHR; eglUnlockSurfaceKHR = f; return retval;} eglCreateImageKHR_t set_eglCreateImageKHR(eglCreateImageKHR_t f) { eglCreateImageKHR_t retval = eglCreateImageKHR; eglCreateImageKHR = f; return retval;} eglDestroyImageKHR_t set_eglDestroyImageKHR(eglDestroyImageKHR_t f) { eglDestroyImageKHR_t retval = eglDestroyImageKHR; eglDestroyImageKHR = f; return retval;} eglCreateSyncKHR_t set_eglCreateSyncKHR(eglCreateSyncKHR_t f) { eglCreateSyncKHR_t retval = eglCreateSyncKHR; eglCreateSyncKHR = f; return retval;} eglDestroySyncKHR_t set_eglDestroySyncKHR(eglDestroySyncKHR_t f) { eglDestroySyncKHR_t retval = eglDestroySyncKHR; eglDestroySyncKHR = f; return retval;} eglClientWaitSyncKHR_t set_eglClientWaitSyncKHR(eglClientWaitSyncKHR_t f) { eglClientWaitSyncKHR_t retval = eglClientWaitSyncKHR; eglClientWaitSyncKHR = f; return retval;} eglSignalSyncKHR_t set_eglSignalSyncKHR(eglSignalSyncKHR_t f) { eglSignalSyncKHR_t retval = eglSignalSyncKHR; eglSignalSyncKHR = f; return retval;} eglGetSyncAttribKHR_t set_eglGetSyncAttribKHR(eglGetSyncAttribKHR_t f) { eglGetSyncAttribKHR_t retval = eglGetSyncAttribKHR; eglGetSyncAttribKHR = f; return retval;} eglSetSwapRectangleANDROID_t set_eglSetSwapRectangleANDROID(eglSetSwapRectangleANDROID_t f) { eglSetSwapRectangleANDROID_t retval = eglSetSwapRectangleANDROID; eglSetSwapRectangleANDROID = f; return retval;} }; egl_dispatch *create_egl_dispatch(void *gles_andorid); #endif anbox-0.0~git20191115/android/opengl/tests/gles_android_wrapper/egl_ftable.h000066400000000000000000000060711356361734700267260ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ static struct _egl_funcs_by_name { const char *name; void *proc; } egl_funcs_by_name[] = { {"eglGetError", (void *)eglGetError}, {"eglGetDisplay", (void *)eglGetDisplay}, {"eglInitialize", (void *)eglInitialize}, {"eglTerminate", (void *)eglTerminate}, {"eglQueryString", (void *)eglQueryString}, {"eglGetConfigs", (void *)eglGetConfigs}, {"eglChooseConfig", (void *)eglChooseConfig}, {"eglGetConfigAttrib", (void *)eglGetConfigAttrib}, {"eglCreateWindowSurface", (void *)eglCreateWindowSurface}, {"eglCreatePbufferSurface", (void *)eglCreatePbufferSurface}, {"eglCreatePixmapSurface", (void *)eglCreatePixmapSurface}, {"eglDestroySurface", (void *)eglDestroySurface}, {"eglQuerySurface", (void *)eglQuerySurface}, {"eglBindAPI", (void *)eglBindAPI}, {"eglQueryAPI", (void *)eglQueryAPI}, {"eglWaitClient", (void *)eglWaitClient}, {"eglReleaseThread", (void *)eglReleaseThread}, {"eglCreatePbufferFromClientBuffer", (void *)eglCreatePbufferFromClientBuffer}, {"eglSurfaceAttrib", (void *)eglSurfaceAttrib}, {"eglBindTexImage", (void *)eglBindTexImage}, {"eglReleaseTexImage", (void *)eglReleaseTexImage}, {"eglSwapInterval", (void *)eglSwapInterval}, {"eglCreateContext", (void *)eglCreateContext}, {"eglDestroyContext", (void *)eglDestroyContext}, {"eglMakeCurrent", (void *)eglMakeCurrent}, {"eglGetCurrentContext", (void *)eglGetCurrentContext}, {"eglGetCurrentSurface", (void *)eglGetCurrentSurface}, {"eglGetCurrentDisplay", (void *)eglGetCurrentDisplay}, {"eglQueryContext", (void *)eglQueryContext}, {"eglWaitGL", (void *)eglWaitGL}, {"eglWaitNative", (void *)eglWaitNative}, {"eglSwapBuffers", (void *)eglSwapBuffers}, {"eglCopyBuffers", (void *)eglCopyBuffers}, {"eglGetProcAddress", (void *)eglGetProcAddress}, {"eglLockSurfaceKHR", (void *)eglLockSurfaceKHR}, {"eglUnlockSurfaceKHR", (void *)eglUnlockSurfaceKHR}, {"eglCreateImageKHR", (void *)eglCreateImageKHR}, {"eglDestroyImageKHR", (void *)eglDestroyImageKHR}, {"eglCreateSyncKHR", (void *)eglCreateSyncKHR}, {"eglDestroySyncKHR", (void *)eglDestroySyncKHR}, {"eglClientWaitSyncKHR", (void *)eglClientWaitSyncKHR}, {"eglSignalSyncKHR", (void *)eglSignalSyncKHR}, {"eglGetSyncAttribKHR", (void *)eglGetSyncAttribKHR}, {"eglSetSwapRectangleANDROID", (void *)eglSetSwapRectangleANDROID} }; static int egl_num_funcs = sizeof(egl_funcs_by_name) / sizeof(struct _egl_funcs_by_name); anbox-0.0~git20191115/android/opengl/tests/gles_android_wrapper/egl_proc.h000066400000000000000000000077101356361734700264350ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _EGL_PROC_H #define _EGL_PROC_H #include #define EGL_EGLEXT_PROTOTYPES #include typedef EGLint (* eglGetError_t) (); typedef EGLDisplay (* eglGetDisplay_t) (EGLNativeDisplayType); typedef EGLBoolean (* eglInitialize_t) (EGLDisplay, EGLint*, EGLint*); typedef EGLBoolean (* eglTerminate_t) (EGLDisplay); typedef char* (* eglQueryString_t) (EGLDisplay, EGLint); typedef EGLBoolean (* eglGetConfigs_t) (EGLDisplay, EGLConfig*, EGLint, EGLint*); typedef EGLBoolean (* eglChooseConfig_t) (EGLDisplay, const EGLint*, EGLConfig*, EGLint, EGLint*); typedef EGLBoolean (* eglGetConfigAttrib_t) (EGLDisplay, EGLConfig, EGLint, EGLint*); typedef EGLSurface (* eglCreateWindowSurface_t) (EGLDisplay, EGLConfig, EGLNativeWindowType, const EGLint*); typedef EGLSurface (* eglCreatePbufferSurface_t) (EGLDisplay, EGLConfig, const EGLint*); typedef EGLSurface (* eglCreatePixmapSurface_t) (EGLDisplay, EGLConfig, EGLNativePixmapType, const EGLint*); typedef EGLBoolean (* eglDestroySurface_t) (EGLDisplay, EGLSurface); typedef EGLBoolean (* eglQuerySurface_t) (EGLDisplay, EGLSurface, EGLint, EGLint*); typedef EGLBoolean (* eglBindAPI_t) (EGLenum); typedef EGLenum (* eglQueryAPI_t) (); typedef EGLBoolean (* eglWaitClient_t) (); typedef EGLBoolean (* eglReleaseThread_t) (); typedef EGLSurface (* eglCreatePbufferFromClientBuffer_t) (EGLDisplay, EGLenum, EGLClientBuffer, EGLConfig, const EGLint*); typedef EGLBoolean (* eglSurfaceAttrib_t) (EGLDisplay, EGLSurface, EGLint, EGLint); typedef EGLBoolean (* eglBindTexImage_t) (EGLDisplay, EGLSurface, EGLint); typedef EGLBoolean (* eglReleaseTexImage_t) (EGLDisplay, EGLSurface, EGLint); typedef EGLBoolean (* eglSwapInterval_t) (EGLDisplay, EGLint); typedef EGLContext (* eglCreateContext_t) (EGLDisplay, EGLConfig, EGLContext, const EGLint*); typedef EGLBoolean (* eglDestroyContext_t) (EGLDisplay, EGLContext); typedef EGLBoolean (* eglMakeCurrent_t) (EGLDisplay, EGLSurface, EGLSurface, EGLContext); typedef EGLContext (* eglGetCurrentContext_t) (); typedef EGLSurface (* eglGetCurrentSurface_t) (EGLint); typedef EGLDisplay (* eglGetCurrentDisplay_t) (); typedef EGLBoolean (* eglQueryContext_t) (EGLDisplay, EGLContext, EGLint, EGLint*); typedef EGLBoolean (* eglWaitGL_t) (); typedef EGLBoolean (* eglWaitNative_t) (EGLint); typedef EGLBoolean (* eglSwapBuffers_t) (EGLDisplay, EGLSurface); typedef EGLBoolean (* eglCopyBuffers_t) (EGLDisplay, EGLSurface, EGLNativePixmapType); typedef __eglMustCastToProperFunctionPointerType (* eglGetProcAddress_t) (const char*); typedef EGLBoolean (* eglLockSurfaceKHR_t) (EGLDisplay, EGLSurface, const EGLint*); typedef EGLBoolean (* eglUnlockSurfaceKHR_t) (EGLDisplay, EGLSurface); typedef EGLImageKHR (* eglCreateImageKHR_t) (EGLDisplay, EGLContext, EGLenum, EGLClientBuffer, const EGLint*); typedef EGLBoolean (* eglDestroyImageKHR_t) (EGLDisplay, EGLImageKHR image); typedef EGLSyncKHR (* eglCreateSyncKHR_t) (EGLDisplay, EGLenum, const EGLint*); typedef EGLBoolean (* eglDestroySyncKHR_t) (EGLDisplay, EGLSyncKHR sync); typedef EGLint (* eglClientWaitSyncKHR_t) (EGLDisplay, EGLSyncKHR, EGLint, EGLTimeKHR timeout); typedef EGLBoolean (* eglSignalSyncKHR_t) (EGLDisplay, EGLSyncKHR, EGLenum); typedef EGLBoolean (* eglGetSyncAttribKHR_t) (EGLDisplay, EGLSyncKHR, EGLint, EGLint*); typedef EGLBoolean (* eglSetSwapRectangleANDROID_t) (EGLDisplay, EGLSurface, EGLint, EGLint, EGLint, EGLint); #endif // of _EGL_PROC_H anbox-0.0~git20191115/android/opengl/tests/gles_android_wrapper/gles.cpp000066400000000000000000001053311356361734700261260ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include "gles_dispatch.h" #include "gles_ftable.h" #include #include static struct gles_dispatch *s_dispatch = NULL; void init_gles(void *gles_android) { s_dispatch = create_gles_dispatch(gles_android); if (s_dispatch == NULL) { ALOGE("failed to create gles dispatch\n"); } } static struct gles_dispatch *getDispatch() { if (!s_dispatch) { fprintf(stderr,"FATAL ERROR: GLES has not been initialized\n"); exit(-1); } return s_dispatch; } __eglMustCastToProperFunctionPointerType gles_getProcAddress(const char *procname) { for (int i=0; iglAlphaFunc(func, ref); } void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { getDispatch()->glClearColor(red, green, blue, alpha); } void glClearDepthf(GLclampf depth) { getDispatch()->glClearDepthf(depth); } void glClipPlanef(GLenum plane, const GLfloat *equation) { getDispatch()->glClipPlanef(plane, equation); } void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { getDispatch()->glColor4f(red, green, blue, alpha); } void glDepthRangef(GLclampf zNear, GLclampf zFar) { getDispatch()->glDepthRangef(zNear, zFar); } void glFogf(GLenum pname, GLfloat param) { getDispatch()->glFogf(pname, param); } void glFogfv(GLenum pname, const GLfloat *params) { getDispatch()->glFogfv(pname, params); } void glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) { getDispatch()->glFrustumf(left, right, bottom, top, zNear, zFar); } void glGetClipPlanef(GLenum pname, GLfloat eqn[4]) { getDispatch()->glGetClipPlanef(pname, eqn); } void glGetFloatv(GLenum pname, GLfloat *params) { getDispatch()->glGetFloatv(pname, params); } void glGetLightfv(GLenum light, GLenum pname, GLfloat *params) { getDispatch()->glGetLightfv(light, pname, params); } void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params) { getDispatch()->glGetMaterialfv(face, pname, params); } void glGetTexEnvfv(GLenum env, GLenum pname, GLfloat *params) { getDispatch()->glGetTexEnvfv(env, pname, params); } void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) { getDispatch()->glGetTexParameterfv(target, pname, params); } void glLightModelf(GLenum pname, GLfloat param) { getDispatch()->glLightModelf(pname, param); } void glLightModelfv(GLenum pname, const GLfloat *params) { getDispatch()->glLightModelfv(pname, params); } void glLightf(GLenum light, GLenum pname, GLfloat param) { getDispatch()->glLightf(light, pname, param); } void glLightfv(GLenum light, GLenum pname, const GLfloat *params) { getDispatch()->glLightfv(light, pname, params); } void glLineWidth(GLfloat width) { getDispatch()->glLineWidth(width); } void glLoadMatrixf(const GLfloat *m) { getDispatch()->glLoadMatrixf(m); } void glMaterialf(GLenum face, GLenum pname, GLfloat param) { getDispatch()->glMaterialf(face, pname, param); } void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) { getDispatch()->glMaterialfv(face, pname, params); } void glMultMatrixf(const GLfloat *m) { getDispatch()->glMultMatrixf(m); } void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) { getDispatch()->glMultiTexCoord4f(target, s, t, r, q); } void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) { getDispatch()->glNormal3f(nx, ny, nz); } void glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) { getDispatch()->glOrthof(left, right, bottom, top, zNear, zFar); } void glPointParameterf(GLenum pname, GLfloat param) { getDispatch()->glPointParameterf(pname, param); } void glPointParameterfv(GLenum pname, const GLfloat *params) { getDispatch()->glPointParameterfv(pname, params); } void glPointSize(GLfloat size) { getDispatch()->glPointSize(size); } void glPolygonOffset(GLfloat factor, GLfloat units) { getDispatch()->glPolygonOffset(factor, units); } void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) { getDispatch()->glRotatef(angle, x, y, z); } void glScalef(GLfloat x, GLfloat y, GLfloat z) { getDispatch()->glScalef(x, y, z); } void glTexEnvf(GLenum target, GLenum pname, GLfloat param) { getDispatch()->glTexEnvf(target, pname, param); } void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params) { getDispatch()->glTexEnvfv(target, pname, params); } void glTexParameterf(GLenum target, GLenum pname, GLfloat param) { getDispatch()->glTexParameterf(target, pname, param); } void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) { getDispatch()->glTexParameterfv(target, pname, params); } void glTranslatef(GLfloat x, GLfloat y, GLfloat z) { getDispatch()->glTranslatef(x, y, z); } void glActiveTexture(GLenum texture) { getDispatch()->glActiveTexture(texture); } void glAlphaFuncx(GLenum func, GLclampx ref) { getDispatch()->glAlphaFuncx(func, ref); } void glBindBuffer(GLenum target, GLuint buffer) { getDispatch()->glBindBuffer(target, buffer); } void glBindTexture(GLenum target, GLuint texture) { getDispatch()->glBindTexture(target, texture); } void glBlendFunc(GLenum sfactor, GLenum dfactor) { getDispatch()->glBlendFunc(sfactor, dfactor); } void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage) { getDispatch()->glBufferData(target, size, data, usage); } void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data) { getDispatch()->glBufferSubData(target, offset, size, data); } void glClear(GLbitfield mask) { getDispatch()->glClear(mask); } void glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) { getDispatch()->glClearColorx(red, green, blue, alpha); } void glClearDepthx(GLclampx depth) { getDispatch()->glClearDepthx(depth); } void glClearStencil(GLint s) { getDispatch()->glClearStencil(s); } void glClientActiveTexture(GLenum texture) { getDispatch()->glClientActiveTexture(texture); } void glClipPlanex(GLenum plane, const GLfixed *equation) { getDispatch()->glClipPlanex(plane, equation); } void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) { getDispatch()->glColor4ub(red, green, blue, alpha); } void glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) { getDispatch()->glColor4x(red, green, blue, alpha); } void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) { getDispatch()->glColorMask(red, green, blue, alpha); } void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) { getDispatch()->glColorPointer(size, type, stride, pointer); } void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) { getDispatch()->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data); } void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) { getDispatch()->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); } void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { getDispatch()->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border); } void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { getDispatch()->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); } void glCullFace(GLenum mode) { getDispatch()->glCullFace(mode); } void glDeleteBuffers(GLsizei n, const GLuint *buffers) { getDispatch()->glDeleteBuffers(n, buffers); } void glDeleteTextures(GLsizei n, const GLuint *textures) { getDispatch()->glDeleteTextures(n, textures); } void glDepthFunc(GLenum func) { getDispatch()->glDepthFunc(func); } void glDepthMask(GLboolean flag) { getDispatch()->glDepthMask(flag); } void glDepthRangex(GLclampx zNear, GLclampx zFar) { getDispatch()->glDepthRangex(zNear, zFar); } void glDisable(GLenum cap) { getDispatch()->glDisable(cap); } void glDisableClientState(GLenum array) { getDispatch()->glDisableClientState(array); } void glDrawArrays(GLenum mode, GLint first, GLsizei count) { getDispatch()->glDrawArrays(mode, first, count); } void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) { getDispatch()->glDrawElements(mode, count, type, indices); } void glEnable(GLenum cap) { getDispatch()->glEnable(cap); } void glEnableClientState(GLenum array) { getDispatch()->glEnableClientState(array); } void glFinish() { getDispatch()->glFinish(); } void glFlush() { getDispatch()->glFlush(); } void glFogx(GLenum pname, GLfixed param) { getDispatch()->glFogx(pname, param); } void glFogxv(GLenum pname, const GLfixed *params) { getDispatch()->glFogxv(pname, params); } void glFrontFace(GLenum mode) { getDispatch()->glFrontFace(mode); } void glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) { getDispatch()->glFrustumx(left, right, bottom, top, zNear, zFar); } void glGetBooleanv(GLenum pname, GLboolean *params) { getDispatch()->glGetBooleanv(pname, params); } void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params) { getDispatch()->glGetBufferParameteriv(target, pname, params); } void glGetClipPlanex(GLenum pname, GLfixed eqn[4]) { getDispatch()->glGetClipPlanex(pname, eqn); } void glGenBuffers(GLsizei n, GLuint *buffers) { getDispatch()->glGenBuffers(n, buffers); } void glGenTextures(GLsizei n, GLuint *textures) { getDispatch()->glGenTextures(n, textures); } GLenum glGetError() { return getDispatch()->glGetError(); } void glGetFixedv(GLenum pname, GLfixed *params) { getDispatch()->glGetFixedv(pname, params); } void glGetIntegerv(GLenum pname, GLint *params) { getDispatch()->glGetIntegerv(pname, params); } void glGetLightxv(GLenum light, GLenum pname, GLfixed *params) { getDispatch()->glGetLightxv(light, pname, params); } void glGetMaterialxv(GLenum face, GLenum pname, GLfixed *params) { getDispatch()->glGetMaterialxv(face, pname, params); } void glGetPointerv(GLenum pname, GLvoid **params) { getDispatch()->glGetPointerv(pname, params); } const GLubyte* glGetString(GLenum name) { return getDispatch()->glGetString(name); } void glGetTexEnviv(GLenum env, GLenum pname, GLint *params) { getDispatch()->glGetTexEnviv(env, pname, params); } void glGetTexEnvxv(GLenum env, GLenum pname, GLfixed *params) { getDispatch()->glGetTexEnvxv(env, pname, params); } void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params) { getDispatch()->glGetTexParameteriv(target, pname, params); } void glGetTexParameterxv(GLenum target, GLenum pname, GLfixed *params) { getDispatch()->glGetTexParameterxv(target, pname, params); } void glHint(GLenum target, GLenum mode) { getDispatch()->glHint(target, mode); } GLboolean glIsBuffer(GLuint buffer) { return getDispatch()->glIsBuffer(buffer); } GLboolean glIsEnabled(GLenum cap) { return getDispatch()->glIsEnabled(cap); } GLboolean glIsTexture(GLuint texture) { return getDispatch()->glIsTexture(texture); } void glLightModelx(GLenum pname, GLfixed param) { getDispatch()->glLightModelx(pname, param); } void glLightModelxv(GLenum pname, const GLfixed *params) { getDispatch()->glLightModelxv(pname, params); } void glLightx(GLenum light, GLenum pname, GLfixed param) { getDispatch()->glLightx(light, pname, param); } void glLightxv(GLenum light, GLenum pname, const GLfixed *params) { getDispatch()->glLightxv(light, pname, params); } void glLineWidthx(GLfixed width) { getDispatch()->glLineWidthx(width); } void glLoadIdentity() { getDispatch()->glLoadIdentity(); } void glLoadMatrixx(const GLfixed *m) { getDispatch()->glLoadMatrixx(m); } void glLogicOp(GLenum opcode) { getDispatch()->glLogicOp(opcode); } void glMaterialx(GLenum face, GLenum pname, GLfixed param) { getDispatch()->glMaterialx(face, pname, param); } void glMaterialxv(GLenum face, GLenum pname, const GLfixed *params) { getDispatch()->glMaterialxv(face, pname, params); } void glMatrixMode(GLenum mode) { getDispatch()->glMatrixMode(mode); } void glMultMatrixx(const GLfixed *m) { getDispatch()->glMultMatrixx(m); } void glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q) { getDispatch()->glMultiTexCoord4x(target, s, t, r, q); } void glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz) { getDispatch()->glNormal3x(nx, ny, nz); } void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer) { getDispatch()->glNormalPointer(type, stride, pointer); } void glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) { getDispatch()->glOrthox(left, right, bottom, top, zNear, zFar); } void glPixelStorei(GLenum pname, GLint param) { getDispatch()->glPixelStorei(pname, param); } void glPointParameterx(GLenum pname, GLfixed param) { getDispatch()->glPointParameterx(pname, param); } void glPointParameterxv(GLenum pname, const GLfixed *params) { getDispatch()->glPointParameterxv(pname, params); } void glPointSizex(GLfixed size) { getDispatch()->glPointSizex(size); } void glPolygonOffsetx(GLfixed factor, GLfixed units) { getDispatch()->glPolygonOffsetx(factor, units); } void glPopMatrix() { getDispatch()->glPopMatrix(); } void glPushMatrix() { getDispatch()->glPushMatrix(); } void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) { getDispatch()->glReadPixels(x, y, width, height, format, type, pixels); } void glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z) { getDispatch()->glRotatex(angle, x, y, z); } void glSampleCoverage(GLclampf value, GLboolean invert) { getDispatch()->glSampleCoverage(value, invert); } void glSampleCoveragex(GLclampx value, GLboolean invert) { getDispatch()->glSampleCoveragex(value, invert); } void glScalex(GLfixed x, GLfixed y, GLfixed z) { getDispatch()->glScalex(x, y, z); } void glScissor(GLint x, GLint y, GLsizei width, GLsizei height) { getDispatch()->glScissor(x, y, width, height); } void glShadeModel(GLenum mode) { getDispatch()->glShadeModel(mode); } void glStencilFunc(GLenum func, GLint ref, GLuint mask) { getDispatch()->glStencilFunc(func, ref, mask); } void glStencilMask(GLuint mask) { getDispatch()->glStencilMask(mask); } void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) { getDispatch()->glStencilOp(fail, zfail, zpass); } void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) { getDispatch()->glTexCoordPointer(size, type, stride, pointer); } void glTexEnvi(GLenum target, GLenum pname, GLint param) { getDispatch()->glTexEnvi(target, pname, param); } void glTexEnvx(GLenum target, GLenum pname, GLfixed param) { getDispatch()->glTexEnvx(target, pname, param); } void glTexEnviv(GLenum target, GLenum pname, const GLint *params) { getDispatch()->glTexEnviv(target, pname, params); } void glTexEnvxv(GLenum target, GLenum pname, const GLfixed *params) { getDispatch()->glTexEnvxv(target, pname, params); } void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) { getDispatch()->glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels); } void glTexParameteri(GLenum target, GLenum pname, GLint param) { getDispatch()->glTexParameteri(target, pname, param); } void glTexParameterx(GLenum target, GLenum pname, GLfixed param) { getDispatch()->glTexParameterx(target, pname, param); } void glTexParameteriv(GLenum target, GLenum pname, const GLint *params) { getDispatch()->glTexParameteriv(target, pname, params); } void glTexParameterxv(GLenum target, GLenum pname, const GLfixed *params) { getDispatch()->glTexParameterxv(target, pname, params); } void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) { getDispatch()->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); } void glTranslatex(GLfixed x, GLfixed y, GLfixed z) { getDispatch()->glTranslatex(x, y, z); } void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) { getDispatch()->glVertexPointer(size, type, stride, pointer); } void glViewport(GLint x, GLint y, GLsizei width, GLsizei height) { getDispatch()->glViewport(x, y, width, height); } void glPointSizePointerOES(GLenum type, GLsizei stride, const GLvoid *pointer) { getDispatch()->glPointSizePointerOES(type, stride, pointer); } void glBlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha) { getDispatch()->glBlendEquationSeparateOES(modeRGB, modeAlpha); } void glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) { getDispatch()->glBlendFuncSeparateOES(srcRGB, dstRGB, srcAlpha, dstAlpha); } void glBlendEquationOES(GLenum mode) { getDispatch()->glBlendEquationOES(mode); } void glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height) { getDispatch()->glDrawTexsOES(x, y, z, width, height); } void glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height) { getDispatch()->glDrawTexiOES(x, y, z, width, height); } void glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height) { getDispatch()->glDrawTexxOES(x, y, z, width, height); } void glDrawTexsvOES(const GLshort *coords) { getDispatch()->glDrawTexsvOES(coords); } void glDrawTexivOES(const GLint *coords) { getDispatch()->glDrawTexivOES(coords); } void glDrawTexxvOES(const GLfixed *coords) { getDispatch()->glDrawTexxvOES(coords); } void glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height) { getDispatch()->glDrawTexfOES(x, y, z, width, height); } void glDrawTexfvOES(const GLfloat *coords) { getDispatch()->glDrawTexfvOES(coords); } void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image) { getDispatch()->glEGLImageTargetTexture2DOES(target, image); } void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image) { getDispatch()->glEGLImageTargetRenderbufferStorageOES(target, image); } void glAlphaFuncxOES(GLenum func, GLclampx ref) { getDispatch()->glAlphaFuncxOES(func, ref); } void glClearColorxOES(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) { getDispatch()->glClearColorxOES(red, green, blue, alpha); } void glClearDepthxOES(GLclampx depth) { getDispatch()->glClearDepthxOES(depth); } void glClipPlanexOES(GLenum plane, const GLfixed *equation) { getDispatch()->glClipPlanexOES(plane, equation); } void glColor4xOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) { getDispatch()->glColor4xOES(red, green, blue, alpha); } void glDepthRangexOES(GLclampx zNear, GLclampx zFar) { getDispatch()->glDepthRangexOES(zNear, zFar); } void glFogxOES(GLenum pname, GLfixed param) { getDispatch()->glFogxOES(pname, param); } void glFogxvOES(GLenum pname, const GLfixed *params) { getDispatch()->glFogxvOES(pname, params); } void glFrustumxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) { getDispatch()->glFrustumxOES(left, right, bottom, top, zNear, zFar); } void glGetClipPlanexOES(GLenum pname, GLfixed eqn[4]) { getDispatch()->glGetClipPlanexOES(pname, eqn); } void glGetFixedvOES(GLenum pname, GLfixed *params) { getDispatch()->glGetFixedvOES(pname, params); } void glGetLightxvOES(GLenum light, GLenum pname, GLfixed *params) { getDispatch()->glGetLightxvOES(light, pname, params); } void glGetMaterialxvOES(GLenum face, GLenum pname, GLfixed *params) { getDispatch()->glGetMaterialxvOES(face, pname, params); } void glGetTexEnvxvOES(GLenum env, GLenum pname, GLfixed *params) { getDispatch()->glGetTexEnvxvOES(env, pname, params); } void glGetTexParameterxvOES(GLenum target, GLenum pname, GLfixed *params) { getDispatch()->glGetTexParameterxvOES(target, pname, params); } void glLightModelxOES(GLenum pname, GLfixed param) { getDispatch()->glLightModelxOES(pname, param); } void glLightModelxvOES(GLenum pname, const GLfixed *params) { getDispatch()->glLightModelxvOES(pname, params); } void glLightxOES(GLenum light, GLenum pname, GLfixed param) { getDispatch()->glLightxOES(light, pname, param); } void glLightxvOES(GLenum light, GLenum pname, const GLfixed *params) { getDispatch()->glLightxvOES(light, pname, params); } void glLineWidthxOES(GLfixed width) { getDispatch()->glLineWidthxOES(width); } void glLoadMatrixxOES(const GLfixed *m) { getDispatch()->glLoadMatrixxOES(m); } void glMaterialxOES(GLenum face, GLenum pname, GLfixed param) { getDispatch()->glMaterialxOES(face, pname, param); } void glMaterialxvOES(GLenum face, GLenum pname, const GLfixed *params) { getDispatch()->glMaterialxvOES(face, pname, params); } void glMultMatrixxOES(const GLfixed *m) { getDispatch()->glMultMatrixxOES(m); } void glMultiTexCoord4xOES(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q) { getDispatch()->glMultiTexCoord4xOES(target, s, t, r, q); } void glNormal3xOES(GLfixed nx, GLfixed ny, GLfixed nz) { getDispatch()->glNormal3xOES(nx, ny, nz); } void glOrthoxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) { getDispatch()->glOrthoxOES(left, right, bottom, top, zNear, zFar); } void glPointParameterxOES(GLenum pname, GLfixed param) { getDispatch()->glPointParameterxOES(pname, param); } void glPointParameterxvOES(GLenum pname, const GLfixed *params) { getDispatch()->glPointParameterxvOES(pname, params); } void glPointSizexOES(GLfixed size) { getDispatch()->glPointSizexOES(size); } void glPolygonOffsetxOES(GLfixed factor, GLfixed units) { getDispatch()->glPolygonOffsetxOES(factor, units); } void glRotatexOES(GLfixed angle, GLfixed x, GLfixed y, GLfixed z) { getDispatch()->glRotatexOES(angle, x, y, z); } void glSampleCoveragexOES(GLclampx value, GLboolean invert) { getDispatch()->glSampleCoveragexOES(value, invert); } void glScalexOES(GLfixed x, GLfixed y, GLfixed z) { getDispatch()->glScalexOES(x, y, z); } void glTexEnvxOES(GLenum target, GLenum pname, GLfixed param) { getDispatch()->glTexEnvxOES(target, pname, param); } void glTexEnvxvOES(GLenum target, GLenum pname, const GLfixed *params) { getDispatch()->glTexEnvxvOES(target, pname, params); } void glTexParameterxOES(GLenum target, GLenum pname, GLfixed param) { getDispatch()->glTexParameterxOES(target, pname, param); } void glTexParameterxvOES(GLenum target, GLenum pname, const GLfixed *params) { getDispatch()->glTexParameterxvOES(target, pname, params); } void glTranslatexOES(GLfixed x, GLfixed y, GLfixed z) { getDispatch()->glTranslatexOES(x, y, z); } GLboolean glIsRenderbufferOES(GLuint renderbuffer) { return getDispatch()->glIsRenderbufferOES(renderbuffer); } void glBindRenderbufferOES(GLenum target, GLuint renderbuffer) { getDispatch()->glBindRenderbufferOES(target, renderbuffer); } void glDeleteRenderbuffersOES(GLsizei n, const GLuint *renderbuffers) { getDispatch()->glDeleteRenderbuffersOES(n, renderbuffers); } void glGenRenderbuffersOES(GLsizei n, GLuint *renderbuffers) { getDispatch()->glGenRenderbuffersOES(n, renderbuffers); } void glRenderbufferStorageOES(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) { getDispatch()->glRenderbufferStorageOES(target, internalformat, width, height); } void glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint *params) { getDispatch()->glGetRenderbufferParameterivOES(target, pname, params); } GLboolean glIsFramebufferOES(GLuint framebuffer) { return getDispatch()->glIsFramebufferOES(framebuffer); } void glBindFramebufferOES(GLenum target, GLuint framebuffer) { getDispatch()->glBindFramebufferOES(target, framebuffer); } void glDeleteFramebuffersOES(GLsizei n, const GLuint *framebuffers) { getDispatch()->glDeleteFramebuffersOES(n, framebuffers); } void glGenFramebuffersOES(GLsizei n, GLuint *framebuffers) { getDispatch()->glGenFramebuffersOES(n, framebuffers); } GLenum glCheckFramebufferStatusOES(GLenum target) { return getDispatch()->glCheckFramebufferStatusOES(target); } void glFramebufferRenderbufferOES(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) { getDispatch()->glFramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer); } void glFramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { getDispatch()->glFramebufferTexture2DOES(target, attachment, textarget, texture, level); } void glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint *params) { getDispatch()->glGetFramebufferAttachmentParameterivOES(target, attachment, pname, params); } void glGenerateMipmapOES(GLenum target) { getDispatch()->glGenerateMipmapOES(target); } void* glMapBufferOES(GLenum target, GLenum access) { return getDispatch()->glMapBufferOES(target, access); } GLboolean glUnmapBufferOES(GLenum target) { return getDispatch()->glUnmapBufferOES(target); } void glGetBufferPointervOES(GLenum target, GLenum pname, GLvoid **ptr) { getDispatch()->glGetBufferPointervOES(target, pname, ptr); } void glCurrentPaletteMatrixOES(GLuint matrixpaletteindex) { getDispatch()->glCurrentPaletteMatrixOES(matrixpaletteindex); } void glLoadPaletteFromModelViewMatrixOES() { getDispatch()->glLoadPaletteFromModelViewMatrixOES(); } void glMatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) { getDispatch()->glMatrixIndexPointerOES(size, type, stride, pointer); } void glWeightPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) { getDispatch()->glWeightPointerOES(size, type, stride, pointer); } GLbitfield glQueryMatrixxOES(GLfixed mantissa[16], GLint exponent[16]) { return getDispatch()->glQueryMatrixxOES(mantissa, exponent); } void glDepthRangefOES(GLclampf zNear, GLclampf zFar) { getDispatch()->glDepthRangefOES(zNear, zFar); } void glFrustumfOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) { getDispatch()->glFrustumfOES(left, right, bottom, top, zNear, zFar); } void glOrthofOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) { getDispatch()->glOrthofOES(left, right, bottom, top, zNear, zFar); } void glClipPlanefOES(GLenum plane, const GLfloat *equation) { getDispatch()->glClipPlanefOES(plane, equation); } void glGetClipPlanefOES(GLenum pname, GLfloat eqn[4]) { getDispatch()->glGetClipPlanefOES(pname, eqn); } void glClearDepthfOES(GLclampf depth) { getDispatch()->glClearDepthfOES(depth); } void glTexGenfOES(GLenum coord, GLenum pname, GLfloat param) { getDispatch()->glTexGenfOES(coord, pname, param); } void glTexGenfvOES(GLenum coord, GLenum pname, const GLfloat *params) { getDispatch()->glTexGenfvOES(coord, pname, params); } void glTexGeniOES(GLenum coord, GLenum pname, GLint param) { getDispatch()->glTexGeniOES(coord, pname, param); } void glTexGenivOES(GLenum coord, GLenum pname, const GLint *params) { getDispatch()->glTexGenivOES(coord, pname, params); } void glTexGenxOES(GLenum coord, GLenum pname, GLfixed param) { getDispatch()->glTexGenxOES(coord, pname, param); } void glTexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params) { getDispatch()->glTexGenxvOES(coord, pname, params); } void glGetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params) { getDispatch()->glGetTexGenfvOES(coord, pname, params); } void glGetTexGenivOES(GLenum coord, GLenum pname, GLint *params) { getDispatch()->glGetTexGenivOES(coord, pname, params); } void glGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params) { getDispatch()->glGetTexGenxvOES(coord, pname, params); } void glBindVertexArrayOES(GLuint array) { getDispatch()->glBindVertexArrayOES(array); } void glDeleteVertexArraysOES(GLsizei n, const GLuint *arrays) { getDispatch()->glDeleteVertexArraysOES(n, arrays); } void glGenVertexArraysOES(GLsizei n, GLuint *arrays) { getDispatch()->glGenVertexArraysOES(n, arrays); } GLboolean glIsVertexArrayOES(GLuint array) { return getDispatch()->glIsVertexArrayOES(array); } void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum *attachments) { getDispatch()->glDiscardFramebufferEXT(target, numAttachments, attachments); } void glMultiDrawArraysEXT(GLenum mode, GLint *first, GLsizei *count, GLsizei primcount) { getDispatch()->glMultiDrawArraysEXT(mode, first, count, primcount); } void glMultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount) { getDispatch()->glMultiDrawElementsEXT(mode, count, type, indices, primcount); } void glClipPlanefIMG(GLenum p, const GLfloat *eqn) { getDispatch()->glClipPlanefIMG(p, eqn); } void glClipPlanexIMG(GLenum p, const GLfixed *eqn) { getDispatch()->glClipPlanexIMG(p, eqn); } void glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) { getDispatch()->glRenderbufferStorageMultisampleIMG(target, samples, internalformat, width, height); } void glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples) { getDispatch()->glFramebufferTexture2DMultisampleIMG(target, attachment, textarget, texture, level, samples); } void glDeleteFencesNV(GLsizei n, const GLuint *fences) { getDispatch()->glDeleteFencesNV(n, fences); } void glGenFencesNV(GLsizei n, GLuint *fences) { getDispatch()->glGenFencesNV(n, fences); } GLboolean glIsFenceNV(GLuint fence) { return getDispatch()->glIsFenceNV(fence); } GLboolean glTestFenceNV(GLuint fence) { return getDispatch()->glTestFenceNV(fence); } void glGetFenceivNV(GLuint fence, GLenum pname, GLint *params) { getDispatch()->glGetFenceivNV(fence, pname, params); } void glFinishFenceNV(GLuint fence) { getDispatch()->glFinishFenceNV(fence); } void glSetFenceNV(GLuint fence, GLenum condition) { getDispatch()->glSetFenceNV(fence, condition); } void glGetDriverControlsQCOM(GLint *num, GLsizei size, GLuint *driverControls) { getDispatch()->glGetDriverControlsQCOM(num, size, driverControls); } void glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei *length, GLchar *driverControlString) { getDispatch()->glGetDriverControlStringQCOM(driverControl, bufSize, length, driverControlString); } void glEnableDriverControlQCOM(GLuint driverControl) { getDispatch()->glEnableDriverControlQCOM(driverControl); } void glDisableDriverControlQCOM(GLuint driverControl) { getDispatch()->glDisableDriverControlQCOM(driverControl); } void glExtGetTexturesQCOM(GLuint *textures, GLint maxTextures, GLint *numTextures) { getDispatch()->glExtGetTexturesQCOM(textures, maxTextures, numTextures); } void glExtGetBuffersQCOM(GLuint *buffers, GLint maxBuffers, GLint *numBuffers) { getDispatch()->glExtGetBuffersQCOM(buffers, maxBuffers, numBuffers); } void glExtGetRenderbuffersQCOM(GLuint *renderbuffers, GLint maxRenderbuffers, GLint *numRenderbuffers) { getDispatch()->glExtGetRenderbuffersQCOM(renderbuffers, maxRenderbuffers, numRenderbuffers); } void glExtGetFramebuffersQCOM(GLuint *framebuffers, GLint maxFramebuffers, GLint *numFramebuffers) { getDispatch()->glExtGetFramebuffersQCOM(framebuffers, maxFramebuffers, numFramebuffers); } void glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint *params) { getDispatch()->glExtGetTexLevelParameterivQCOM(texture, face, level, pname, params); } void glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param) { getDispatch()->glExtTexObjectStateOverrideiQCOM(target, pname, param); } void glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid *texels) { getDispatch()->glExtGetTexSubImageQCOM(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels); } void glExtGetBufferPointervQCOM(GLenum target, GLvoid **params) { getDispatch()->glExtGetBufferPointervQCOM(target, params); } void glExtGetShadersQCOM(GLuint *shaders, GLint maxShaders, GLint *numShaders) { getDispatch()->glExtGetShadersQCOM(shaders, maxShaders, numShaders); } void glExtGetProgramsQCOM(GLuint *programs, GLint maxPrograms, GLint *numPrograms) { getDispatch()->glExtGetProgramsQCOM(programs, maxPrograms, numPrograms); } GLboolean glExtIsProgramBinaryQCOM(GLuint program) { return getDispatch()->glExtIsProgramBinaryQCOM(program); } void glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar *source, GLint *length) { getDispatch()->glExtGetProgramBinarySourceQCOM(program, shadertype, source, length); } void glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask) { getDispatch()->glStartTilingQCOM(x, y, width, height, preserveMask); } void glEndTilingQCOM(GLbitfield preserveMask) { getDispatch()->glEndTilingQCOM(preserveMask); } anbox-0.0~git20191115/android/opengl/tests/gles_android_wrapper/gles_dispatch.cpp000066400000000000000000000671431356361734700300150ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "gles_dispatch.h" #include #include gles_dispatch *create_gles_dispatch(void *gles_android) { gles_dispatch *disp = new gles_dispatch; void *ptr; ptr = dlsym(gles_android,"glAlphaFunc"); disp->set_glAlphaFunc((glAlphaFunc_t)ptr); ptr = dlsym(gles_android,"glClearColor"); disp->set_glClearColor((glClearColor_t)ptr); ptr = dlsym(gles_android,"glClearDepthf"); disp->set_glClearDepthf((glClearDepthf_t)ptr); ptr = dlsym(gles_android,"glClipPlanef"); disp->set_glClipPlanef((glClipPlanef_t)ptr); ptr = dlsym(gles_android,"glColor4f"); disp->set_glColor4f((glColor4f_t)ptr); ptr = dlsym(gles_android,"glDepthRangef"); disp->set_glDepthRangef((glDepthRangef_t)ptr); ptr = dlsym(gles_android,"glFogf"); disp->set_glFogf((glFogf_t)ptr); ptr = dlsym(gles_android,"glFogfv"); disp->set_glFogfv((glFogfv_t)ptr); ptr = dlsym(gles_android,"glFrustumf"); disp->set_glFrustumf((glFrustumf_t)ptr); ptr = dlsym(gles_android,"glGetClipPlanef"); disp->set_glGetClipPlanef((glGetClipPlanef_t)ptr); ptr = dlsym(gles_android,"glGetFloatv"); disp->set_glGetFloatv((glGetFloatv_t)ptr); ptr = dlsym(gles_android,"glGetLightfv"); disp->set_glGetLightfv((glGetLightfv_t)ptr); ptr = dlsym(gles_android,"glGetMaterialfv"); disp->set_glGetMaterialfv((glGetMaterialfv_t)ptr); ptr = dlsym(gles_android,"glGetTexEnvfv"); disp->set_glGetTexEnvfv((glGetTexEnvfv_t)ptr); ptr = dlsym(gles_android,"glGetTexParameterfv"); disp->set_glGetTexParameterfv((glGetTexParameterfv_t)ptr); ptr = dlsym(gles_android,"glLightModelf"); disp->set_glLightModelf((glLightModelf_t)ptr); ptr = dlsym(gles_android,"glLightModelfv"); disp->set_glLightModelfv((glLightModelfv_t)ptr); ptr = dlsym(gles_android,"glLightf"); disp->set_glLightf((glLightf_t)ptr); ptr = dlsym(gles_android,"glLightfv"); disp->set_glLightfv((glLightfv_t)ptr); ptr = dlsym(gles_android,"glLineWidth"); disp->set_glLineWidth((glLineWidth_t)ptr); ptr = dlsym(gles_android,"glLoadMatrixf"); disp->set_glLoadMatrixf((glLoadMatrixf_t)ptr); ptr = dlsym(gles_android,"glMaterialf"); disp->set_glMaterialf((glMaterialf_t)ptr); ptr = dlsym(gles_android,"glMaterialfv"); disp->set_glMaterialfv((glMaterialfv_t)ptr); ptr = dlsym(gles_android,"glMultMatrixf"); disp->set_glMultMatrixf((glMultMatrixf_t)ptr); ptr = dlsym(gles_android,"glMultiTexCoord4f"); disp->set_glMultiTexCoord4f((glMultiTexCoord4f_t)ptr); ptr = dlsym(gles_android,"glNormal3f"); disp->set_glNormal3f((glNormal3f_t)ptr); ptr = dlsym(gles_android,"glOrthof"); disp->set_glOrthof((glOrthof_t)ptr); ptr = dlsym(gles_android,"glPointParameterf"); disp->set_glPointParameterf((glPointParameterf_t)ptr); ptr = dlsym(gles_android,"glPointParameterfv"); disp->set_glPointParameterfv((glPointParameterfv_t)ptr); ptr = dlsym(gles_android,"glPointSize"); disp->set_glPointSize((glPointSize_t)ptr); ptr = dlsym(gles_android,"glPolygonOffset"); disp->set_glPolygonOffset((glPolygonOffset_t)ptr); ptr = dlsym(gles_android,"glRotatef"); disp->set_glRotatef((glRotatef_t)ptr); ptr = dlsym(gles_android,"glScalef"); disp->set_glScalef((glScalef_t)ptr); ptr = dlsym(gles_android,"glTexEnvf"); disp->set_glTexEnvf((glTexEnvf_t)ptr); ptr = dlsym(gles_android,"glTexEnvfv"); disp->set_glTexEnvfv((glTexEnvfv_t)ptr); ptr = dlsym(gles_android,"glTexParameterf"); disp->set_glTexParameterf((glTexParameterf_t)ptr); ptr = dlsym(gles_android,"glTexParameterfv"); disp->set_glTexParameterfv((glTexParameterfv_t)ptr); ptr = dlsym(gles_android,"glTranslatef"); disp->set_glTranslatef((glTranslatef_t)ptr); ptr = dlsym(gles_android,"glActiveTexture"); disp->set_glActiveTexture((glActiveTexture_t)ptr); ptr = dlsym(gles_android,"glAlphaFuncx"); disp->set_glAlphaFuncx((glAlphaFuncx_t)ptr); ptr = dlsym(gles_android,"glBindBuffer"); disp->set_glBindBuffer((glBindBuffer_t)ptr); ptr = dlsym(gles_android,"glBindTexture"); disp->set_glBindTexture((glBindTexture_t)ptr); ptr = dlsym(gles_android,"glBlendFunc"); disp->set_glBlendFunc((glBlendFunc_t)ptr); ptr = dlsym(gles_android,"glBufferData"); disp->set_glBufferData((glBufferData_t)ptr); ptr = dlsym(gles_android,"glBufferSubData"); disp->set_glBufferSubData((glBufferSubData_t)ptr); ptr = dlsym(gles_android,"glClear"); disp->set_glClear((glClear_t)ptr); ptr = dlsym(gles_android,"glClearColorx"); disp->set_glClearColorx((glClearColorx_t)ptr); ptr = dlsym(gles_android,"glClearDepthx"); disp->set_glClearDepthx((glClearDepthx_t)ptr); ptr = dlsym(gles_android,"glClearStencil"); disp->set_glClearStencil((glClearStencil_t)ptr); ptr = dlsym(gles_android,"glClientActiveTexture"); disp->set_glClientActiveTexture((glClientActiveTexture_t)ptr); ptr = dlsym(gles_android,"glClipPlanex"); disp->set_glClipPlanex((glClipPlanex_t)ptr); ptr = dlsym(gles_android,"glColor4ub"); disp->set_glColor4ub((glColor4ub_t)ptr); ptr = dlsym(gles_android,"glColor4x"); disp->set_glColor4x((glColor4x_t)ptr); ptr = dlsym(gles_android,"glColorMask"); disp->set_glColorMask((glColorMask_t)ptr); ptr = dlsym(gles_android,"glColorPointer"); disp->set_glColorPointer((glColorPointer_t)ptr); ptr = dlsym(gles_android,"glCompressedTexImage2D"); disp->set_glCompressedTexImage2D((glCompressedTexImage2D_t)ptr); ptr = dlsym(gles_android,"glCompressedTexSubImage2D"); disp->set_glCompressedTexSubImage2D((glCompressedTexSubImage2D_t)ptr); ptr = dlsym(gles_android,"glCopyTexImage2D"); disp->set_glCopyTexImage2D((glCopyTexImage2D_t)ptr); ptr = dlsym(gles_android,"glCopyTexSubImage2D"); disp->set_glCopyTexSubImage2D((glCopyTexSubImage2D_t)ptr); ptr = dlsym(gles_android,"glCullFace"); disp->set_glCullFace((glCullFace_t)ptr); ptr = dlsym(gles_android,"glDeleteBuffers"); disp->set_glDeleteBuffers((glDeleteBuffers_t)ptr); ptr = dlsym(gles_android,"glDeleteTextures"); disp->set_glDeleteTextures((glDeleteTextures_t)ptr); ptr = dlsym(gles_android,"glDepthFunc"); disp->set_glDepthFunc((glDepthFunc_t)ptr); ptr = dlsym(gles_android,"glDepthMask"); disp->set_glDepthMask((glDepthMask_t)ptr); ptr = dlsym(gles_android,"glDepthRangex"); disp->set_glDepthRangex((glDepthRangex_t)ptr); ptr = dlsym(gles_android,"glDisable"); disp->set_glDisable((glDisable_t)ptr); ptr = dlsym(gles_android,"glDisableClientState"); disp->set_glDisableClientState((glDisableClientState_t)ptr); ptr = dlsym(gles_android,"glDrawArrays"); disp->set_glDrawArrays((glDrawArrays_t)ptr); ptr = dlsym(gles_android,"glDrawElements"); disp->set_glDrawElements((glDrawElements_t)ptr); ptr = dlsym(gles_android,"glEnable"); disp->set_glEnable((glEnable_t)ptr); ptr = dlsym(gles_android,"glEnableClientState"); disp->set_glEnableClientState((glEnableClientState_t)ptr); ptr = dlsym(gles_android,"glFinish"); disp->set_glFinish((glFinish_t)ptr); ptr = dlsym(gles_android,"glFlush"); disp->set_glFlush((glFlush_t)ptr); ptr = dlsym(gles_android,"glFogx"); disp->set_glFogx((glFogx_t)ptr); ptr = dlsym(gles_android,"glFogxv"); disp->set_glFogxv((glFogxv_t)ptr); ptr = dlsym(gles_android,"glFrontFace"); disp->set_glFrontFace((glFrontFace_t)ptr); ptr = dlsym(gles_android,"glFrustumx"); disp->set_glFrustumx((glFrustumx_t)ptr); ptr = dlsym(gles_android,"glGetBooleanv"); disp->set_glGetBooleanv((glGetBooleanv_t)ptr); ptr = dlsym(gles_android,"glGetBufferParameteriv"); disp->set_glGetBufferParameteriv((glGetBufferParameteriv_t)ptr); ptr = dlsym(gles_android,"glGetClipPlanex"); disp->set_glGetClipPlanex((glGetClipPlanex_t)ptr); ptr = dlsym(gles_android,"glGenBuffers"); disp->set_glGenBuffers((glGenBuffers_t)ptr); ptr = dlsym(gles_android,"glGenTextures"); disp->set_glGenTextures((glGenTextures_t)ptr); ptr = dlsym(gles_android,"glGetError"); disp->set_glGetError((glGetError_t)ptr); ptr = dlsym(gles_android,"glGetFixedv"); disp->set_glGetFixedv((glGetFixedv_t)ptr); ptr = dlsym(gles_android,"glGetIntegerv"); disp->set_glGetIntegerv((glGetIntegerv_t)ptr); ptr = dlsym(gles_android,"glGetLightxv"); disp->set_glGetLightxv((glGetLightxv_t)ptr); ptr = dlsym(gles_android,"glGetMaterialxv"); disp->set_glGetMaterialxv((glGetMaterialxv_t)ptr); ptr = dlsym(gles_android,"glGetPointerv"); disp->set_glGetPointerv((glGetPointerv_t)ptr); ptr = dlsym(gles_android,"glGetString"); disp->set_glGetString((glGetString_t)ptr); ptr = dlsym(gles_android,"glGetTexEnviv"); disp->set_glGetTexEnviv((glGetTexEnviv_t)ptr); ptr = dlsym(gles_android,"glGetTexEnvxv"); disp->set_glGetTexEnvxv((glGetTexEnvxv_t)ptr); ptr = dlsym(gles_android,"glGetTexParameteriv"); disp->set_glGetTexParameteriv((glGetTexParameteriv_t)ptr); ptr = dlsym(gles_android,"glGetTexParameterxv"); disp->set_glGetTexParameterxv((glGetTexParameterxv_t)ptr); ptr = dlsym(gles_android,"glHint"); disp->set_glHint((glHint_t)ptr); ptr = dlsym(gles_android,"glIsBuffer"); disp->set_glIsBuffer((glIsBuffer_t)ptr); ptr = dlsym(gles_android,"glIsEnabled"); disp->set_glIsEnabled((glIsEnabled_t)ptr); ptr = dlsym(gles_android,"glIsTexture"); disp->set_glIsTexture((glIsTexture_t)ptr); ptr = dlsym(gles_android,"glLightModelx"); disp->set_glLightModelx((glLightModelx_t)ptr); ptr = dlsym(gles_android,"glLightModelxv"); disp->set_glLightModelxv((glLightModelxv_t)ptr); ptr = dlsym(gles_android,"glLightx"); disp->set_glLightx((glLightx_t)ptr); ptr = dlsym(gles_android,"glLightxv"); disp->set_glLightxv((glLightxv_t)ptr); ptr = dlsym(gles_android,"glLineWidthx"); disp->set_glLineWidthx((glLineWidthx_t)ptr); ptr = dlsym(gles_android,"glLoadIdentity"); disp->set_glLoadIdentity((glLoadIdentity_t)ptr); ptr = dlsym(gles_android,"glLoadMatrixx"); disp->set_glLoadMatrixx((glLoadMatrixx_t)ptr); ptr = dlsym(gles_android,"glLogicOp"); disp->set_glLogicOp((glLogicOp_t)ptr); ptr = dlsym(gles_android,"glMaterialx"); disp->set_glMaterialx((glMaterialx_t)ptr); ptr = dlsym(gles_android,"glMaterialxv"); disp->set_glMaterialxv((glMaterialxv_t)ptr); ptr = dlsym(gles_android,"glMatrixMode"); disp->set_glMatrixMode((glMatrixMode_t)ptr); ptr = dlsym(gles_android,"glMultMatrixx"); disp->set_glMultMatrixx((glMultMatrixx_t)ptr); ptr = dlsym(gles_android,"glMultiTexCoord4x"); disp->set_glMultiTexCoord4x((glMultiTexCoord4x_t)ptr); ptr = dlsym(gles_android,"glNormal3x"); disp->set_glNormal3x((glNormal3x_t)ptr); ptr = dlsym(gles_android,"glNormalPointer"); disp->set_glNormalPointer((glNormalPointer_t)ptr); ptr = dlsym(gles_android,"glOrthox"); disp->set_glOrthox((glOrthox_t)ptr); ptr = dlsym(gles_android,"glPixelStorei"); disp->set_glPixelStorei((glPixelStorei_t)ptr); ptr = dlsym(gles_android,"glPointParameterx"); disp->set_glPointParameterx((glPointParameterx_t)ptr); ptr = dlsym(gles_android,"glPointParameterxv"); disp->set_glPointParameterxv((glPointParameterxv_t)ptr); ptr = dlsym(gles_android,"glPointSizex"); disp->set_glPointSizex((glPointSizex_t)ptr); ptr = dlsym(gles_android,"glPolygonOffsetx"); disp->set_glPolygonOffsetx((glPolygonOffsetx_t)ptr); ptr = dlsym(gles_android,"glPopMatrix"); disp->set_glPopMatrix((glPopMatrix_t)ptr); ptr = dlsym(gles_android,"glPushMatrix"); disp->set_glPushMatrix((glPushMatrix_t)ptr); ptr = dlsym(gles_android,"glReadPixels"); disp->set_glReadPixels((glReadPixels_t)ptr); ptr = dlsym(gles_android,"glRotatex"); disp->set_glRotatex((glRotatex_t)ptr); ptr = dlsym(gles_android,"glSampleCoverage"); disp->set_glSampleCoverage((glSampleCoverage_t)ptr); ptr = dlsym(gles_android,"glSampleCoveragex"); disp->set_glSampleCoveragex((glSampleCoveragex_t)ptr); ptr = dlsym(gles_android,"glScalex"); disp->set_glScalex((glScalex_t)ptr); ptr = dlsym(gles_android,"glScissor"); disp->set_glScissor((glScissor_t)ptr); ptr = dlsym(gles_android,"glShadeModel"); disp->set_glShadeModel((glShadeModel_t)ptr); ptr = dlsym(gles_android,"glStencilFunc"); disp->set_glStencilFunc((glStencilFunc_t)ptr); ptr = dlsym(gles_android,"glStencilMask"); disp->set_glStencilMask((glStencilMask_t)ptr); ptr = dlsym(gles_android,"glStencilOp"); disp->set_glStencilOp((glStencilOp_t)ptr); ptr = dlsym(gles_android,"glTexCoordPointer"); disp->set_glTexCoordPointer((glTexCoordPointer_t)ptr); ptr = dlsym(gles_android,"glTexEnvi"); disp->set_glTexEnvi((glTexEnvi_t)ptr); ptr = dlsym(gles_android,"glTexEnvx"); disp->set_glTexEnvx((glTexEnvx_t)ptr); ptr = dlsym(gles_android,"glTexEnviv"); disp->set_glTexEnviv((glTexEnviv_t)ptr); ptr = dlsym(gles_android,"glTexEnvxv"); disp->set_glTexEnvxv((glTexEnvxv_t)ptr); ptr = dlsym(gles_android,"glTexImage2D"); disp->set_glTexImage2D((glTexImage2D_t)ptr); ptr = dlsym(gles_android,"glTexParameteri"); disp->set_glTexParameteri((glTexParameteri_t)ptr); ptr = dlsym(gles_android,"glTexParameterx"); disp->set_glTexParameterx((glTexParameterx_t)ptr); ptr = dlsym(gles_android,"glTexParameteriv"); disp->set_glTexParameteriv((glTexParameteriv_t)ptr); ptr = dlsym(gles_android,"glTexParameterxv"); disp->set_glTexParameterxv((glTexParameterxv_t)ptr); ptr = dlsym(gles_android,"glTexSubImage2D"); disp->set_glTexSubImage2D((glTexSubImage2D_t)ptr); ptr = dlsym(gles_android,"glTranslatex"); disp->set_glTranslatex((glTranslatex_t)ptr); ptr = dlsym(gles_android,"glVertexPointer"); disp->set_glVertexPointer((glVertexPointer_t)ptr); ptr = dlsym(gles_android,"glViewport"); disp->set_glViewport((glViewport_t)ptr); ptr = dlsym(gles_android,"glPointSizePointerOES"); disp->set_glPointSizePointerOES((glPointSizePointerOES_t)ptr); ptr = dlsym(gles_android,"glBlendEquationSeparateOES"); disp->set_glBlendEquationSeparateOES((glBlendEquationSeparateOES_t)ptr); ptr = dlsym(gles_android,"glBlendFuncSeparateOES"); disp->set_glBlendFuncSeparateOES((glBlendFuncSeparateOES_t)ptr); ptr = dlsym(gles_android,"glBlendEquationOES"); disp->set_glBlendEquationOES((glBlendEquationOES_t)ptr); ptr = dlsym(gles_android,"glDrawTexsOES"); disp->set_glDrawTexsOES((glDrawTexsOES_t)ptr); ptr = dlsym(gles_android,"glDrawTexiOES"); disp->set_glDrawTexiOES((glDrawTexiOES_t)ptr); ptr = dlsym(gles_android,"glDrawTexxOES"); disp->set_glDrawTexxOES((glDrawTexxOES_t)ptr); ptr = dlsym(gles_android,"glDrawTexsvOES"); disp->set_glDrawTexsvOES((glDrawTexsvOES_t)ptr); ptr = dlsym(gles_android,"glDrawTexivOES"); disp->set_glDrawTexivOES((glDrawTexivOES_t)ptr); ptr = dlsym(gles_android,"glDrawTexxvOES"); disp->set_glDrawTexxvOES((glDrawTexxvOES_t)ptr); ptr = dlsym(gles_android,"glDrawTexfOES"); disp->set_glDrawTexfOES((glDrawTexfOES_t)ptr); ptr = dlsym(gles_android,"glDrawTexfvOES"); disp->set_glDrawTexfvOES((glDrawTexfvOES_t)ptr); ptr = dlsym(gles_android,"glEGLImageTargetTexture2DOES"); disp->set_glEGLImageTargetTexture2DOES((glEGLImageTargetTexture2DOES_t)ptr); ptr = dlsym(gles_android,"glEGLImageTargetRenderbufferStorageOES"); disp->set_glEGLImageTargetRenderbufferStorageOES((glEGLImageTargetRenderbufferStorageOES_t)ptr); ptr = dlsym(gles_android,"glAlphaFuncxOES"); disp->set_glAlphaFuncxOES((glAlphaFuncxOES_t)ptr); ptr = dlsym(gles_android,"glClearColorxOES"); disp->set_glClearColorxOES((glClearColorxOES_t)ptr); ptr = dlsym(gles_android,"glClearDepthxOES"); disp->set_glClearDepthxOES((glClearDepthxOES_t)ptr); ptr = dlsym(gles_android,"glClipPlanexOES"); disp->set_glClipPlanexOES((glClipPlanexOES_t)ptr); ptr = dlsym(gles_android,"glColor4xOES"); disp->set_glColor4xOES((glColor4xOES_t)ptr); ptr = dlsym(gles_android,"glDepthRangexOES"); disp->set_glDepthRangexOES((glDepthRangexOES_t)ptr); ptr = dlsym(gles_android,"glFogxOES"); disp->set_glFogxOES((glFogxOES_t)ptr); ptr = dlsym(gles_android,"glFogxvOES"); disp->set_glFogxvOES((glFogxvOES_t)ptr); ptr = dlsym(gles_android,"glFrustumxOES"); disp->set_glFrustumxOES((glFrustumxOES_t)ptr); ptr = dlsym(gles_android,"glGetClipPlanexOES"); disp->set_glGetClipPlanexOES((glGetClipPlanexOES_t)ptr); ptr = dlsym(gles_android,"glGetFixedvOES"); disp->set_glGetFixedvOES((glGetFixedvOES_t)ptr); ptr = dlsym(gles_android,"glGetLightxvOES"); disp->set_glGetLightxvOES((glGetLightxvOES_t)ptr); ptr = dlsym(gles_android,"glGetMaterialxvOES"); disp->set_glGetMaterialxvOES((glGetMaterialxvOES_t)ptr); ptr = dlsym(gles_android,"glGetTexEnvxvOES"); disp->set_glGetTexEnvxvOES((glGetTexEnvxvOES_t)ptr); ptr = dlsym(gles_android,"glGetTexParameterxvOES"); disp->set_glGetTexParameterxvOES((glGetTexParameterxvOES_t)ptr); ptr = dlsym(gles_android,"glLightModelxOES"); disp->set_glLightModelxOES((glLightModelxOES_t)ptr); ptr = dlsym(gles_android,"glLightModelxvOES"); disp->set_glLightModelxvOES((glLightModelxvOES_t)ptr); ptr = dlsym(gles_android,"glLightxOES"); disp->set_glLightxOES((glLightxOES_t)ptr); ptr = dlsym(gles_android,"glLightxvOES"); disp->set_glLightxvOES((glLightxvOES_t)ptr); ptr = dlsym(gles_android,"glLineWidthxOES"); disp->set_glLineWidthxOES((glLineWidthxOES_t)ptr); ptr = dlsym(gles_android,"glLoadMatrixxOES"); disp->set_glLoadMatrixxOES((glLoadMatrixxOES_t)ptr); ptr = dlsym(gles_android,"glMaterialxOES"); disp->set_glMaterialxOES((glMaterialxOES_t)ptr); ptr = dlsym(gles_android,"glMaterialxvOES"); disp->set_glMaterialxvOES((glMaterialxvOES_t)ptr); ptr = dlsym(gles_android,"glMultMatrixxOES"); disp->set_glMultMatrixxOES((glMultMatrixxOES_t)ptr); ptr = dlsym(gles_android,"glMultiTexCoord4xOES"); disp->set_glMultiTexCoord4xOES((glMultiTexCoord4xOES_t)ptr); ptr = dlsym(gles_android,"glNormal3xOES"); disp->set_glNormal3xOES((glNormal3xOES_t)ptr); ptr = dlsym(gles_android,"glOrthoxOES"); disp->set_glOrthoxOES((glOrthoxOES_t)ptr); ptr = dlsym(gles_android,"glPointParameterxOES"); disp->set_glPointParameterxOES((glPointParameterxOES_t)ptr); ptr = dlsym(gles_android,"glPointParameterxvOES"); disp->set_glPointParameterxvOES((glPointParameterxvOES_t)ptr); ptr = dlsym(gles_android,"glPointSizexOES"); disp->set_glPointSizexOES((glPointSizexOES_t)ptr); ptr = dlsym(gles_android,"glPolygonOffsetxOES"); disp->set_glPolygonOffsetxOES((glPolygonOffsetxOES_t)ptr); ptr = dlsym(gles_android,"glRotatexOES"); disp->set_glRotatexOES((glRotatexOES_t)ptr); ptr = dlsym(gles_android,"glSampleCoveragexOES"); disp->set_glSampleCoveragexOES((glSampleCoveragexOES_t)ptr); ptr = dlsym(gles_android,"glScalexOES"); disp->set_glScalexOES((glScalexOES_t)ptr); ptr = dlsym(gles_android,"glTexEnvxOES"); disp->set_glTexEnvxOES((glTexEnvxOES_t)ptr); ptr = dlsym(gles_android,"glTexEnvxvOES"); disp->set_glTexEnvxvOES((glTexEnvxvOES_t)ptr); ptr = dlsym(gles_android,"glTexParameterxOES"); disp->set_glTexParameterxOES((glTexParameterxOES_t)ptr); ptr = dlsym(gles_android,"glTexParameterxvOES"); disp->set_glTexParameterxvOES((glTexParameterxvOES_t)ptr); ptr = dlsym(gles_android,"glTranslatexOES"); disp->set_glTranslatexOES((glTranslatexOES_t)ptr); ptr = dlsym(gles_android,"glIsRenderbufferOES"); disp->set_glIsRenderbufferOES((glIsRenderbufferOES_t)ptr); ptr = dlsym(gles_android,"glBindRenderbufferOES"); disp->set_glBindRenderbufferOES((glBindRenderbufferOES_t)ptr); ptr = dlsym(gles_android,"glDeleteRenderbuffersOES"); disp->set_glDeleteRenderbuffersOES((glDeleteRenderbuffersOES_t)ptr); ptr = dlsym(gles_android,"glGenRenderbuffersOES"); disp->set_glGenRenderbuffersOES((glGenRenderbuffersOES_t)ptr); ptr = dlsym(gles_android,"glRenderbufferStorageOES"); disp->set_glRenderbufferStorageOES((glRenderbufferStorageOES_t)ptr); ptr = dlsym(gles_android,"glGetRenderbufferParameterivOES"); disp->set_glGetRenderbufferParameterivOES((glGetRenderbufferParameterivOES_t)ptr); ptr = dlsym(gles_android,"glIsFramebufferOES"); disp->set_glIsFramebufferOES((glIsFramebufferOES_t)ptr); ptr = dlsym(gles_android,"glBindFramebufferOES"); disp->set_glBindFramebufferOES((glBindFramebufferOES_t)ptr); ptr = dlsym(gles_android,"glDeleteFramebuffersOES"); disp->set_glDeleteFramebuffersOES((glDeleteFramebuffersOES_t)ptr); ptr = dlsym(gles_android,"glGenFramebuffersOES"); disp->set_glGenFramebuffersOES((glGenFramebuffersOES_t)ptr); ptr = dlsym(gles_android,"glCheckFramebufferStatusOES"); disp->set_glCheckFramebufferStatusOES((glCheckFramebufferStatusOES_t)ptr); ptr = dlsym(gles_android,"glFramebufferRenderbufferOES"); disp->set_glFramebufferRenderbufferOES((glFramebufferRenderbufferOES_t)ptr); ptr = dlsym(gles_android,"glFramebufferTexture2DOES"); disp->set_glFramebufferTexture2DOES((glFramebufferTexture2DOES_t)ptr); ptr = dlsym(gles_android,"glGetFramebufferAttachmentParameterivOES"); disp->set_glGetFramebufferAttachmentParameterivOES((glGetFramebufferAttachmentParameterivOES_t)ptr); ptr = dlsym(gles_android,"glGenerateMipmapOES"); disp->set_glGenerateMipmapOES((glGenerateMipmapOES_t)ptr); ptr = dlsym(gles_android,"glMapBufferOES"); disp->set_glMapBufferOES((glMapBufferOES_t)ptr); ptr = dlsym(gles_android,"glUnmapBufferOES"); disp->set_glUnmapBufferOES((glUnmapBufferOES_t)ptr); ptr = dlsym(gles_android,"glGetBufferPointervOES"); disp->set_glGetBufferPointervOES((glGetBufferPointervOES_t)ptr); ptr = dlsym(gles_android,"glCurrentPaletteMatrixOES"); disp->set_glCurrentPaletteMatrixOES((glCurrentPaletteMatrixOES_t)ptr); ptr = dlsym(gles_android,"glLoadPaletteFromModelViewMatrixOES"); disp->set_glLoadPaletteFromModelViewMatrixOES((glLoadPaletteFromModelViewMatrixOES_t)ptr); ptr = dlsym(gles_android,"glMatrixIndexPointerOES"); disp->set_glMatrixIndexPointerOES((glMatrixIndexPointerOES_t)ptr); ptr = dlsym(gles_android,"glWeightPointerOES"); disp->set_glWeightPointerOES((glWeightPointerOES_t)ptr); ptr = dlsym(gles_android,"glQueryMatrixxOES"); disp->set_glQueryMatrixxOES((glQueryMatrixxOES_t)ptr); ptr = dlsym(gles_android,"glDepthRangefOES"); disp->set_glDepthRangefOES((glDepthRangefOES_t)ptr); ptr = dlsym(gles_android,"glFrustumfOES"); disp->set_glFrustumfOES((glFrustumfOES_t)ptr); ptr = dlsym(gles_android,"glOrthofOES"); disp->set_glOrthofOES((glOrthofOES_t)ptr); ptr = dlsym(gles_android,"glClipPlanefOES"); disp->set_glClipPlanefOES((glClipPlanefOES_t)ptr); ptr = dlsym(gles_android,"glGetClipPlanefOES"); disp->set_glGetClipPlanefOES((glGetClipPlanefOES_t)ptr); ptr = dlsym(gles_android,"glClearDepthfOES"); disp->set_glClearDepthfOES((glClearDepthfOES_t)ptr); ptr = dlsym(gles_android,"glTexGenfOES"); disp->set_glTexGenfOES((glTexGenfOES_t)ptr); ptr = dlsym(gles_android,"glTexGenfvOES"); disp->set_glTexGenfvOES((glTexGenfvOES_t)ptr); ptr = dlsym(gles_android,"glTexGeniOES"); disp->set_glTexGeniOES((glTexGeniOES_t)ptr); ptr = dlsym(gles_android,"glTexGenivOES"); disp->set_glTexGenivOES((glTexGenivOES_t)ptr); ptr = dlsym(gles_android,"glTexGenxOES"); disp->set_glTexGenxOES((glTexGenxOES_t)ptr); ptr = dlsym(gles_android,"glTexGenxvOES"); disp->set_glTexGenxvOES((glTexGenxvOES_t)ptr); ptr = dlsym(gles_android,"glGetTexGenfvOES"); disp->set_glGetTexGenfvOES((glGetTexGenfvOES_t)ptr); ptr = dlsym(gles_android,"glGetTexGenivOES"); disp->set_glGetTexGenivOES((glGetTexGenivOES_t)ptr); ptr = dlsym(gles_android,"glGetTexGenxvOES"); disp->set_glGetTexGenxvOES((glGetTexGenxvOES_t)ptr); ptr = dlsym(gles_android,"glBindVertexArrayOES"); disp->set_glBindVertexArrayOES((glBindVertexArrayOES_t)ptr); ptr = dlsym(gles_android,"glDeleteVertexArraysOES"); disp->set_glDeleteVertexArraysOES((glDeleteVertexArraysOES_t)ptr); ptr = dlsym(gles_android,"glGenVertexArraysOES"); disp->set_glGenVertexArraysOES((glGenVertexArraysOES_t)ptr); ptr = dlsym(gles_android,"glIsVertexArrayOES"); disp->set_glIsVertexArrayOES((glIsVertexArrayOES_t)ptr); ptr = dlsym(gles_android,"glDiscardFramebufferEXT"); disp->set_glDiscardFramebufferEXT((glDiscardFramebufferEXT_t)ptr); ptr = dlsym(gles_android,"glMultiDrawArraysEXT"); disp->set_glMultiDrawArraysEXT((glMultiDrawArraysEXT_t)ptr); ptr = dlsym(gles_android,"glMultiDrawElementsEXT"); disp->set_glMultiDrawElementsEXT((glMultiDrawElementsEXT_t)ptr); ptr = dlsym(gles_android,"glClipPlanefIMG"); disp->set_glClipPlanefIMG((glClipPlanefIMG_t)ptr); ptr = dlsym(gles_android,"glClipPlanexIMG"); disp->set_glClipPlanexIMG((glClipPlanexIMG_t)ptr); ptr = dlsym(gles_android,"glRenderbufferStorageMultisampleIMG"); disp->set_glRenderbufferStorageMultisampleIMG((glRenderbufferStorageMultisampleIMG_t)ptr); ptr = dlsym(gles_android,"glFramebufferTexture2DMultisampleIMG"); disp->set_glFramebufferTexture2DMultisampleIMG((glFramebufferTexture2DMultisampleIMG_t)ptr); ptr = dlsym(gles_android,"glDeleteFencesNV"); disp->set_glDeleteFencesNV((glDeleteFencesNV_t)ptr); ptr = dlsym(gles_android,"glGenFencesNV"); disp->set_glGenFencesNV((glGenFencesNV_t)ptr); ptr = dlsym(gles_android,"glIsFenceNV"); disp->set_glIsFenceNV((glIsFenceNV_t)ptr); ptr = dlsym(gles_android,"glTestFenceNV"); disp->set_glTestFenceNV((glTestFenceNV_t)ptr); ptr = dlsym(gles_android,"glGetFenceivNV"); disp->set_glGetFenceivNV((glGetFenceivNV_t)ptr); ptr = dlsym(gles_android,"glFinishFenceNV"); disp->set_glFinishFenceNV((glFinishFenceNV_t)ptr); ptr = dlsym(gles_android,"glSetFenceNV"); disp->set_glSetFenceNV((glSetFenceNV_t)ptr); ptr = dlsym(gles_android,"glGetDriverControlsQCOM"); disp->set_glGetDriverControlsQCOM((glGetDriverControlsQCOM_t)ptr); ptr = dlsym(gles_android,"glGetDriverControlStringQCOM"); disp->set_glGetDriverControlStringQCOM((glGetDriverControlStringQCOM_t)ptr); ptr = dlsym(gles_android,"glEnableDriverControlQCOM"); disp->set_glEnableDriverControlQCOM((glEnableDriverControlQCOM_t)ptr); ptr = dlsym(gles_android,"glDisableDriverControlQCOM"); disp->set_glDisableDriverControlQCOM((glDisableDriverControlQCOM_t)ptr); ptr = dlsym(gles_android,"glExtGetTexturesQCOM"); disp->set_glExtGetTexturesQCOM((glExtGetTexturesQCOM_t)ptr); ptr = dlsym(gles_android,"glExtGetBuffersQCOM"); disp->set_glExtGetBuffersQCOM((glExtGetBuffersQCOM_t)ptr); ptr = dlsym(gles_android,"glExtGetRenderbuffersQCOM"); disp->set_glExtGetRenderbuffersQCOM((glExtGetRenderbuffersQCOM_t)ptr); ptr = dlsym(gles_android,"glExtGetFramebuffersQCOM"); disp->set_glExtGetFramebuffersQCOM((glExtGetFramebuffersQCOM_t)ptr); ptr = dlsym(gles_android,"glExtGetTexLevelParameterivQCOM"); disp->set_glExtGetTexLevelParameterivQCOM((glExtGetTexLevelParameterivQCOM_t)ptr); ptr = dlsym(gles_android,"glExtTexObjectStateOverrideiQCOM"); disp->set_glExtTexObjectStateOverrideiQCOM((glExtTexObjectStateOverrideiQCOM_t)ptr); ptr = dlsym(gles_android,"glExtGetTexSubImageQCOM"); disp->set_glExtGetTexSubImageQCOM((glExtGetTexSubImageQCOM_t)ptr); ptr = dlsym(gles_android,"glExtGetBufferPointervQCOM"); disp->set_glExtGetBufferPointervQCOM((glExtGetBufferPointervQCOM_t)ptr); ptr = dlsym(gles_android,"glExtGetShadersQCOM"); disp->set_glExtGetShadersQCOM((glExtGetShadersQCOM_t)ptr); ptr = dlsym(gles_android,"glExtGetProgramsQCOM"); disp->set_glExtGetProgramsQCOM((glExtGetProgramsQCOM_t)ptr); ptr = dlsym(gles_android,"glExtIsProgramBinaryQCOM"); disp->set_glExtIsProgramBinaryQCOM((glExtIsProgramBinaryQCOM_t)ptr); ptr = dlsym(gles_android,"glExtGetProgramBinarySourceQCOM"); disp->set_glExtGetProgramBinarySourceQCOM((glExtGetProgramBinarySourceQCOM_t)ptr); ptr = dlsym(gles_android,"glStartTilingQCOM"); disp->set_glStartTilingQCOM((glStartTilingQCOM_t)ptr); ptr = dlsym(gles_android,"glEndTilingQCOM"); disp->set_glEndTilingQCOM((glEndTilingQCOM_t)ptr); return disp; } anbox-0.0~git20191115/android/opengl/tests/gles_android_wrapper/gles_dispatch.h000066400000000000000000001452001356361734700274510ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _GLES_DISPATCH_H #define _GLES_DISPATCH_H #include "gles_proc.h" struct gles_dispatch { glAlphaFunc_t glAlphaFunc; glClearColor_t glClearColor; glClearDepthf_t glClearDepthf; glClipPlanef_t glClipPlanef; glColor4f_t glColor4f; glDepthRangef_t glDepthRangef; glFogf_t glFogf; glFogfv_t glFogfv; glFrustumf_t glFrustumf; glGetClipPlanef_t glGetClipPlanef; glGetFloatv_t glGetFloatv; glGetLightfv_t glGetLightfv; glGetMaterialfv_t glGetMaterialfv; glGetTexEnvfv_t glGetTexEnvfv; glGetTexParameterfv_t glGetTexParameterfv; glLightModelf_t glLightModelf; glLightModelfv_t glLightModelfv; glLightf_t glLightf; glLightfv_t glLightfv; glLineWidth_t glLineWidth; glLoadMatrixf_t glLoadMatrixf; glMaterialf_t glMaterialf; glMaterialfv_t glMaterialfv; glMultMatrixf_t glMultMatrixf; glMultiTexCoord4f_t glMultiTexCoord4f; glNormal3f_t glNormal3f; glOrthof_t glOrthof; glPointParameterf_t glPointParameterf; glPointParameterfv_t glPointParameterfv; glPointSize_t glPointSize; glPolygonOffset_t glPolygonOffset; glRotatef_t glRotatef; glScalef_t glScalef; glTexEnvf_t glTexEnvf; glTexEnvfv_t glTexEnvfv; glTexParameterf_t glTexParameterf; glTexParameterfv_t glTexParameterfv; glTranslatef_t glTranslatef; glActiveTexture_t glActiveTexture; glAlphaFuncx_t glAlphaFuncx; glBindBuffer_t glBindBuffer; glBindTexture_t glBindTexture; glBlendFunc_t glBlendFunc; glBufferData_t glBufferData; glBufferSubData_t glBufferSubData; glClear_t glClear; glClearColorx_t glClearColorx; glClearDepthx_t glClearDepthx; glClearStencil_t glClearStencil; glClientActiveTexture_t glClientActiveTexture; glClipPlanex_t glClipPlanex; glColor4ub_t glColor4ub; glColor4x_t glColor4x; glColorMask_t glColorMask; glColorPointer_t glColorPointer; glCompressedTexImage2D_t glCompressedTexImage2D; glCompressedTexSubImage2D_t glCompressedTexSubImage2D; glCopyTexImage2D_t glCopyTexImage2D; glCopyTexSubImage2D_t glCopyTexSubImage2D; glCullFace_t glCullFace; glDeleteBuffers_t glDeleteBuffers; glDeleteTextures_t glDeleteTextures; glDepthFunc_t glDepthFunc; glDepthMask_t glDepthMask; glDepthRangex_t glDepthRangex; glDisable_t glDisable; glDisableClientState_t glDisableClientState; glDrawArrays_t glDrawArrays; glDrawElements_t glDrawElements; glEnable_t glEnable; glEnableClientState_t glEnableClientState; glFinish_t glFinish; glFlush_t glFlush; glFogx_t glFogx; glFogxv_t glFogxv; glFrontFace_t glFrontFace; glFrustumx_t glFrustumx; glGetBooleanv_t glGetBooleanv; glGetBufferParameteriv_t glGetBufferParameteriv; glGetClipPlanex_t glGetClipPlanex; glGenBuffers_t glGenBuffers; glGenTextures_t glGenTextures; glGetError_t glGetError; glGetFixedv_t glGetFixedv; glGetIntegerv_t glGetIntegerv; glGetLightxv_t glGetLightxv; glGetMaterialxv_t glGetMaterialxv; glGetPointerv_t glGetPointerv; glGetString_t glGetString; glGetTexEnviv_t glGetTexEnviv; glGetTexEnvxv_t glGetTexEnvxv; glGetTexParameteriv_t glGetTexParameteriv; glGetTexParameterxv_t glGetTexParameterxv; glHint_t glHint; glIsBuffer_t glIsBuffer; glIsEnabled_t glIsEnabled; glIsTexture_t glIsTexture; glLightModelx_t glLightModelx; glLightModelxv_t glLightModelxv; glLightx_t glLightx; glLightxv_t glLightxv; glLineWidthx_t glLineWidthx; glLoadIdentity_t glLoadIdentity; glLoadMatrixx_t glLoadMatrixx; glLogicOp_t glLogicOp; glMaterialx_t glMaterialx; glMaterialxv_t glMaterialxv; glMatrixMode_t glMatrixMode; glMultMatrixx_t glMultMatrixx; glMultiTexCoord4x_t glMultiTexCoord4x; glNormal3x_t glNormal3x; glNormalPointer_t glNormalPointer; glOrthox_t glOrthox; glPixelStorei_t glPixelStorei; glPointParameterx_t glPointParameterx; glPointParameterxv_t glPointParameterxv; glPointSizex_t glPointSizex; glPolygonOffsetx_t glPolygonOffsetx; glPopMatrix_t glPopMatrix; glPushMatrix_t glPushMatrix; glReadPixels_t glReadPixels; glRotatex_t glRotatex; glSampleCoverage_t glSampleCoverage; glSampleCoveragex_t glSampleCoveragex; glScalex_t glScalex; glScissor_t glScissor; glShadeModel_t glShadeModel; glStencilFunc_t glStencilFunc; glStencilMask_t glStencilMask; glStencilOp_t glStencilOp; glTexCoordPointer_t glTexCoordPointer; glTexEnvi_t glTexEnvi; glTexEnvx_t glTexEnvx; glTexEnviv_t glTexEnviv; glTexEnvxv_t glTexEnvxv; glTexImage2D_t glTexImage2D; glTexParameteri_t glTexParameteri; glTexParameterx_t glTexParameterx; glTexParameteriv_t glTexParameteriv; glTexParameterxv_t glTexParameterxv; glTexSubImage2D_t glTexSubImage2D; glTranslatex_t glTranslatex; glVertexPointer_t glVertexPointer; glViewport_t glViewport; glPointSizePointerOES_t glPointSizePointerOES; glBlendEquationSeparateOES_t glBlendEquationSeparateOES; glBlendFuncSeparateOES_t glBlendFuncSeparateOES; glBlendEquationOES_t glBlendEquationOES; glDrawTexsOES_t glDrawTexsOES; glDrawTexiOES_t glDrawTexiOES; glDrawTexxOES_t glDrawTexxOES; glDrawTexsvOES_t glDrawTexsvOES; glDrawTexivOES_t glDrawTexivOES; glDrawTexxvOES_t glDrawTexxvOES; glDrawTexfOES_t glDrawTexfOES; glDrawTexfvOES_t glDrawTexfvOES; glEGLImageTargetTexture2DOES_t glEGLImageTargetTexture2DOES; glEGLImageTargetRenderbufferStorageOES_t glEGLImageTargetRenderbufferStorageOES; glAlphaFuncxOES_t glAlphaFuncxOES; glClearColorxOES_t glClearColorxOES; glClearDepthxOES_t glClearDepthxOES; glClipPlanexOES_t glClipPlanexOES; glColor4xOES_t glColor4xOES; glDepthRangexOES_t glDepthRangexOES; glFogxOES_t glFogxOES; glFogxvOES_t glFogxvOES; glFrustumxOES_t glFrustumxOES; glGetClipPlanexOES_t glGetClipPlanexOES; glGetFixedvOES_t glGetFixedvOES; glGetLightxvOES_t glGetLightxvOES; glGetMaterialxvOES_t glGetMaterialxvOES; glGetTexEnvxvOES_t glGetTexEnvxvOES; glGetTexParameterxvOES_t glGetTexParameterxvOES; glLightModelxOES_t glLightModelxOES; glLightModelxvOES_t glLightModelxvOES; glLightxOES_t glLightxOES; glLightxvOES_t glLightxvOES; glLineWidthxOES_t glLineWidthxOES; glLoadMatrixxOES_t glLoadMatrixxOES; glMaterialxOES_t glMaterialxOES; glMaterialxvOES_t glMaterialxvOES; glMultMatrixxOES_t glMultMatrixxOES; glMultiTexCoord4xOES_t glMultiTexCoord4xOES; glNormal3xOES_t glNormal3xOES; glOrthoxOES_t glOrthoxOES; glPointParameterxOES_t glPointParameterxOES; glPointParameterxvOES_t glPointParameterxvOES; glPointSizexOES_t glPointSizexOES; glPolygonOffsetxOES_t glPolygonOffsetxOES; glRotatexOES_t glRotatexOES; glSampleCoveragexOES_t glSampleCoveragexOES; glScalexOES_t glScalexOES; glTexEnvxOES_t glTexEnvxOES; glTexEnvxvOES_t glTexEnvxvOES; glTexParameterxOES_t glTexParameterxOES; glTexParameterxvOES_t glTexParameterxvOES; glTranslatexOES_t glTranslatexOES; glIsRenderbufferOES_t glIsRenderbufferOES; glBindRenderbufferOES_t glBindRenderbufferOES; glDeleteRenderbuffersOES_t glDeleteRenderbuffersOES; glGenRenderbuffersOES_t glGenRenderbuffersOES; glRenderbufferStorageOES_t glRenderbufferStorageOES; glGetRenderbufferParameterivOES_t glGetRenderbufferParameterivOES; glIsFramebufferOES_t glIsFramebufferOES; glBindFramebufferOES_t glBindFramebufferOES; glDeleteFramebuffersOES_t glDeleteFramebuffersOES; glGenFramebuffersOES_t glGenFramebuffersOES; glCheckFramebufferStatusOES_t glCheckFramebufferStatusOES; glFramebufferRenderbufferOES_t glFramebufferRenderbufferOES; glFramebufferTexture2DOES_t glFramebufferTexture2DOES; glGetFramebufferAttachmentParameterivOES_t glGetFramebufferAttachmentParameterivOES; glGenerateMipmapOES_t glGenerateMipmapOES; glMapBufferOES_t glMapBufferOES; glUnmapBufferOES_t glUnmapBufferOES; glGetBufferPointervOES_t glGetBufferPointervOES; glCurrentPaletteMatrixOES_t glCurrentPaletteMatrixOES; glLoadPaletteFromModelViewMatrixOES_t glLoadPaletteFromModelViewMatrixOES; glMatrixIndexPointerOES_t glMatrixIndexPointerOES; glWeightPointerOES_t glWeightPointerOES; glQueryMatrixxOES_t glQueryMatrixxOES; glDepthRangefOES_t glDepthRangefOES; glFrustumfOES_t glFrustumfOES; glOrthofOES_t glOrthofOES; glClipPlanefOES_t glClipPlanefOES; glGetClipPlanefOES_t glGetClipPlanefOES; glClearDepthfOES_t glClearDepthfOES; glTexGenfOES_t glTexGenfOES; glTexGenfvOES_t glTexGenfvOES; glTexGeniOES_t glTexGeniOES; glTexGenivOES_t glTexGenivOES; glTexGenxOES_t glTexGenxOES; glTexGenxvOES_t glTexGenxvOES; glGetTexGenfvOES_t glGetTexGenfvOES; glGetTexGenivOES_t glGetTexGenivOES; glGetTexGenxvOES_t glGetTexGenxvOES; glBindVertexArrayOES_t glBindVertexArrayOES; glDeleteVertexArraysOES_t glDeleteVertexArraysOES; glGenVertexArraysOES_t glGenVertexArraysOES; glIsVertexArrayOES_t glIsVertexArrayOES; glDiscardFramebufferEXT_t glDiscardFramebufferEXT; glMultiDrawArraysEXT_t glMultiDrawArraysEXT; glMultiDrawElementsEXT_t glMultiDrawElementsEXT; glClipPlanefIMG_t glClipPlanefIMG; glClipPlanexIMG_t glClipPlanexIMG; glRenderbufferStorageMultisampleIMG_t glRenderbufferStorageMultisampleIMG; glFramebufferTexture2DMultisampleIMG_t glFramebufferTexture2DMultisampleIMG; glDeleteFencesNV_t glDeleteFencesNV; glGenFencesNV_t glGenFencesNV; glIsFenceNV_t glIsFenceNV; glTestFenceNV_t glTestFenceNV; glGetFenceivNV_t glGetFenceivNV; glFinishFenceNV_t glFinishFenceNV; glSetFenceNV_t glSetFenceNV; glGetDriverControlsQCOM_t glGetDriverControlsQCOM; glGetDriverControlStringQCOM_t glGetDriverControlStringQCOM; glEnableDriverControlQCOM_t glEnableDriverControlQCOM; glDisableDriverControlQCOM_t glDisableDriverControlQCOM; glExtGetTexturesQCOM_t glExtGetTexturesQCOM; glExtGetBuffersQCOM_t glExtGetBuffersQCOM; glExtGetRenderbuffersQCOM_t glExtGetRenderbuffersQCOM; glExtGetFramebuffersQCOM_t glExtGetFramebuffersQCOM; glExtGetTexLevelParameterivQCOM_t glExtGetTexLevelParameterivQCOM; glExtTexObjectStateOverrideiQCOM_t glExtTexObjectStateOverrideiQCOM; glExtGetTexSubImageQCOM_t glExtGetTexSubImageQCOM; glExtGetBufferPointervQCOM_t glExtGetBufferPointervQCOM; glExtGetShadersQCOM_t glExtGetShadersQCOM; glExtGetProgramsQCOM_t glExtGetProgramsQCOM; glExtIsProgramBinaryQCOM_t glExtIsProgramBinaryQCOM; glExtGetProgramBinarySourceQCOM_t glExtGetProgramBinarySourceQCOM; glStartTilingQCOM_t glStartTilingQCOM; glEndTilingQCOM_t glEndTilingQCOM; //Accessors glAlphaFunc_t set_glAlphaFunc(glAlphaFunc_t f) { glAlphaFunc_t retval = glAlphaFunc; glAlphaFunc = f; return retval;} glClearColor_t set_glClearColor(glClearColor_t f) { glClearColor_t retval = glClearColor; glClearColor = f; return retval;} glClearDepthf_t set_glClearDepthf(glClearDepthf_t f) { glClearDepthf_t retval = glClearDepthf; glClearDepthf = f; return retval;} glClipPlanef_t set_glClipPlanef(glClipPlanef_t f) { glClipPlanef_t retval = glClipPlanef; glClipPlanef = f; return retval;} glColor4f_t set_glColor4f(glColor4f_t f) { glColor4f_t retval = glColor4f; glColor4f = f; return retval;} glDepthRangef_t set_glDepthRangef(glDepthRangef_t f) { glDepthRangef_t retval = glDepthRangef; glDepthRangef = f; return retval;} glFogf_t set_glFogf(glFogf_t f) { glFogf_t retval = glFogf; glFogf = f; return retval;} glFogfv_t set_glFogfv(glFogfv_t f) { glFogfv_t retval = glFogfv; glFogfv = f; return retval;} glFrustumf_t set_glFrustumf(glFrustumf_t f) { glFrustumf_t retval = glFrustumf; glFrustumf = f; return retval;} glGetClipPlanef_t set_glGetClipPlanef(glGetClipPlanef_t f) { glGetClipPlanef_t retval = glGetClipPlanef; glGetClipPlanef = f; return retval;} glGetFloatv_t set_glGetFloatv(glGetFloatv_t f) { glGetFloatv_t retval = glGetFloatv; glGetFloatv = f; return retval;} glGetLightfv_t set_glGetLightfv(glGetLightfv_t f) { glGetLightfv_t retval = glGetLightfv; glGetLightfv = f; return retval;} glGetMaterialfv_t set_glGetMaterialfv(glGetMaterialfv_t f) { glGetMaterialfv_t retval = glGetMaterialfv; glGetMaterialfv = f; return retval;} glGetTexEnvfv_t set_glGetTexEnvfv(glGetTexEnvfv_t f) { glGetTexEnvfv_t retval = glGetTexEnvfv; glGetTexEnvfv = f; return retval;} glGetTexParameterfv_t set_glGetTexParameterfv(glGetTexParameterfv_t f) { glGetTexParameterfv_t retval = glGetTexParameterfv; glGetTexParameterfv = f; return retval;} glLightModelf_t set_glLightModelf(glLightModelf_t f) { glLightModelf_t retval = glLightModelf; glLightModelf = f; return retval;} glLightModelfv_t set_glLightModelfv(glLightModelfv_t f) { glLightModelfv_t retval = glLightModelfv; glLightModelfv = f; return retval;} glLightf_t set_glLightf(glLightf_t f) { glLightf_t retval = glLightf; glLightf = f; return retval;} glLightfv_t set_glLightfv(glLightfv_t f) { glLightfv_t retval = glLightfv; glLightfv = f; return retval;} glLineWidth_t set_glLineWidth(glLineWidth_t f) { glLineWidth_t retval = glLineWidth; glLineWidth = f; return retval;} glLoadMatrixf_t set_glLoadMatrixf(glLoadMatrixf_t f) { glLoadMatrixf_t retval = glLoadMatrixf; glLoadMatrixf = f; return retval;} glMaterialf_t set_glMaterialf(glMaterialf_t f) { glMaterialf_t retval = glMaterialf; glMaterialf = f; return retval;} glMaterialfv_t set_glMaterialfv(glMaterialfv_t f) { glMaterialfv_t retval = glMaterialfv; glMaterialfv = f; return retval;} glMultMatrixf_t set_glMultMatrixf(glMultMatrixf_t f) { glMultMatrixf_t retval = glMultMatrixf; glMultMatrixf = f; return retval;} glMultiTexCoord4f_t set_glMultiTexCoord4f(glMultiTexCoord4f_t f) { glMultiTexCoord4f_t retval = glMultiTexCoord4f; glMultiTexCoord4f = f; return retval;} glNormal3f_t set_glNormal3f(glNormal3f_t f) { glNormal3f_t retval = glNormal3f; glNormal3f = f; return retval;} glOrthof_t set_glOrthof(glOrthof_t f) { glOrthof_t retval = glOrthof; glOrthof = f; return retval;} glPointParameterf_t set_glPointParameterf(glPointParameterf_t f) { glPointParameterf_t retval = glPointParameterf; glPointParameterf = f; return retval;} glPointParameterfv_t set_glPointParameterfv(glPointParameterfv_t f) { glPointParameterfv_t retval = glPointParameterfv; glPointParameterfv = f; return retval;} glPointSize_t set_glPointSize(glPointSize_t f) { glPointSize_t retval = glPointSize; glPointSize = f; return retval;} glPolygonOffset_t set_glPolygonOffset(glPolygonOffset_t f) { glPolygonOffset_t retval = glPolygonOffset; glPolygonOffset = f; return retval;} glRotatef_t set_glRotatef(glRotatef_t f) { glRotatef_t retval = glRotatef; glRotatef = f; return retval;} glScalef_t set_glScalef(glScalef_t f) { glScalef_t retval = glScalef; glScalef = f; return retval;} glTexEnvf_t set_glTexEnvf(glTexEnvf_t f) { glTexEnvf_t retval = glTexEnvf; glTexEnvf = f; return retval;} glTexEnvfv_t set_glTexEnvfv(glTexEnvfv_t f) { glTexEnvfv_t retval = glTexEnvfv; glTexEnvfv = f; return retval;} glTexParameterf_t set_glTexParameterf(glTexParameterf_t f) { glTexParameterf_t retval = glTexParameterf; glTexParameterf = f; return retval;} glTexParameterfv_t set_glTexParameterfv(glTexParameterfv_t f) { glTexParameterfv_t retval = glTexParameterfv; glTexParameterfv = f; return retval;} glTranslatef_t set_glTranslatef(glTranslatef_t f) { glTranslatef_t retval = glTranslatef; glTranslatef = f; return retval;} glActiveTexture_t set_glActiveTexture(glActiveTexture_t f) { glActiveTexture_t retval = glActiveTexture; glActiveTexture = f; return retval;} glAlphaFuncx_t set_glAlphaFuncx(glAlphaFuncx_t f) { glAlphaFuncx_t retval = glAlphaFuncx; glAlphaFuncx = f; return retval;} glBindBuffer_t set_glBindBuffer(glBindBuffer_t f) { glBindBuffer_t retval = glBindBuffer; glBindBuffer = f; return retval;} glBindTexture_t set_glBindTexture(glBindTexture_t f) { glBindTexture_t retval = glBindTexture; glBindTexture = f; return retval;} glBlendFunc_t set_glBlendFunc(glBlendFunc_t f) { glBlendFunc_t retval = glBlendFunc; glBlendFunc = f; return retval;} glBufferData_t set_glBufferData(glBufferData_t f) { glBufferData_t retval = glBufferData; glBufferData = f; return retval;} glBufferSubData_t set_glBufferSubData(glBufferSubData_t f) { glBufferSubData_t retval = glBufferSubData; glBufferSubData = f; return retval;} glClear_t set_glClear(glClear_t f) { glClear_t retval = glClear; glClear = f; return retval;} glClearColorx_t set_glClearColorx(glClearColorx_t f) { glClearColorx_t retval = glClearColorx; glClearColorx = f; return retval;} glClearDepthx_t set_glClearDepthx(glClearDepthx_t f) { glClearDepthx_t retval = glClearDepthx; glClearDepthx = f; return retval;} glClearStencil_t set_glClearStencil(glClearStencil_t f) { glClearStencil_t retval = glClearStencil; glClearStencil = f; return retval;} glClientActiveTexture_t set_glClientActiveTexture(glClientActiveTexture_t f) { glClientActiveTexture_t retval = glClientActiveTexture; glClientActiveTexture = f; return retval;} glClipPlanex_t set_glClipPlanex(glClipPlanex_t f) { glClipPlanex_t retval = glClipPlanex; glClipPlanex = f; return retval;} glColor4ub_t set_glColor4ub(glColor4ub_t f) { glColor4ub_t retval = glColor4ub; glColor4ub = f; return retval;} glColor4x_t set_glColor4x(glColor4x_t f) { glColor4x_t retval = glColor4x; glColor4x = f; return retval;} glColorMask_t set_glColorMask(glColorMask_t f) { glColorMask_t retval = glColorMask; glColorMask = f; return retval;} glColorPointer_t set_glColorPointer(glColorPointer_t f) { glColorPointer_t retval = glColorPointer; glColorPointer = f; return retval;} glCompressedTexImage2D_t set_glCompressedTexImage2D(glCompressedTexImage2D_t f) { glCompressedTexImage2D_t retval = glCompressedTexImage2D; glCompressedTexImage2D = f; return retval;} glCompressedTexSubImage2D_t set_glCompressedTexSubImage2D(glCompressedTexSubImage2D_t f) { glCompressedTexSubImage2D_t retval = glCompressedTexSubImage2D; glCompressedTexSubImage2D = f; return retval;} glCopyTexImage2D_t set_glCopyTexImage2D(glCopyTexImage2D_t f) { glCopyTexImage2D_t retval = glCopyTexImage2D; glCopyTexImage2D = f; return retval;} glCopyTexSubImage2D_t set_glCopyTexSubImage2D(glCopyTexSubImage2D_t f) { glCopyTexSubImage2D_t retval = glCopyTexSubImage2D; glCopyTexSubImage2D = f; return retval;} glCullFace_t set_glCullFace(glCullFace_t f) { glCullFace_t retval = glCullFace; glCullFace = f; return retval;} glDeleteBuffers_t set_glDeleteBuffers(glDeleteBuffers_t f) { glDeleteBuffers_t retval = glDeleteBuffers; glDeleteBuffers = f; return retval;} glDeleteTextures_t set_glDeleteTextures(glDeleteTextures_t f) { glDeleteTextures_t retval = glDeleteTextures; glDeleteTextures = f; return retval;} glDepthFunc_t set_glDepthFunc(glDepthFunc_t f) { glDepthFunc_t retval = glDepthFunc; glDepthFunc = f; return retval;} glDepthMask_t set_glDepthMask(glDepthMask_t f) { glDepthMask_t retval = glDepthMask; glDepthMask = f; return retval;} glDepthRangex_t set_glDepthRangex(glDepthRangex_t f) { glDepthRangex_t retval = glDepthRangex; glDepthRangex = f; return retval;} glDisable_t set_glDisable(glDisable_t f) { glDisable_t retval = glDisable; glDisable = f; return retval;} glDisableClientState_t set_glDisableClientState(glDisableClientState_t f) { glDisableClientState_t retval = glDisableClientState; glDisableClientState = f; return retval;} glDrawArrays_t set_glDrawArrays(glDrawArrays_t f) { glDrawArrays_t retval = glDrawArrays; glDrawArrays = f; return retval;} glDrawElements_t set_glDrawElements(glDrawElements_t f) { glDrawElements_t retval = glDrawElements; glDrawElements = f; return retval;} glEnable_t set_glEnable(glEnable_t f) { glEnable_t retval = glEnable; glEnable = f; return retval;} glEnableClientState_t set_glEnableClientState(glEnableClientState_t f) { glEnableClientState_t retval = glEnableClientState; glEnableClientState = f; return retval;} glFinish_t set_glFinish(glFinish_t f) { glFinish_t retval = glFinish; glFinish = f; return retval;} glFlush_t set_glFlush(glFlush_t f) { glFlush_t retval = glFlush; glFlush = f; return retval;} glFogx_t set_glFogx(glFogx_t f) { glFogx_t retval = glFogx; glFogx = f; return retval;} glFogxv_t set_glFogxv(glFogxv_t f) { glFogxv_t retval = glFogxv; glFogxv = f; return retval;} glFrontFace_t set_glFrontFace(glFrontFace_t f) { glFrontFace_t retval = glFrontFace; glFrontFace = f; return retval;} glFrustumx_t set_glFrustumx(glFrustumx_t f) { glFrustumx_t retval = glFrustumx; glFrustumx = f; return retval;} glGetBooleanv_t set_glGetBooleanv(glGetBooleanv_t f) { glGetBooleanv_t retval = glGetBooleanv; glGetBooleanv = f; return retval;} glGetBufferParameteriv_t set_glGetBufferParameteriv(glGetBufferParameteriv_t f) { glGetBufferParameteriv_t retval = glGetBufferParameteriv; glGetBufferParameteriv = f; return retval;} glGetClipPlanex_t set_glGetClipPlanex(glGetClipPlanex_t f) { glGetClipPlanex_t retval = glGetClipPlanex; glGetClipPlanex = f; return retval;} glGenBuffers_t set_glGenBuffers(glGenBuffers_t f) { glGenBuffers_t retval = glGenBuffers; glGenBuffers = f; return retval;} glGenTextures_t set_glGenTextures(glGenTextures_t f) { glGenTextures_t retval = glGenTextures; glGenTextures = f; return retval;} glGetError_t set_glGetError(glGetError_t f) { glGetError_t retval = glGetError; glGetError = f; return retval;} glGetFixedv_t set_glGetFixedv(glGetFixedv_t f) { glGetFixedv_t retval = glGetFixedv; glGetFixedv = f; return retval;} glGetIntegerv_t set_glGetIntegerv(glGetIntegerv_t f) { glGetIntegerv_t retval = glGetIntegerv; glGetIntegerv = f; return retval;} glGetLightxv_t set_glGetLightxv(glGetLightxv_t f) { glGetLightxv_t retval = glGetLightxv; glGetLightxv = f; return retval;} glGetMaterialxv_t set_glGetMaterialxv(glGetMaterialxv_t f) { glGetMaterialxv_t retval = glGetMaterialxv; glGetMaterialxv = f; return retval;} glGetPointerv_t set_glGetPointerv(glGetPointerv_t f) { glGetPointerv_t retval = glGetPointerv; glGetPointerv = f; return retval;} glGetString_t set_glGetString(glGetString_t f) { glGetString_t retval = glGetString; glGetString = f; return retval;} glGetTexEnviv_t set_glGetTexEnviv(glGetTexEnviv_t f) { glGetTexEnviv_t retval = glGetTexEnviv; glGetTexEnviv = f; return retval;} glGetTexEnvxv_t set_glGetTexEnvxv(glGetTexEnvxv_t f) { glGetTexEnvxv_t retval = glGetTexEnvxv; glGetTexEnvxv = f; return retval;} glGetTexParameteriv_t set_glGetTexParameteriv(glGetTexParameteriv_t f) { glGetTexParameteriv_t retval = glGetTexParameteriv; glGetTexParameteriv = f; return retval;} glGetTexParameterxv_t set_glGetTexParameterxv(glGetTexParameterxv_t f) { glGetTexParameterxv_t retval = glGetTexParameterxv; glGetTexParameterxv = f; return retval;} glHint_t set_glHint(glHint_t f) { glHint_t retval = glHint; glHint = f; return retval;} glIsBuffer_t set_glIsBuffer(glIsBuffer_t f) { glIsBuffer_t retval = glIsBuffer; glIsBuffer = f; return retval;} glIsEnabled_t set_glIsEnabled(glIsEnabled_t f) { glIsEnabled_t retval = glIsEnabled; glIsEnabled = f; return retval;} glIsTexture_t set_glIsTexture(glIsTexture_t f) { glIsTexture_t retval = glIsTexture; glIsTexture = f; return retval;} glLightModelx_t set_glLightModelx(glLightModelx_t f) { glLightModelx_t retval = glLightModelx; glLightModelx = f; return retval;} glLightModelxv_t set_glLightModelxv(glLightModelxv_t f) { glLightModelxv_t retval = glLightModelxv; glLightModelxv = f; return retval;} glLightx_t set_glLightx(glLightx_t f) { glLightx_t retval = glLightx; glLightx = f; return retval;} glLightxv_t set_glLightxv(glLightxv_t f) { glLightxv_t retval = glLightxv; glLightxv = f; return retval;} glLineWidthx_t set_glLineWidthx(glLineWidthx_t f) { glLineWidthx_t retval = glLineWidthx; glLineWidthx = f; return retval;} glLoadIdentity_t set_glLoadIdentity(glLoadIdentity_t f) { glLoadIdentity_t retval = glLoadIdentity; glLoadIdentity = f; return retval;} glLoadMatrixx_t set_glLoadMatrixx(glLoadMatrixx_t f) { glLoadMatrixx_t retval = glLoadMatrixx; glLoadMatrixx = f; return retval;} glLogicOp_t set_glLogicOp(glLogicOp_t f) { glLogicOp_t retval = glLogicOp; glLogicOp = f; return retval;} glMaterialx_t set_glMaterialx(glMaterialx_t f) { glMaterialx_t retval = glMaterialx; glMaterialx = f; return retval;} glMaterialxv_t set_glMaterialxv(glMaterialxv_t f) { glMaterialxv_t retval = glMaterialxv; glMaterialxv = f; return retval;} glMatrixMode_t set_glMatrixMode(glMatrixMode_t f) { glMatrixMode_t retval = glMatrixMode; glMatrixMode = f; return retval;} glMultMatrixx_t set_glMultMatrixx(glMultMatrixx_t f) { glMultMatrixx_t retval = glMultMatrixx; glMultMatrixx = f; return retval;} glMultiTexCoord4x_t set_glMultiTexCoord4x(glMultiTexCoord4x_t f) { glMultiTexCoord4x_t retval = glMultiTexCoord4x; glMultiTexCoord4x = f; return retval;} glNormal3x_t set_glNormal3x(glNormal3x_t f) { glNormal3x_t retval = glNormal3x; glNormal3x = f; return retval;} glNormalPointer_t set_glNormalPointer(glNormalPointer_t f) { glNormalPointer_t retval = glNormalPointer; glNormalPointer = f; return retval;} glOrthox_t set_glOrthox(glOrthox_t f) { glOrthox_t retval = glOrthox; glOrthox = f; return retval;} glPixelStorei_t set_glPixelStorei(glPixelStorei_t f) { glPixelStorei_t retval = glPixelStorei; glPixelStorei = f; return retval;} glPointParameterx_t set_glPointParameterx(glPointParameterx_t f) { glPointParameterx_t retval = glPointParameterx; glPointParameterx = f; return retval;} glPointParameterxv_t set_glPointParameterxv(glPointParameterxv_t f) { glPointParameterxv_t retval = glPointParameterxv; glPointParameterxv = f; return retval;} glPointSizex_t set_glPointSizex(glPointSizex_t f) { glPointSizex_t retval = glPointSizex; glPointSizex = f; return retval;} glPolygonOffsetx_t set_glPolygonOffsetx(glPolygonOffsetx_t f) { glPolygonOffsetx_t retval = glPolygonOffsetx; glPolygonOffsetx = f; return retval;} glPopMatrix_t set_glPopMatrix(glPopMatrix_t f) { glPopMatrix_t retval = glPopMatrix; glPopMatrix = f; return retval;} glPushMatrix_t set_glPushMatrix(glPushMatrix_t f) { glPushMatrix_t retval = glPushMatrix; glPushMatrix = f; return retval;} glReadPixels_t set_glReadPixels(glReadPixels_t f) { glReadPixels_t retval = glReadPixels; glReadPixels = f; return retval;} glRotatex_t set_glRotatex(glRotatex_t f) { glRotatex_t retval = glRotatex; glRotatex = f; return retval;} glSampleCoverage_t set_glSampleCoverage(glSampleCoverage_t f) { glSampleCoverage_t retval = glSampleCoverage; glSampleCoverage = f; return retval;} glSampleCoveragex_t set_glSampleCoveragex(glSampleCoveragex_t f) { glSampleCoveragex_t retval = glSampleCoveragex; glSampleCoveragex = f; return retval;} glScalex_t set_glScalex(glScalex_t f) { glScalex_t retval = glScalex; glScalex = f; return retval;} glScissor_t set_glScissor(glScissor_t f) { glScissor_t retval = glScissor; glScissor = f; return retval;} glShadeModel_t set_glShadeModel(glShadeModel_t f) { glShadeModel_t retval = glShadeModel; glShadeModel = f; return retval;} glStencilFunc_t set_glStencilFunc(glStencilFunc_t f) { glStencilFunc_t retval = glStencilFunc; glStencilFunc = f; return retval;} glStencilMask_t set_glStencilMask(glStencilMask_t f) { glStencilMask_t retval = glStencilMask; glStencilMask = f; return retval;} glStencilOp_t set_glStencilOp(glStencilOp_t f) { glStencilOp_t retval = glStencilOp; glStencilOp = f; return retval;} glTexCoordPointer_t set_glTexCoordPointer(glTexCoordPointer_t f) { glTexCoordPointer_t retval = glTexCoordPointer; glTexCoordPointer = f; return retval;} glTexEnvi_t set_glTexEnvi(glTexEnvi_t f) { glTexEnvi_t retval = glTexEnvi; glTexEnvi = f; return retval;} glTexEnvx_t set_glTexEnvx(glTexEnvx_t f) { glTexEnvx_t retval = glTexEnvx; glTexEnvx = f; return retval;} glTexEnviv_t set_glTexEnviv(glTexEnviv_t f) { glTexEnviv_t retval = glTexEnviv; glTexEnviv = f; return retval;} glTexEnvxv_t set_glTexEnvxv(glTexEnvxv_t f) { glTexEnvxv_t retval = glTexEnvxv; glTexEnvxv = f; return retval;} glTexImage2D_t set_glTexImage2D(glTexImage2D_t f) { glTexImage2D_t retval = glTexImage2D; glTexImage2D = f; return retval;} glTexParameteri_t set_glTexParameteri(glTexParameteri_t f) { glTexParameteri_t retval = glTexParameteri; glTexParameteri = f; return retval;} glTexParameterx_t set_glTexParameterx(glTexParameterx_t f) { glTexParameterx_t retval = glTexParameterx; glTexParameterx = f; return retval;} glTexParameteriv_t set_glTexParameteriv(glTexParameteriv_t f) { glTexParameteriv_t retval = glTexParameteriv; glTexParameteriv = f; return retval;} glTexParameterxv_t set_glTexParameterxv(glTexParameterxv_t f) { glTexParameterxv_t retval = glTexParameterxv; glTexParameterxv = f; return retval;} glTexSubImage2D_t set_glTexSubImage2D(glTexSubImage2D_t f) { glTexSubImage2D_t retval = glTexSubImage2D; glTexSubImage2D = f; return retval;} glTranslatex_t set_glTranslatex(glTranslatex_t f) { glTranslatex_t retval = glTranslatex; glTranslatex = f; return retval;} glVertexPointer_t set_glVertexPointer(glVertexPointer_t f) { glVertexPointer_t retval = glVertexPointer; glVertexPointer = f; return retval;} glViewport_t set_glViewport(glViewport_t f) { glViewport_t retval = glViewport; glViewport = f; return retval;} glPointSizePointerOES_t set_glPointSizePointerOES(glPointSizePointerOES_t f) { glPointSizePointerOES_t retval = glPointSizePointerOES; glPointSizePointerOES = f; return retval;} glBlendEquationSeparateOES_t set_glBlendEquationSeparateOES(glBlendEquationSeparateOES_t f) { glBlendEquationSeparateOES_t retval = glBlendEquationSeparateOES; glBlendEquationSeparateOES = f; return retval;} glBlendFuncSeparateOES_t set_glBlendFuncSeparateOES(glBlendFuncSeparateOES_t f) { glBlendFuncSeparateOES_t retval = glBlendFuncSeparateOES; glBlendFuncSeparateOES = f; return retval;} glBlendEquationOES_t set_glBlendEquationOES(glBlendEquationOES_t f) { glBlendEquationOES_t retval = glBlendEquationOES; glBlendEquationOES = f; return retval;} glDrawTexsOES_t set_glDrawTexsOES(glDrawTexsOES_t f) { glDrawTexsOES_t retval = glDrawTexsOES; glDrawTexsOES = f; return retval;} glDrawTexiOES_t set_glDrawTexiOES(glDrawTexiOES_t f) { glDrawTexiOES_t retval = glDrawTexiOES; glDrawTexiOES = f; return retval;} glDrawTexxOES_t set_glDrawTexxOES(glDrawTexxOES_t f) { glDrawTexxOES_t retval = glDrawTexxOES; glDrawTexxOES = f; return retval;} glDrawTexsvOES_t set_glDrawTexsvOES(glDrawTexsvOES_t f) { glDrawTexsvOES_t retval = glDrawTexsvOES; glDrawTexsvOES = f; return retval;} glDrawTexivOES_t set_glDrawTexivOES(glDrawTexivOES_t f) { glDrawTexivOES_t retval = glDrawTexivOES; glDrawTexivOES = f; return retval;} glDrawTexxvOES_t set_glDrawTexxvOES(glDrawTexxvOES_t f) { glDrawTexxvOES_t retval = glDrawTexxvOES; glDrawTexxvOES = f; return retval;} glDrawTexfOES_t set_glDrawTexfOES(glDrawTexfOES_t f) { glDrawTexfOES_t retval = glDrawTexfOES; glDrawTexfOES = f; return retval;} glDrawTexfvOES_t set_glDrawTexfvOES(glDrawTexfvOES_t f) { glDrawTexfvOES_t retval = glDrawTexfvOES; glDrawTexfvOES = f; return retval;} glEGLImageTargetTexture2DOES_t set_glEGLImageTargetTexture2DOES(glEGLImageTargetTexture2DOES_t f) { glEGLImageTargetTexture2DOES_t retval = glEGLImageTargetTexture2DOES; glEGLImageTargetTexture2DOES = f; return retval;} glEGLImageTargetRenderbufferStorageOES_t set_glEGLImageTargetRenderbufferStorageOES(glEGLImageTargetRenderbufferStorageOES_t f) { glEGLImageTargetRenderbufferStorageOES_t retval = glEGLImageTargetRenderbufferStorageOES; glEGLImageTargetRenderbufferStorageOES = f; return retval;} glAlphaFuncxOES_t set_glAlphaFuncxOES(glAlphaFuncxOES_t f) { glAlphaFuncxOES_t retval = glAlphaFuncxOES; glAlphaFuncxOES = f; return retval;} glClearColorxOES_t set_glClearColorxOES(glClearColorxOES_t f) { glClearColorxOES_t retval = glClearColorxOES; glClearColorxOES = f; return retval;} glClearDepthxOES_t set_glClearDepthxOES(glClearDepthxOES_t f) { glClearDepthxOES_t retval = glClearDepthxOES; glClearDepthxOES = f; return retval;} glClipPlanexOES_t set_glClipPlanexOES(glClipPlanexOES_t f) { glClipPlanexOES_t retval = glClipPlanexOES; glClipPlanexOES = f; return retval;} glColor4xOES_t set_glColor4xOES(glColor4xOES_t f) { glColor4xOES_t retval = glColor4xOES; glColor4xOES = f; return retval;} glDepthRangexOES_t set_glDepthRangexOES(glDepthRangexOES_t f) { glDepthRangexOES_t retval = glDepthRangexOES; glDepthRangexOES = f; return retval;} glFogxOES_t set_glFogxOES(glFogxOES_t f) { glFogxOES_t retval = glFogxOES; glFogxOES = f; return retval;} glFogxvOES_t set_glFogxvOES(glFogxvOES_t f) { glFogxvOES_t retval = glFogxvOES; glFogxvOES = f; return retval;} glFrustumxOES_t set_glFrustumxOES(glFrustumxOES_t f) { glFrustumxOES_t retval = glFrustumxOES; glFrustumxOES = f; return retval;} glGetClipPlanexOES_t set_glGetClipPlanexOES(glGetClipPlanexOES_t f) { glGetClipPlanexOES_t retval = glGetClipPlanexOES; glGetClipPlanexOES = f; return retval;} glGetFixedvOES_t set_glGetFixedvOES(glGetFixedvOES_t f) { glGetFixedvOES_t retval = glGetFixedvOES; glGetFixedvOES = f; return retval;} glGetLightxvOES_t set_glGetLightxvOES(glGetLightxvOES_t f) { glGetLightxvOES_t retval = glGetLightxvOES; glGetLightxvOES = f; return retval;} glGetMaterialxvOES_t set_glGetMaterialxvOES(glGetMaterialxvOES_t f) { glGetMaterialxvOES_t retval = glGetMaterialxvOES; glGetMaterialxvOES = f; return retval;} glGetTexEnvxvOES_t set_glGetTexEnvxvOES(glGetTexEnvxvOES_t f) { glGetTexEnvxvOES_t retval = glGetTexEnvxvOES; glGetTexEnvxvOES = f; return retval;} glGetTexParameterxvOES_t set_glGetTexParameterxvOES(glGetTexParameterxvOES_t f) { glGetTexParameterxvOES_t retval = glGetTexParameterxvOES; glGetTexParameterxvOES = f; return retval;} glLightModelxOES_t set_glLightModelxOES(glLightModelxOES_t f) { glLightModelxOES_t retval = glLightModelxOES; glLightModelxOES = f; return retval;} glLightModelxvOES_t set_glLightModelxvOES(glLightModelxvOES_t f) { glLightModelxvOES_t retval = glLightModelxvOES; glLightModelxvOES = f; return retval;} glLightxOES_t set_glLightxOES(glLightxOES_t f) { glLightxOES_t retval = glLightxOES; glLightxOES = f; return retval;} glLightxvOES_t set_glLightxvOES(glLightxvOES_t f) { glLightxvOES_t retval = glLightxvOES; glLightxvOES = f; return retval;} glLineWidthxOES_t set_glLineWidthxOES(glLineWidthxOES_t f) { glLineWidthxOES_t retval = glLineWidthxOES; glLineWidthxOES = f; return retval;} glLoadMatrixxOES_t set_glLoadMatrixxOES(glLoadMatrixxOES_t f) { glLoadMatrixxOES_t retval = glLoadMatrixxOES; glLoadMatrixxOES = f; return retval;} glMaterialxOES_t set_glMaterialxOES(glMaterialxOES_t f) { glMaterialxOES_t retval = glMaterialxOES; glMaterialxOES = f; return retval;} glMaterialxvOES_t set_glMaterialxvOES(glMaterialxvOES_t f) { glMaterialxvOES_t retval = glMaterialxvOES; glMaterialxvOES = f; return retval;} glMultMatrixxOES_t set_glMultMatrixxOES(glMultMatrixxOES_t f) { glMultMatrixxOES_t retval = glMultMatrixxOES; glMultMatrixxOES = f; return retval;} glMultiTexCoord4xOES_t set_glMultiTexCoord4xOES(glMultiTexCoord4xOES_t f) { glMultiTexCoord4xOES_t retval = glMultiTexCoord4xOES; glMultiTexCoord4xOES = f; return retval;} glNormal3xOES_t set_glNormal3xOES(glNormal3xOES_t f) { glNormal3xOES_t retval = glNormal3xOES; glNormal3xOES = f; return retval;} glOrthoxOES_t set_glOrthoxOES(glOrthoxOES_t f) { glOrthoxOES_t retval = glOrthoxOES; glOrthoxOES = f; return retval;} glPointParameterxOES_t set_glPointParameterxOES(glPointParameterxOES_t f) { glPointParameterxOES_t retval = glPointParameterxOES; glPointParameterxOES = f; return retval;} glPointParameterxvOES_t set_glPointParameterxvOES(glPointParameterxvOES_t f) { glPointParameterxvOES_t retval = glPointParameterxvOES; glPointParameterxvOES = f; return retval;} glPointSizexOES_t set_glPointSizexOES(glPointSizexOES_t f) { glPointSizexOES_t retval = glPointSizexOES; glPointSizexOES = f; return retval;} glPolygonOffsetxOES_t set_glPolygonOffsetxOES(glPolygonOffsetxOES_t f) { glPolygonOffsetxOES_t retval = glPolygonOffsetxOES; glPolygonOffsetxOES = f; return retval;} glRotatexOES_t set_glRotatexOES(glRotatexOES_t f) { glRotatexOES_t retval = glRotatexOES; glRotatexOES = f; return retval;} glSampleCoveragexOES_t set_glSampleCoveragexOES(glSampleCoveragexOES_t f) { glSampleCoveragexOES_t retval = glSampleCoveragexOES; glSampleCoveragexOES = f; return retval;} glScalexOES_t set_glScalexOES(glScalexOES_t f) { glScalexOES_t retval = glScalexOES; glScalexOES = f; return retval;} glTexEnvxOES_t set_glTexEnvxOES(glTexEnvxOES_t f) { glTexEnvxOES_t retval = glTexEnvxOES; glTexEnvxOES = f; return retval;} glTexEnvxvOES_t set_glTexEnvxvOES(glTexEnvxvOES_t f) { glTexEnvxvOES_t retval = glTexEnvxvOES; glTexEnvxvOES = f; return retval;} glTexParameterxOES_t set_glTexParameterxOES(glTexParameterxOES_t f) { glTexParameterxOES_t retval = glTexParameterxOES; glTexParameterxOES = f; return retval;} glTexParameterxvOES_t set_glTexParameterxvOES(glTexParameterxvOES_t f) { glTexParameterxvOES_t retval = glTexParameterxvOES; glTexParameterxvOES = f; return retval;} glTranslatexOES_t set_glTranslatexOES(glTranslatexOES_t f) { glTranslatexOES_t retval = glTranslatexOES; glTranslatexOES = f; return retval;} glIsRenderbufferOES_t set_glIsRenderbufferOES(glIsRenderbufferOES_t f) { glIsRenderbufferOES_t retval = glIsRenderbufferOES; glIsRenderbufferOES = f; return retval;} glBindRenderbufferOES_t set_glBindRenderbufferOES(glBindRenderbufferOES_t f) { glBindRenderbufferOES_t retval = glBindRenderbufferOES; glBindRenderbufferOES = f; return retval;} glDeleteRenderbuffersOES_t set_glDeleteRenderbuffersOES(glDeleteRenderbuffersOES_t f) { glDeleteRenderbuffersOES_t retval = glDeleteRenderbuffersOES; glDeleteRenderbuffersOES = f; return retval;} glGenRenderbuffersOES_t set_glGenRenderbuffersOES(glGenRenderbuffersOES_t f) { glGenRenderbuffersOES_t retval = glGenRenderbuffersOES; glGenRenderbuffersOES = f; return retval;} glRenderbufferStorageOES_t set_glRenderbufferStorageOES(glRenderbufferStorageOES_t f) { glRenderbufferStorageOES_t retval = glRenderbufferStorageOES; glRenderbufferStorageOES = f; return retval;} glGetRenderbufferParameterivOES_t set_glGetRenderbufferParameterivOES(glGetRenderbufferParameterivOES_t f) { glGetRenderbufferParameterivOES_t retval = glGetRenderbufferParameterivOES; glGetRenderbufferParameterivOES = f; return retval;} glIsFramebufferOES_t set_glIsFramebufferOES(glIsFramebufferOES_t f) { glIsFramebufferOES_t retval = glIsFramebufferOES; glIsFramebufferOES = f; return retval;} glBindFramebufferOES_t set_glBindFramebufferOES(glBindFramebufferOES_t f) { glBindFramebufferOES_t retval = glBindFramebufferOES; glBindFramebufferOES = f; return retval;} glDeleteFramebuffersOES_t set_glDeleteFramebuffersOES(glDeleteFramebuffersOES_t f) { glDeleteFramebuffersOES_t retval = glDeleteFramebuffersOES; glDeleteFramebuffersOES = f; return retval;} glGenFramebuffersOES_t set_glGenFramebuffersOES(glGenFramebuffersOES_t f) { glGenFramebuffersOES_t retval = glGenFramebuffersOES; glGenFramebuffersOES = f; return retval;} glCheckFramebufferStatusOES_t set_glCheckFramebufferStatusOES(glCheckFramebufferStatusOES_t f) { glCheckFramebufferStatusOES_t retval = glCheckFramebufferStatusOES; glCheckFramebufferStatusOES = f; return retval;} glFramebufferRenderbufferOES_t set_glFramebufferRenderbufferOES(glFramebufferRenderbufferOES_t f) { glFramebufferRenderbufferOES_t retval = glFramebufferRenderbufferOES; glFramebufferRenderbufferOES = f; return retval;} glFramebufferTexture2DOES_t set_glFramebufferTexture2DOES(glFramebufferTexture2DOES_t f) { glFramebufferTexture2DOES_t retval = glFramebufferTexture2DOES; glFramebufferTexture2DOES = f; return retval;} glGetFramebufferAttachmentParameterivOES_t set_glGetFramebufferAttachmentParameterivOES(glGetFramebufferAttachmentParameterivOES_t f) { glGetFramebufferAttachmentParameterivOES_t retval = glGetFramebufferAttachmentParameterivOES; glGetFramebufferAttachmentParameterivOES = f; return retval;} glGenerateMipmapOES_t set_glGenerateMipmapOES(glGenerateMipmapOES_t f) { glGenerateMipmapOES_t retval = glGenerateMipmapOES; glGenerateMipmapOES = f; return retval;} glMapBufferOES_t set_glMapBufferOES(glMapBufferOES_t f) { glMapBufferOES_t retval = glMapBufferOES; glMapBufferOES = f; return retval;} glUnmapBufferOES_t set_glUnmapBufferOES(glUnmapBufferOES_t f) { glUnmapBufferOES_t retval = glUnmapBufferOES; glUnmapBufferOES = f; return retval;} glGetBufferPointervOES_t set_glGetBufferPointervOES(glGetBufferPointervOES_t f) { glGetBufferPointervOES_t retval = glGetBufferPointervOES; glGetBufferPointervOES = f; return retval;} glCurrentPaletteMatrixOES_t set_glCurrentPaletteMatrixOES(glCurrentPaletteMatrixOES_t f) { glCurrentPaletteMatrixOES_t retval = glCurrentPaletteMatrixOES; glCurrentPaletteMatrixOES = f; return retval;} glLoadPaletteFromModelViewMatrixOES_t set_glLoadPaletteFromModelViewMatrixOES(glLoadPaletteFromModelViewMatrixOES_t f) { glLoadPaletteFromModelViewMatrixOES_t retval = glLoadPaletteFromModelViewMatrixOES; glLoadPaletteFromModelViewMatrixOES = f; return retval;} glMatrixIndexPointerOES_t set_glMatrixIndexPointerOES(glMatrixIndexPointerOES_t f) { glMatrixIndexPointerOES_t retval = glMatrixIndexPointerOES; glMatrixIndexPointerOES = f; return retval;} glWeightPointerOES_t set_glWeightPointerOES(glWeightPointerOES_t f) { glWeightPointerOES_t retval = glWeightPointerOES; glWeightPointerOES = f; return retval;} glQueryMatrixxOES_t set_glQueryMatrixxOES(glQueryMatrixxOES_t f) { glQueryMatrixxOES_t retval = glQueryMatrixxOES; glQueryMatrixxOES = f; return retval;} glDepthRangefOES_t set_glDepthRangefOES(glDepthRangefOES_t f) { glDepthRangefOES_t retval = glDepthRangefOES; glDepthRangefOES = f; return retval;} glFrustumfOES_t set_glFrustumfOES(glFrustumfOES_t f) { glFrustumfOES_t retval = glFrustumfOES; glFrustumfOES = f; return retval;} glOrthofOES_t set_glOrthofOES(glOrthofOES_t f) { glOrthofOES_t retval = glOrthofOES; glOrthofOES = f; return retval;} glClipPlanefOES_t set_glClipPlanefOES(glClipPlanefOES_t f) { glClipPlanefOES_t retval = glClipPlanefOES; glClipPlanefOES = f; return retval;} glGetClipPlanefOES_t set_glGetClipPlanefOES(glGetClipPlanefOES_t f) { glGetClipPlanefOES_t retval = glGetClipPlanefOES; glGetClipPlanefOES = f; return retval;} glClearDepthfOES_t set_glClearDepthfOES(glClearDepthfOES_t f) { glClearDepthfOES_t retval = glClearDepthfOES; glClearDepthfOES = f; return retval;} glTexGenfOES_t set_glTexGenfOES(glTexGenfOES_t f) { glTexGenfOES_t retval = glTexGenfOES; glTexGenfOES = f; return retval;} glTexGenfvOES_t set_glTexGenfvOES(glTexGenfvOES_t f) { glTexGenfvOES_t retval = glTexGenfvOES; glTexGenfvOES = f; return retval;} glTexGeniOES_t set_glTexGeniOES(glTexGeniOES_t f) { glTexGeniOES_t retval = glTexGeniOES; glTexGeniOES = f; return retval;} glTexGenivOES_t set_glTexGenivOES(glTexGenivOES_t f) { glTexGenivOES_t retval = glTexGenivOES; glTexGenivOES = f; return retval;} glTexGenxOES_t set_glTexGenxOES(glTexGenxOES_t f) { glTexGenxOES_t retval = glTexGenxOES; glTexGenxOES = f; return retval;} glTexGenxvOES_t set_glTexGenxvOES(glTexGenxvOES_t f) { glTexGenxvOES_t retval = glTexGenxvOES; glTexGenxvOES = f; return retval;} glGetTexGenfvOES_t set_glGetTexGenfvOES(glGetTexGenfvOES_t f) { glGetTexGenfvOES_t retval = glGetTexGenfvOES; glGetTexGenfvOES = f; return retval;} glGetTexGenivOES_t set_glGetTexGenivOES(glGetTexGenivOES_t f) { glGetTexGenivOES_t retval = glGetTexGenivOES; glGetTexGenivOES = f; return retval;} glGetTexGenxvOES_t set_glGetTexGenxvOES(glGetTexGenxvOES_t f) { glGetTexGenxvOES_t retval = glGetTexGenxvOES; glGetTexGenxvOES = f; return retval;} glBindVertexArrayOES_t set_glBindVertexArrayOES(glBindVertexArrayOES_t f) { glBindVertexArrayOES_t retval = glBindVertexArrayOES; glBindVertexArrayOES = f; return retval;} glDeleteVertexArraysOES_t set_glDeleteVertexArraysOES(glDeleteVertexArraysOES_t f) { glDeleteVertexArraysOES_t retval = glDeleteVertexArraysOES; glDeleteVertexArraysOES = f; return retval;} glGenVertexArraysOES_t set_glGenVertexArraysOES(glGenVertexArraysOES_t f) { glGenVertexArraysOES_t retval = glGenVertexArraysOES; glGenVertexArraysOES = f; return retval;} glIsVertexArrayOES_t set_glIsVertexArrayOES(glIsVertexArrayOES_t f) { glIsVertexArrayOES_t retval = glIsVertexArrayOES; glIsVertexArrayOES = f; return retval;} glDiscardFramebufferEXT_t set_glDiscardFramebufferEXT(glDiscardFramebufferEXT_t f) { glDiscardFramebufferEXT_t retval = glDiscardFramebufferEXT; glDiscardFramebufferEXT = f; return retval;} glMultiDrawArraysEXT_t set_glMultiDrawArraysEXT(glMultiDrawArraysEXT_t f) { glMultiDrawArraysEXT_t retval = glMultiDrawArraysEXT; glMultiDrawArraysEXT = f; return retval;} glMultiDrawElementsEXT_t set_glMultiDrawElementsEXT(glMultiDrawElementsEXT_t f) { glMultiDrawElementsEXT_t retval = glMultiDrawElementsEXT; glMultiDrawElementsEXT = f; return retval;} glClipPlanefIMG_t set_glClipPlanefIMG(glClipPlanefIMG_t f) { glClipPlanefIMG_t retval = glClipPlanefIMG; glClipPlanefIMG = f; return retval;} glClipPlanexIMG_t set_glClipPlanexIMG(glClipPlanexIMG_t f) { glClipPlanexIMG_t retval = glClipPlanexIMG; glClipPlanexIMG = f; return retval;} glRenderbufferStorageMultisampleIMG_t set_glRenderbufferStorageMultisampleIMG(glRenderbufferStorageMultisampleIMG_t f) { glRenderbufferStorageMultisampleIMG_t retval = glRenderbufferStorageMultisampleIMG; glRenderbufferStorageMultisampleIMG = f; return retval;} glFramebufferTexture2DMultisampleIMG_t set_glFramebufferTexture2DMultisampleIMG(glFramebufferTexture2DMultisampleIMG_t f) { glFramebufferTexture2DMultisampleIMG_t retval = glFramebufferTexture2DMultisampleIMG; glFramebufferTexture2DMultisampleIMG = f; return retval;} glDeleteFencesNV_t set_glDeleteFencesNV(glDeleteFencesNV_t f) { glDeleteFencesNV_t retval = glDeleteFencesNV; glDeleteFencesNV = f; return retval;} glGenFencesNV_t set_glGenFencesNV(glGenFencesNV_t f) { glGenFencesNV_t retval = glGenFencesNV; glGenFencesNV = f; return retval;} glIsFenceNV_t set_glIsFenceNV(glIsFenceNV_t f) { glIsFenceNV_t retval = glIsFenceNV; glIsFenceNV = f; return retval;} glTestFenceNV_t set_glTestFenceNV(glTestFenceNV_t f) { glTestFenceNV_t retval = glTestFenceNV; glTestFenceNV = f; return retval;} glGetFenceivNV_t set_glGetFenceivNV(glGetFenceivNV_t f) { glGetFenceivNV_t retval = glGetFenceivNV; glGetFenceivNV = f; return retval;} glFinishFenceNV_t set_glFinishFenceNV(glFinishFenceNV_t f) { glFinishFenceNV_t retval = glFinishFenceNV; glFinishFenceNV = f; return retval;} glSetFenceNV_t set_glSetFenceNV(glSetFenceNV_t f) { glSetFenceNV_t retval = glSetFenceNV; glSetFenceNV = f; return retval;} glGetDriverControlsQCOM_t set_glGetDriverControlsQCOM(glGetDriverControlsQCOM_t f) { glGetDriverControlsQCOM_t retval = glGetDriverControlsQCOM; glGetDriverControlsQCOM = f; return retval;} glGetDriverControlStringQCOM_t set_glGetDriverControlStringQCOM(glGetDriverControlStringQCOM_t f) { glGetDriverControlStringQCOM_t retval = glGetDriverControlStringQCOM; glGetDriverControlStringQCOM = f; return retval;} glEnableDriverControlQCOM_t set_glEnableDriverControlQCOM(glEnableDriverControlQCOM_t f) { glEnableDriverControlQCOM_t retval = glEnableDriverControlQCOM; glEnableDriverControlQCOM = f; return retval;} glDisableDriverControlQCOM_t set_glDisableDriverControlQCOM(glDisableDriverControlQCOM_t f) { glDisableDriverControlQCOM_t retval = glDisableDriverControlQCOM; glDisableDriverControlQCOM = f; return retval;} glExtGetTexturesQCOM_t set_glExtGetTexturesQCOM(glExtGetTexturesQCOM_t f) { glExtGetTexturesQCOM_t retval = glExtGetTexturesQCOM; glExtGetTexturesQCOM = f; return retval;} glExtGetBuffersQCOM_t set_glExtGetBuffersQCOM(glExtGetBuffersQCOM_t f) { glExtGetBuffersQCOM_t retval = glExtGetBuffersQCOM; glExtGetBuffersQCOM = f; return retval;} glExtGetRenderbuffersQCOM_t set_glExtGetRenderbuffersQCOM(glExtGetRenderbuffersQCOM_t f) { glExtGetRenderbuffersQCOM_t retval = glExtGetRenderbuffersQCOM; glExtGetRenderbuffersQCOM = f; return retval;} glExtGetFramebuffersQCOM_t set_glExtGetFramebuffersQCOM(glExtGetFramebuffersQCOM_t f) { glExtGetFramebuffersQCOM_t retval = glExtGetFramebuffersQCOM; glExtGetFramebuffersQCOM = f; return retval;} glExtGetTexLevelParameterivQCOM_t set_glExtGetTexLevelParameterivQCOM(glExtGetTexLevelParameterivQCOM_t f) { glExtGetTexLevelParameterivQCOM_t retval = glExtGetTexLevelParameterivQCOM; glExtGetTexLevelParameterivQCOM = f; return retval;} glExtTexObjectStateOverrideiQCOM_t set_glExtTexObjectStateOverrideiQCOM(glExtTexObjectStateOverrideiQCOM_t f) { glExtTexObjectStateOverrideiQCOM_t retval = glExtTexObjectStateOverrideiQCOM; glExtTexObjectStateOverrideiQCOM = f; return retval;} glExtGetTexSubImageQCOM_t set_glExtGetTexSubImageQCOM(glExtGetTexSubImageQCOM_t f) { glExtGetTexSubImageQCOM_t retval = glExtGetTexSubImageQCOM; glExtGetTexSubImageQCOM = f; return retval;} glExtGetBufferPointervQCOM_t set_glExtGetBufferPointervQCOM(glExtGetBufferPointervQCOM_t f) { glExtGetBufferPointervQCOM_t retval = glExtGetBufferPointervQCOM; glExtGetBufferPointervQCOM = f; return retval;} glExtGetShadersQCOM_t set_glExtGetShadersQCOM(glExtGetShadersQCOM_t f) { glExtGetShadersQCOM_t retval = glExtGetShadersQCOM; glExtGetShadersQCOM = f; return retval;} glExtGetProgramsQCOM_t set_glExtGetProgramsQCOM(glExtGetProgramsQCOM_t f) { glExtGetProgramsQCOM_t retval = glExtGetProgramsQCOM; glExtGetProgramsQCOM = f; return retval;} glExtIsProgramBinaryQCOM_t set_glExtIsProgramBinaryQCOM(glExtIsProgramBinaryQCOM_t f) { glExtIsProgramBinaryQCOM_t retval = glExtIsProgramBinaryQCOM; glExtIsProgramBinaryQCOM = f; return retval;} glExtGetProgramBinarySourceQCOM_t set_glExtGetProgramBinarySourceQCOM(glExtGetProgramBinarySourceQCOM_t f) { glExtGetProgramBinarySourceQCOM_t retval = glExtGetProgramBinarySourceQCOM; glExtGetProgramBinarySourceQCOM = f; return retval;} glStartTilingQCOM_t set_glStartTilingQCOM(glStartTilingQCOM_t f) { glStartTilingQCOM_t retval = glStartTilingQCOM; glStartTilingQCOM = f; return retval;} glEndTilingQCOM_t set_glEndTilingQCOM(glEndTilingQCOM_t f) { glEndTilingQCOM_t retval = glEndTilingQCOM; glEndTilingQCOM = f; return retval;} }; gles_dispatch *create_gles_dispatch(void *gles_andorid); #endif anbox-0.0~git20191115/android/opengl/tests/gles_android_wrapper/gles_emul.cfg000066400000000000000000000001771356361734700271270ustar00rootroot00000000000000angeles my-tritex org.zeroxlab.benchmark com.cooliris.media com.polarbit.waveblazerlite test-opengl-gl2_basic com.trendy.ddapp anbox-0.0~git20191115/android/opengl/tests/gles_android_wrapper/gles_ftable.h000066400000000000000000000343611356361734700271140ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ static struct _gles_funcs_by_name { const char *name; void *proc; } gles_funcs_by_name[] = { {"glAlphaFunc", (void *)glAlphaFunc}, {"glClearColor", (void *)glClearColor}, {"glClearDepthf", (void *)glClearDepthf}, {"glClipPlanef", (void *)glClipPlanef}, {"glColor4f", (void *)glColor4f}, {"glDepthRangef", (void *)glDepthRangef}, {"glFogf", (void *)glFogf}, {"glFogfv", (void *)glFogfv}, {"glFrustumf", (void *)glFrustumf}, {"glGetClipPlanef", (void *)glGetClipPlanef}, {"glGetFloatv", (void *)glGetFloatv}, {"glGetLightfv", (void *)glGetLightfv}, {"glGetMaterialfv", (void *)glGetMaterialfv}, {"glGetTexEnvfv", (void *)glGetTexEnvfv}, {"glGetTexParameterfv", (void *)glGetTexParameterfv}, {"glLightModelf", (void *)glLightModelf}, {"glLightModelfv", (void *)glLightModelfv}, {"glLightf", (void *)glLightf}, {"glLightfv", (void *)glLightfv}, {"glLineWidth", (void *)glLineWidth}, {"glLoadMatrixf", (void *)glLoadMatrixf}, {"glMaterialf", (void *)glMaterialf}, {"glMaterialfv", (void *)glMaterialfv}, {"glMultMatrixf", (void *)glMultMatrixf}, {"glMultiTexCoord4f", (void *)glMultiTexCoord4f}, {"glNormal3f", (void *)glNormal3f}, {"glOrthof", (void *)glOrthof}, {"glPointParameterf", (void *)glPointParameterf}, {"glPointParameterfv", (void *)glPointParameterfv}, {"glPointSize", (void *)glPointSize}, {"glPolygonOffset", (void *)glPolygonOffset}, {"glRotatef", (void *)glRotatef}, {"glScalef", (void *)glScalef}, {"glTexEnvf", (void *)glTexEnvf}, {"glTexEnvfv", (void *)glTexEnvfv}, {"glTexParameterf", (void *)glTexParameterf}, {"glTexParameterfv", (void *)glTexParameterfv}, {"glTranslatef", (void *)glTranslatef}, {"glActiveTexture", (void *)glActiveTexture}, {"glAlphaFuncx", (void *)glAlphaFuncx}, {"glBindBuffer", (void *)glBindBuffer}, {"glBindTexture", (void *)glBindTexture}, {"glBlendFunc", (void *)glBlendFunc}, {"glBufferData", (void *)glBufferData}, {"glBufferSubData", (void *)glBufferSubData}, {"glClear", (void *)glClear}, {"glClearColorx", (void *)glClearColorx}, {"glClearDepthx", (void *)glClearDepthx}, {"glClearStencil", (void *)glClearStencil}, {"glClientActiveTexture", (void *)glClientActiveTexture}, {"glClipPlanex", (void *)glClipPlanex}, {"glColor4ub", (void *)glColor4ub}, {"glColor4x", (void *)glColor4x}, {"glColorMask", (void *)glColorMask}, {"glColorPointer", (void *)glColorPointer}, {"glCompressedTexImage2D", (void *)glCompressedTexImage2D}, {"glCompressedTexSubImage2D", (void *)glCompressedTexSubImage2D}, {"glCopyTexImage2D", (void *)glCopyTexImage2D}, {"glCopyTexSubImage2D", (void *)glCopyTexSubImage2D}, {"glCullFace", (void *)glCullFace}, {"glDeleteBuffers", (void *)glDeleteBuffers}, {"glDeleteTextures", (void *)glDeleteTextures}, {"glDepthFunc", (void *)glDepthFunc}, {"glDepthMask", (void *)glDepthMask}, {"glDepthRangex", (void *)glDepthRangex}, {"glDisable", (void *)glDisable}, {"glDisableClientState", (void *)glDisableClientState}, {"glDrawArrays", (void *)glDrawArrays}, {"glDrawElements", (void *)glDrawElements}, {"glEnable", (void *)glEnable}, {"glEnableClientState", (void *)glEnableClientState}, {"glFinish", (void *)glFinish}, {"glFlush", (void *)glFlush}, {"glFogx", (void *)glFogx}, {"glFogxv", (void *)glFogxv}, {"glFrontFace", (void *)glFrontFace}, {"glFrustumx", (void *)glFrustumx}, {"glGetBooleanv", (void *)glGetBooleanv}, {"glGetBufferParameteriv", (void *)glGetBufferParameteriv}, {"glGetClipPlanex", (void *)glGetClipPlanex}, {"glGenBuffers", (void *)glGenBuffers}, {"glGenTextures", (void *)glGenTextures}, {"glGetError", (void *)glGetError}, {"glGetFixedv", (void *)glGetFixedv}, {"glGetIntegerv", (void *)glGetIntegerv}, {"glGetLightxv", (void *)glGetLightxv}, {"glGetMaterialxv", (void *)glGetMaterialxv}, {"glGetPointerv", (void *)glGetPointerv}, {"glGetString", (void *)glGetString}, {"glGetTexEnviv", (void *)glGetTexEnviv}, {"glGetTexEnvxv", (void *)glGetTexEnvxv}, {"glGetTexParameteriv", (void *)glGetTexParameteriv}, {"glGetTexParameterxv", (void *)glGetTexParameterxv}, {"glHint", (void *)glHint}, {"glIsBuffer", (void *)glIsBuffer}, {"glIsEnabled", (void *)glIsEnabled}, {"glIsTexture", (void *)glIsTexture}, {"glLightModelx", (void *)glLightModelx}, {"glLightModelxv", (void *)glLightModelxv}, {"glLightx", (void *)glLightx}, {"glLightxv", (void *)glLightxv}, {"glLineWidthx", (void *)glLineWidthx}, {"glLoadIdentity", (void *)glLoadIdentity}, {"glLoadMatrixx", (void *)glLoadMatrixx}, {"glLogicOp", (void *)glLogicOp}, {"glMaterialx", (void *)glMaterialx}, {"glMaterialxv", (void *)glMaterialxv}, {"glMatrixMode", (void *)glMatrixMode}, {"glMultMatrixx", (void *)glMultMatrixx}, {"glMultiTexCoord4x", (void *)glMultiTexCoord4x}, {"glNormal3x", (void *)glNormal3x}, {"glNormalPointer", (void *)glNormalPointer}, {"glOrthox", (void *)glOrthox}, {"glPixelStorei", (void *)glPixelStorei}, {"glPointParameterx", (void *)glPointParameterx}, {"glPointParameterxv", (void *)glPointParameterxv}, {"glPointSizex", (void *)glPointSizex}, {"glPolygonOffsetx", (void *)glPolygonOffsetx}, {"glPopMatrix", (void *)glPopMatrix}, {"glPushMatrix", (void *)glPushMatrix}, {"glReadPixels", (void *)glReadPixels}, {"glRotatex", (void *)glRotatex}, {"glSampleCoverage", (void *)glSampleCoverage}, {"glSampleCoveragex", (void *)glSampleCoveragex}, {"glScalex", (void *)glScalex}, {"glScissor", (void *)glScissor}, {"glShadeModel", (void *)glShadeModel}, {"glStencilFunc", (void *)glStencilFunc}, {"glStencilMask", (void *)glStencilMask}, {"glStencilOp", (void *)glStencilOp}, {"glTexCoordPointer", (void *)glTexCoordPointer}, {"glTexEnvi", (void *)glTexEnvi}, {"glTexEnvx", (void *)glTexEnvx}, {"glTexEnviv", (void *)glTexEnviv}, {"glTexEnvxv", (void *)glTexEnvxv}, {"glTexImage2D", (void *)glTexImage2D}, {"glTexParameteri", (void *)glTexParameteri}, {"glTexParameterx", (void *)glTexParameterx}, {"glTexParameteriv", (void *)glTexParameteriv}, {"glTexParameterxv", (void *)glTexParameterxv}, {"glTexSubImage2D", (void *)glTexSubImage2D}, {"glTranslatex", (void *)glTranslatex}, {"glVertexPointer", (void *)glVertexPointer}, {"glViewport", (void *)glViewport}, {"glPointSizePointerOES", (void *)glPointSizePointerOES}, {"glBlendEquationSeparateOES", (void *)glBlendEquationSeparateOES}, {"glBlendFuncSeparateOES", (void *)glBlendFuncSeparateOES}, {"glBlendEquationOES", (void *)glBlendEquationOES}, {"glDrawTexsOES", (void *)glDrawTexsOES}, {"glDrawTexiOES", (void *)glDrawTexiOES}, {"glDrawTexxOES", (void *)glDrawTexxOES}, {"glDrawTexsvOES", (void *)glDrawTexsvOES}, {"glDrawTexivOES", (void *)glDrawTexivOES}, {"glDrawTexxvOES", (void *)glDrawTexxvOES}, {"glDrawTexfOES", (void *)glDrawTexfOES}, {"glDrawTexfvOES", (void *)glDrawTexfvOES}, {"glEGLImageTargetTexture2DOES", (void *)glEGLImageTargetTexture2DOES}, {"glEGLImageTargetRenderbufferStorageOES", (void *)glEGLImageTargetRenderbufferStorageOES}, {"glAlphaFuncxOES", (void *)glAlphaFuncxOES}, {"glClearColorxOES", (void *)glClearColorxOES}, {"glClearDepthxOES", (void *)glClearDepthxOES}, {"glClipPlanexOES", (void *)glClipPlanexOES}, {"glColor4xOES", (void *)glColor4xOES}, {"glDepthRangexOES", (void *)glDepthRangexOES}, {"glFogxOES", (void *)glFogxOES}, {"glFogxvOES", (void *)glFogxvOES}, {"glFrustumxOES", (void *)glFrustumxOES}, {"glGetClipPlanexOES", (void *)glGetClipPlanexOES}, {"glGetFixedvOES", (void *)glGetFixedvOES}, {"glGetLightxvOES", (void *)glGetLightxvOES}, {"glGetMaterialxvOES", (void *)glGetMaterialxvOES}, {"glGetTexEnvxvOES", (void *)glGetTexEnvxvOES}, {"glGetTexParameterxvOES", (void *)glGetTexParameterxvOES}, {"glLightModelxOES", (void *)glLightModelxOES}, {"glLightModelxvOES", (void *)glLightModelxvOES}, {"glLightxOES", (void *)glLightxOES}, {"glLightxvOES", (void *)glLightxvOES}, {"glLineWidthxOES", (void *)glLineWidthxOES}, {"glLoadMatrixxOES", (void *)glLoadMatrixxOES}, {"glMaterialxOES", (void *)glMaterialxOES}, {"glMaterialxvOES", (void *)glMaterialxvOES}, {"glMultMatrixxOES", (void *)glMultMatrixxOES}, {"glMultiTexCoord4xOES", (void *)glMultiTexCoord4xOES}, {"glNormal3xOES", (void *)glNormal3xOES}, {"glOrthoxOES", (void *)glOrthoxOES}, {"glPointParameterxOES", (void *)glPointParameterxOES}, {"glPointParameterxvOES", (void *)glPointParameterxvOES}, {"glPointSizexOES", (void *)glPointSizexOES}, {"glPolygonOffsetxOES", (void *)glPolygonOffsetxOES}, {"glRotatexOES", (void *)glRotatexOES}, {"glSampleCoveragexOES", (void *)glSampleCoveragexOES}, {"glScalexOES", (void *)glScalexOES}, {"glTexEnvxOES", (void *)glTexEnvxOES}, {"glTexEnvxvOES", (void *)glTexEnvxvOES}, {"glTexParameterxOES", (void *)glTexParameterxOES}, {"glTexParameterxvOES", (void *)glTexParameterxvOES}, {"glTranslatexOES", (void *)glTranslatexOES}, {"glIsRenderbufferOES", (void *)glIsRenderbufferOES}, {"glBindRenderbufferOES", (void *)glBindRenderbufferOES}, {"glDeleteRenderbuffersOES", (void *)glDeleteRenderbuffersOES}, {"glGenRenderbuffersOES", (void *)glGenRenderbuffersOES}, {"glRenderbufferStorageOES", (void *)glRenderbufferStorageOES}, {"glGetRenderbufferParameterivOES", (void *)glGetRenderbufferParameterivOES}, {"glIsFramebufferOES", (void *)glIsFramebufferOES}, {"glBindFramebufferOES", (void *)glBindFramebufferOES}, {"glDeleteFramebuffersOES", (void *)glDeleteFramebuffersOES}, {"glGenFramebuffersOES", (void *)glGenFramebuffersOES}, {"glCheckFramebufferStatusOES", (void *)glCheckFramebufferStatusOES}, {"glFramebufferRenderbufferOES", (void *)glFramebufferRenderbufferOES}, {"glFramebufferTexture2DOES", (void *)glFramebufferTexture2DOES}, {"glGetFramebufferAttachmentParameterivOES", (void *)glGetFramebufferAttachmentParameterivOES}, {"glGenerateMipmapOES", (void *)glGenerateMipmapOES}, {"glMapBufferOES", (void *)glMapBufferOES}, {"glUnmapBufferOES", (void *)glUnmapBufferOES}, {"glGetBufferPointervOES", (void *)glGetBufferPointervOES}, {"glCurrentPaletteMatrixOES", (void *)glCurrentPaletteMatrixOES}, {"glLoadPaletteFromModelViewMatrixOES", (void *)glLoadPaletteFromModelViewMatrixOES}, {"glMatrixIndexPointerOES", (void *)glMatrixIndexPointerOES}, {"glWeightPointerOES", (void *)glWeightPointerOES}, {"glQueryMatrixxOES", (void *)glQueryMatrixxOES}, {"glDepthRangefOES", (void *)glDepthRangefOES}, {"glFrustumfOES", (void *)glFrustumfOES}, {"glOrthofOES", (void *)glOrthofOES}, {"glClipPlanefOES", (void *)glClipPlanefOES}, {"glGetClipPlanefOES", (void *)glGetClipPlanefOES}, {"glClearDepthfOES", (void *)glClearDepthfOES}, {"glTexGenfOES", (void *)glTexGenfOES}, {"glTexGenfvOES", (void *)glTexGenfvOES}, {"glTexGeniOES", (void *)glTexGeniOES}, {"glTexGenivOES", (void *)glTexGenivOES}, {"glTexGenxOES", (void *)glTexGenxOES}, {"glTexGenxvOES", (void *)glTexGenxvOES}, {"glGetTexGenfvOES", (void *)glGetTexGenfvOES}, {"glGetTexGenivOES", (void *)glGetTexGenivOES}, {"glGetTexGenxvOES", (void *)glGetTexGenxvOES}, {"glBindVertexArrayOES", (void *)glBindVertexArrayOES}, {"glDeleteVertexArraysOES", (void *)glDeleteVertexArraysOES}, {"glGenVertexArraysOES", (void *)glGenVertexArraysOES}, {"glIsVertexArrayOES", (void *)glIsVertexArrayOES}, {"glDiscardFramebufferEXT", (void *)glDiscardFramebufferEXT}, {"glMultiDrawArraysEXT", (void *)glMultiDrawArraysEXT}, {"glMultiDrawElementsEXT", (void *)glMultiDrawElementsEXT}, {"glClipPlanefIMG", (void *)glClipPlanefIMG}, {"glClipPlanexIMG", (void *)glClipPlanexIMG}, {"glRenderbufferStorageMultisampleIMG", (void *)glRenderbufferStorageMultisampleIMG}, {"glFramebufferTexture2DMultisampleIMG", (void *)glFramebufferTexture2DMultisampleIMG}, {"glDeleteFencesNV", (void *)glDeleteFencesNV}, {"glGenFencesNV", (void *)glGenFencesNV}, {"glIsFenceNV", (void *)glIsFenceNV}, {"glTestFenceNV", (void *)glTestFenceNV}, {"glGetFenceivNV", (void *)glGetFenceivNV}, {"glFinishFenceNV", (void *)glFinishFenceNV}, {"glSetFenceNV", (void *)glSetFenceNV}, {"glGetDriverControlsQCOM", (void *)glGetDriverControlsQCOM}, {"glGetDriverControlStringQCOM", (void *)glGetDriverControlStringQCOM}, {"glEnableDriverControlQCOM", (void *)glEnableDriverControlQCOM}, {"glDisableDriverControlQCOM", (void *)glDisableDriverControlQCOM}, {"glExtGetTexturesQCOM", (void *)glExtGetTexturesQCOM}, {"glExtGetBuffersQCOM", (void *)glExtGetBuffersQCOM}, {"glExtGetRenderbuffersQCOM", (void *)glExtGetRenderbuffersQCOM}, {"glExtGetFramebuffersQCOM", (void *)glExtGetFramebuffersQCOM}, {"glExtGetTexLevelParameterivQCOM", (void *)glExtGetTexLevelParameterivQCOM}, {"glExtTexObjectStateOverrideiQCOM", (void *)glExtTexObjectStateOverrideiQCOM}, {"glExtGetTexSubImageQCOM", (void *)glExtGetTexSubImageQCOM}, {"glExtGetBufferPointervQCOM", (void *)glExtGetBufferPointervQCOM}, {"glExtGetShadersQCOM", (void *)glExtGetShadersQCOM}, {"glExtGetProgramsQCOM", (void *)glExtGetProgramsQCOM}, {"glExtIsProgramBinaryQCOM", (void *)glExtIsProgramBinaryQCOM}, {"glExtGetProgramBinarySourceQCOM", (void *)glExtGetProgramBinarySourceQCOM}, {"glStartTilingQCOM", (void *)glStartTilingQCOM}, {"glEndTilingQCOM", (void *)glEndTilingQCOM} }; static int gles_num_funcs = sizeof(gles_funcs_by_name) / sizeof(struct _gles_funcs_by_name); anbox-0.0~git20191115/android/opengl/tests/gles_android_wrapper/gles_proc.h000066400000000000000000000423621356361734700266220ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _GLES_PROC_H #define _GLES_PROC_H #include #define GL_GLEXT_PROTOTYPES #include typedef void (* glAlphaFunc_t) (GLenum, GLclampf); typedef void (* glClearColor_t) (GLclampf, GLclampf, GLclampf, GLclampf); typedef void (* glClearDepthf_t) (GLclampf); typedef void (* glClipPlanef_t) (GLenum, const GLfloat*); typedef void (* glColor4f_t) (GLfloat, GLfloat, GLfloat, GLfloat); typedef void (* glDepthRangef_t) (GLclampf, GLclampf); typedef void (* glFogf_t) (GLenum, GLfloat); typedef void (* glFogfv_t) (GLenum, const GLfloat*); typedef void (* glFrustumf_t) (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); typedef void (* glGetClipPlanef_t) (GLenum, GLfloat*); typedef void (* glGetFloatv_t) (GLenum, GLfloat*); typedef void (* glGetLightfv_t) (GLenum, GLenum, GLfloat*); typedef void (* glGetMaterialfv_t) (GLenum, GLenum, GLfloat*); typedef void (* glGetTexEnvfv_t) (GLenum, GLenum, GLfloat*); typedef void (* glGetTexParameterfv_t) (GLenum, GLenum, GLfloat*); typedef void (* glLightModelf_t) (GLenum, GLfloat); typedef void (* glLightModelfv_t) (GLenum, const GLfloat*); typedef void (* glLightf_t) (GLenum, GLenum, GLfloat); typedef void (* glLightfv_t) (GLenum, GLenum, const GLfloat*); typedef void (* glLineWidth_t) (GLfloat); typedef void (* glLoadMatrixf_t) (const GLfloat*); typedef void (* glMaterialf_t) (GLenum, GLenum, GLfloat); typedef void (* glMaterialfv_t) (GLenum, GLenum, const GLfloat*); typedef void (* glMultMatrixf_t) (const GLfloat*); typedef void (* glMultiTexCoord4f_t) (GLenum, GLfloat, GLfloat, GLfloat, GLfloat); typedef void (* glNormal3f_t) (GLfloat, GLfloat, GLfloat); typedef void (* glOrthof_t) (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); typedef void (* glPointParameterf_t) (GLenum, GLfloat); typedef void (* glPointParameterfv_t) (GLenum, const GLfloat*); typedef void (* glPointSize_t) (GLfloat); typedef void (* glPolygonOffset_t) (GLfloat, GLfloat); typedef void (* glRotatef_t) (GLfloat, GLfloat, GLfloat, GLfloat); typedef void (* glScalef_t) (GLfloat, GLfloat, GLfloat); typedef void (* glTexEnvf_t) (GLenum, GLenum, GLfloat); typedef void (* glTexEnvfv_t) (GLenum, GLenum, const GLfloat*); typedef void (* glTexParameterf_t) (GLenum, GLenum, GLfloat); typedef void (* glTexParameterfv_t) (GLenum, GLenum, const GLfloat*); typedef void (* glTranslatef_t) (GLfloat, GLfloat, GLfloat); typedef void (* glActiveTexture_t) (GLenum); typedef void (* glAlphaFuncx_t) (GLenum, GLclampx); typedef void (* glBindBuffer_t) (GLenum, GLuint); typedef void (* glBindTexture_t) (GLenum, GLuint); typedef void (* glBlendFunc_t) (GLenum, GLenum); typedef void (* glBufferData_t) (GLenum, GLsizeiptr, const GLvoid*, GLenum); typedef void (* glBufferSubData_t) (GLenum, GLintptr, GLsizeiptr, const GLvoid*); typedef void (* glClear_t) (GLbitfield); typedef void (* glClearColorx_t) (GLclampx, GLclampx, GLclampx, GLclampx); typedef void (* glClearDepthx_t) (GLclampx); typedef void (* glClearStencil_t) (GLint); typedef void (* glClientActiveTexture_t) (GLenum); typedef void (* glClipPlanex_t) (GLenum, const GLfixed*); typedef void (* glColor4ub_t) (GLubyte, GLubyte, GLubyte, GLubyte); typedef void (* glColor4x_t) (GLfixed, GLfixed, GLfixed, GLfixed); typedef void (* glColorMask_t) (GLboolean, GLboolean, GLboolean, GLboolean); typedef void (* glColorPointer_t) (GLint, GLenum, GLsizei, const GLvoid*); typedef void (* glCompressedTexImage2D_t) (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid*); typedef void (* glCompressedTexSubImage2D_t) (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid*); typedef void (* glCopyTexImage2D_t) (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint); typedef void (* glCopyTexSubImage2D_t) (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei); typedef void (* glCullFace_t) (GLenum); typedef void (* glDeleteBuffers_t) (GLsizei, const GLuint*); typedef void (* glDeleteTextures_t) (GLsizei, const GLuint*); typedef void (* glDepthFunc_t) (GLenum); typedef void (* glDepthMask_t) (GLboolean); typedef void (* glDepthRangex_t) (GLclampx, GLclampx); typedef void (* glDisable_t) (GLenum); typedef void (* glDisableClientState_t) (GLenum); typedef void (* glDrawArrays_t) (GLenum, GLint, GLsizei); typedef void (* glDrawElements_t) (GLenum, GLsizei, GLenum, const GLvoid*); typedef void (* glEnable_t) (GLenum); typedef void (* glEnableClientState_t) (GLenum); typedef void (* glFinish_t) (); typedef void (* glFlush_t) (); typedef void (* glFogx_t) (GLenum, GLfixed); typedef void (* glFogxv_t) (GLenum, const GLfixed*); typedef void (* glFrontFace_t) (GLenum); typedef void (* glFrustumx_t) (GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed); typedef void (* glGetBooleanv_t) (GLenum, GLboolean*); typedef void (* glGetBufferParameteriv_t) (GLenum, GLenum, GLint*); typedef void (* glGetClipPlanex_t) (GLenum, GLfixed*); typedef void (* glGenBuffers_t) (GLsizei, GLuint*); typedef void (* glGenTextures_t) (GLsizei, GLuint*); typedef GLenum (* glGetError_t) (); typedef void (* glGetFixedv_t) (GLenum, GLfixed*); typedef void (* glGetIntegerv_t) (GLenum, GLint*); typedef void (* glGetLightxv_t) (GLenum, GLenum, GLfixed*); typedef void (* glGetMaterialxv_t) (GLenum, GLenum, GLfixed*); typedef void (* glGetPointerv_t) (GLenum, GLvoid**); typedef const GLubyte* (* glGetString_t) (GLenum); typedef void (* glGetTexEnviv_t) (GLenum, GLenum, GLint*); typedef void (* glGetTexEnvxv_t) (GLenum, GLenum, GLfixed*); typedef void (* glGetTexParameteriv_t) (GLenum, GLenum, GLint*); typedef void (* glGetTexParameterxv_t) (GLenum, GLenum, GLfixed*); typedef void (* glHint_t) (GLenum, GLenum); typedef GLboolean (* glIsBuffer_t) (GLuint); typedef GLboolean (* glIsEnabled_t) (GLenum); typedef GLboolean (* glIsTexture_t) (GLuint); typedef void (* glLightModelx_t) (GLenum, GLfixed); typedef void (* glLightModelxv_t) (GLenum, const GLfixed*); typedef void (* glLightx_t) (GLenum, GLenum, GLfixed); typedef void (* glLightxv_t) (GLenum, GLenum, const GLfixed*); typedef void (* glLineWidthx_t) (GLfixed); typedef void (* glLoadIdentity_t) (); typedef void (* glLoadMatrixx_t) (const GLfixed*); typedef void (* glLogicOp_t) (GLenum); typedef void (* glMaterialx_t) (GLenum, GLenum, GLfixed); typedef void (* glMaterialxv_t) (GLenum, GLenum, const GLfixed*); typedef void (* glMatrixMode_t) (GLenum); typedef void (* glMultMatrixx_t) (const GLfixed*); typedef void (* glMultiTexCoord4x_t) (GLenum, GLfixed, GLfixed, GLfixed, GLfixed); typedef void (* glNormal3x_t) (GLfixed, GLfixed, GLfixed); typedef void (* glNormalPointer_t) (GLenum, GLsizei, const GLvoid*); typedef void (* glOrthox_t) (GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed); typedef void (* glPixelStorei_t) (GLenum, GLint); typedef void (* glPointParameterx_t) (GLenum, GLfixed); typedef void (* glPointParameterxv_t) (GLenum, const GLfixed*); typedef void (* glPointSizex_t) (GLfixed); typedef void (* glPolygonOffsetx_t) (GLfixed, GLfixed); typedef void (* glPopMatrix_t) (); typedef void (* glPushMatrix_t) (); typedef void (* glReadPixels_t) (GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid*); typedef void (* glRotatex_t) (GLfixed, GLfixed, GLfixed, GLfixed); typedef void (* glSampleCoverage_t) (GLclampf, GLboolean); typedef void (* glSampleCoveragex_t) (GLclampx, GLboolean); typedef void (* glScalex_t) (GLfixed, GLfixed, GLfixed); typedef void (* glScissor_t) (GLint, GLint, GLsizei, GLsizei); typedef void (* glShadeModel_t) (GLenum); typedef void (* glStencilFunc_t) (GLenum, GLint, GLuint); typedef void (* glStencilMask_t) (GLuint); typedef void (* glStencilOp_t) (GLenum, GLenum, GLenum); typedef void (* glTexCoordPointer_t) (GLint, GLenum, GLsizei, const GLvoid*); typedef void (* glTexEnvi_t) (GLenum, GLenum, GLint); typedef void (* glTexEnvx_t) (GLenum, GLenum, GLfixed); typedef void (* glTexEnviv_t) (GLenum, GLenum, const GLint*); typedef void (* glTexEnvxv_t) (GLenum, GLenum, const GLfixed*); typedef void (* glTexImage2D_t) (GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid*); typedef void (* glTexParameteri_t) (GLenum, GLenum, GLint); typedef void (* glTexParameterx_t) (GLenum, GLenum, GLfixed); typedef void (* glTexParameteriv_t) (GLenum, GLenum, const GLint*); typedef void (* glTexParameterxv_t) (GLenum, GLenum, const GLfixed*); typedef void (* glTexSubImage2D_t) (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid*); typedef void (* glTranslatex_t) (GLfixed, GLfixed, GLfixed); typedef void (* glVertexPointer_t) (GLint, GLenum, GLsizei, const GLvoid*); typedef void (* glViewport_t) (GLint, GLint, GLsizei, GLsizei); typedef void (* glPointSizePointerOES_t) (GLenum, GLsizei, const GLvoid*); typedef void (* glBlendEquationSeparateOES_t) (GLenum, GLenum); typedef void (* glBlendFuncSeparateOES_t) (GLenum, GLenum, GLenum, GLenum); typedef void (* glBlendEquationOES_t) (GLenum); typedef void (* glDrawTexsOES_t) (GLshort, GLshort, GLshort, GLshort, GLshort); typedef void (* glDrawTexiOES_t) (GLint, GLint, GLint, GLint, GLint); typedef void (* glDrawTexxOES_t) (GLfixed, GLfixed, GLfixed, GLfixed, GLfixed); typedef void (* glDrawTexsvOES_t) (const GLshort*); typedef void (* glDrawTexivOES_t) (const GLint*); typedef void (* glDrawTexxvOES_t) (const GLfixed*); typedef void (* glDrawTexfOES_t) (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); typedef void (* glDrawTexfvOES_t) (const GLfloat*); typedef void (* glEGLImageTargetTexture2DOES_t) (GLenum, GLeglImageOES); typedef void (* glEGLImageTargetRenderbufferStorageOES_t) (GLenum, GLeglImageOES); typedef void (* glAlphaFuncxOES_t) (GLenum, GLclampx); typedef void (* glClearColorxOES_t) (GLclampx, GLclampx, GLclampx, GLclampx); typedef void (* glClearDepthxOES_t) (GLclampx); typedef void (* glClipPlanexOES_t) (GLenum, const GLfixed*); typedef void (* glColor4xOES_t) (GLfixed, GLfixed, GLfixed, GLfixed); typedef void (* glDepthRangexOES_t) (GLclampx, GLclampx); typedef void (* glFogxOES_t) (GLenum, GLfixed); typedef void (* glFogxvOES_t) (GLenum, const GLfixed*); typedef void (* glFrustumxOES_t) (GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed); typedef void (* glGetClipPlanexOES_t) (GLenum, GLfixed*); typedef void (* glGetFixedvOES_t) (GLenum, GLfixed*); typedef void (* glGetLightxvOES_t) (GLenum, GLenum, GLfixed*); typedef void (* glGetMaterialxvOES_t) (GLenum, GLenum, GLfixed*); typedef void (* glGetTexEnvxvOES_t) (GLenum, GLenum, GLfixed*); typedef void (* glGetTexParameterxvOES_t) (GLenum, GLenum, GLfixed*); typedef void (* glLightModelxOES_t) (GLenum, GLfixed); typedef void (* glLightModelxvOES_t) (GLenum, const GLfixed*); typedef void (* glLightxOES_t) (GLenum, GLenum, GLfixed); typedef void (* glLightxvOES_t) (GLenum, GLenum, const GLfixed*); typedef void (* glLineWidthxOES_t) (GLfixed); typedef void (* glLoadMatrixxOES_t) (const GLfixed*); typedef void (* glMaterialxOES_t) (GLenum, GLenum, GLfixed); typedef void (* glMaterialxvOES_t) (GLenum, GLenum, const GLfixed*); typedef void (* glMultMatrixxOES_t) (const GLfixed*); typedef void (* glMultiTexCoord4xOES_t) (GLenum, GLfixed, GLfixed, GLfixed, GLfixed); typedef void (* glNormal3xOES_t) (GLfixed, GLfixed, GLfixed); typedef void (* glOrthoxOES_t) (GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed); typedef void (* glPointParameterxOES_t) (GLenum, GLfixed); typedef void (* glPointParameterxvOES_t) (GLenum, const GLfixed*); typedef void (* glPointSizexOES_t) (GLfixed); typedef void (* glPolygonOffsetxOES_t) (GLfixed, GLfixed); typedef void (* glRotatexOES_t) (GLfixed, GLfixed, GLfixed, GLfixed); typedef void (* glSampleCoveragexOES_t) (GLclampx, GLboolean); typedef void (* glScalexOES_t) (GLfixed, GLfixed, GLfixed); typedef void (* glTexEnvxOES_t) (GLenum, GLenum, GLfixed); typedef void (* glTexEnvxvOES_t) (GLenum, GLenum, const GLfixed*); typedef void (* glTexParameterxOES_t) (GLenum, GLenum, GLfixed); typedef void (* glTexParameterxvOES_t) (GLenum, GLenum, const GLfixed*); typedef void (* glTranslatexOES_t) (GLfixed, GLfixed, GLfixed); typedef GLboolean (* glIsRenderbufferOES_t) (GLuint); typedef void (* glBindRenderbufferOES_t) (GLenum, GLuint); typedef void (* glDeleteRenderbuffersOES_t) (GLsizei, const GLuint*); typedef void (* glGenRenderbuffersOES_t) (GLsizei, GLuint*); typedef void (* glRenderbufferStorageOES_t) (GLenum, GLenum, GLsizei, GLsizei); typedef void (* glGetRenderbufferParameterivOES_t) (GLenum, GLenum, GLint*); typedef GLboolean (* glIsFramebufferOES_t) (GLuint); typedef void (* glBindFramebufferOES_t) (GLenum, GLuint); typedef void (* glDeleteFramebuffersOES_t) (GLsizei, const GLuint*); typedef void (* glGenFramebuffersOES_t) (GLsizei, GLuint*); typedef GLenum (* glCheckFramebufferStatusOES_t) (GLenum); typedef void (* glFramebufferRenderbufferOES_t) (GLenum, GLenum, GLenum, GLuint); typedef void (* glFramebufferTexture2DOES_t) (GLenum, GLenum, GLenum, GLuint, GLint); typedef void (* glGetFramebufferAttachmentParameterivOES_t) (GLenum, GLenum, GLenum, GLint*); typedef void (* glGenerateMipmapOES_t) (GLenum); typedef void* (* glMapBufferOES_t) (GLenum, GLenum); typedef GLboolean (* glUnmapBufferOES_t) (GLenum); typedef void (* glGetBufferPointervOES_t) (GLenum, GLenum, GLvoid*); typedef void (* glCurrentPaletteMatrixOES_t) (GLuint); typedef void (* glLoadPaletteFromModelViewMatrixOES_t) (); typedef void (* glMatrixIndexPointerOES_t) (GLint, GLenum, GLsizei, const GLvoid*); typedef void (* glWeightPointerOES_t) (GLint, GLenum, GLsizei, const GLvoid*); typedef GLbitfield (* glQueryMatrixxOES_t) (GLfixed*, GLint*); typedef void (* glDepthRangefOES_t) (GLclampf, GLclampf); typedef void (* glFrustumfOES_t) (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); typedef void (* glOrthofOES_t) (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); typedef void (* glClipPlanefOES_t) (GLenum, const GLfloat*); typedef void (* glGetClipPlanefOES_t) (GLenum, GLfloat*); typedef void (* glClearDepthfOES_t) (GLclampf); typedef void (* glTexGenfOES_t) (GLenum, GLenum, GLfloat); typedef void (* glTexGenfvOES_t) (GLenum, GLenum, const GLfloat*); typedef void (* glTexGeniOES_t) (GLenum, GLenum, GLint); typedef void (* glTexGenivOES_t) (GLenum, GLenum, const GLint*); typedef void (* glTexGenxOES_t) (GLenum, GLenum, GLfixed); typedef void (* glTexGenxvOES_t) (GLenum, GLenum, const GLfixed*); typedef void (* glGetTexGenfvOES_t) (GLenum, GLenum, GLfloat*); typedef void (* glGetTexGenivOES_t) (GLenum, GLenum, GLint*); typedef void (* glGetTexGenxvOES_t) (GLenum, GLenum, GLfixed*); typedef void (* glBindVertexArrayOES_t) (GLuint); typedef void (* glDeleteVertexArraysOES_t) (GLsizei, const GLuint*); typedef void (* glGenVertexArraysOES_t) (GLsizei, GLuint*); typedef GLboolean (* glIsVertexArrayOES_t) (GLuint); typedef void (* glDiscardFramebufferEXT_t) (GLenum, GLsizei, const GLenum*); typedef void (* glMultiDrawArraysEXT_t) (GLenum, GLint*, GLsizei*, GLsizei); typedef void (* glMultiDrawElementsEXT_t) (GLenum, const GLsizei*, GLenum, const GLvoid**, GLsizei); typedef void (* glClipPlanefIMG_t) (GLenum, const GLfloat*); typedef void (* glClipPlanexIMG_t) (GLenum, const GLfixed*); typedef void (* glRenderbufferStorageMultisampleIMG_t) (GLenum, GLsizei, GLenum, GLsizei, GLsizei); typedef void (* glFramebufferTexture2DMultisampleIMG_t) (GLenum, GLenum, GLenum, GLuint, GLint, GLsizei); typedef void (* glDeleteFencesNV_t) (GLsizei, const GLuint*); typedef void (* glGenFencesNV_t) (GLsizei, GLuint*); typedef GLboolean (* glIsFenceNV_t) (GLuint); typedef GLboolean (* glTestFenceNV_t) (GLuint); typedef void (* glGetFenceivNV_t) (GLuint, GLenum, GLint*); typedef void (* glFinishFenceNV_t) (GLuint); typedef void (* glSetFenceNV_t) (GLuint, GLenum); typedef void (* glGetDriverControlsQCOM_t) (GLint*, GLsizei, GLuint*); typedef void (* glGetDriverControlStringQCOM_t) (GLuint, GLsizei, GLsizei*, GLchar*); typedef void (* glEnableDriverControlQCOM_t) (GLuint); typedef void (* glDisableDriverControlQCOM_t) (GLuint); typedef void (* glExtGetTexturesQCOM_t) (GLuint*, GLint, GLint*); typedef void (* glExtGetBuffersQCOM_t) (GLuint*, GLint, GLint*); typedef void (* glExtGetRenderbuffersQCOM_t) (GLuint*, GLint, GLint*); typedef void (* glExtGetFramebuffersQCOM_t) (GLuint*, GLint, GLint*); typedef void (* glExtGetTexLevelParameterivQCOM_t) (GLuint, GLenum, GLint, GLenum, GLint*); typedef void (* glExtTexObjectStateOverrideiQCOM_t) (GLenum, GLenum, GLint); typedef void (* glExtGetTexSubImageQCOM_t) (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLvoid*); typedef void (* glExtGetBufferPointervQCOM_t) (GLenum, GLvoid**); typedef void (* glExtGetShadersQCOM_t) (GLuint*, GLint, GLint*); typedef void (* glExtGetProgramsQCOM_t) (GLuint*, GLint, GLint*); typedef GLboolean (* glExtIsProgramBinaryQCOM_t) (GLuint); typedef void (* glExtGetProgramBinarySourceQCOM_t) (GLuint, GLenum, GLchar*, GLint*); typedef void (* glStartTilingQCOM_t) (GLuint, GLuint, GLuint, GLuint, GLbitfield); typedef void (* glEndTilingQCOM_t) (GLbitfield); #endif anbox-0.0~git20191115/android/opengl/tests/gles_android_wrapper/glesv1_emul_ifc.cpp000066400000000000000000000023171356361734700302400ustar00rootroot00000000000000/* * Copyright 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include "ApiInitializer.h" #include #include "gl_wrapper_context.h" extern "C" { gl_wrapper_context_t *createFromLib(void *solib, gl_wrapper_context_t *(*accessor)()); } gl_wrapper_context_t * createFromLib(void *solib, gl_wrapper_context_t *(accessor)()) { gl_wrapper_context_t *ctx = new gl_wrapper_context_t; if (ctx == NULL) { return NULL; } ApiInitializer *initializer = new ApiInitializer(solib); ctx->initDispatchByName(ApiInitializer::s_getProc, initializer); gl_wrapper_context_t::setContextAccessor(accessor); delete initializer; return ctx; } anbox-0.0~git20191115/android/opengl/tests/gles_android_wrapper/glesv2_emul_ifc.cpp000066400000000000000000000023311356361734700302350ustar00rootroot00000000000000/* * Copyright 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include "ApiInitializer.h" #include #include "gl2_wrapper_context.h" extern "C" { gl2_wrapper_context_t *createFromLib(void *solib, gl2_wrapper_context_t *(*accessor)()); } gl2_wrapper_context_t * createFromLib(void *solib, gl2_wrapper_context_t *(*accessor)()) { gl2_wrapper_context_t *ctx = new gl2_wrapper_context_t; if (ctx == NULL) { return NULL; } ApiInitializer *initializer = new ApiInitializer(solib); ctx->initDispatchByName(ApiInitializer::s_getProc, initializer); gl2_wrapper_context_t::setContextAccessor(accessor); delete initializer; return ctx; } anbox-0.0~git20191115/android/opengl/tests/ut_rendercontrol_enc/000077500000000000000000000000001356361734700245105ustar00rootroot00000000000000anbox-0.0~git20191115/android/opengl/tests/ut_rendercontrol_enc/Android.mk000066400000000000000000000004041356361734700264170ustar00rootroot00000000000000LOCAL_PATH := $(call my-dir) $(call emugl-begin-shared-library,libut_rendercontrol_enc) $(call emugl-import,libOpenglCodecCommon) $(call emugl-gen-encoder,$(LOCAL_PATH),ut_rendercontrol) $(call emugl-export,C_INCLUDES,$(LOCAL_PATH)) $(call emugl-end-module) anbox-0.0~git20191115/android/opengl/tests/ut_rendercontrol_enc/ut_rendercontrol.attrib000066400000000000000000000000671356361734700313120ustar00rootroot00000000000000GLOBAL base_opcode 10000 encoder_headers anbox-0.0~git20191115/android/opengl/tests/ut_rendercontrol_enc/ut_rendercontrol.in000066400000000000000000000007031356361734700304300ustar00rootroot00000000000000GL_ENTRY(int, createContext, uint32_t pid, uint32_t handle, uint32_t shareCtx, int version) GL_ENTRY(int, createSurface, uint32_t pid, uint32_t handle) GL_ENTRY(int, makeCurrentContext, uint32_t pid, uint32_t drawSurface, uint32_t readSurface, uint32_t ctxHandle) GL_ENTRY(void, swapBuffers, uint32_t pid, uint32_t surface) GL_ENTRY(int, destroyContext, uint32_t pid, uint32_t handle) GL_ENTRY(int, destroySurface, uint32_t pid, uint32_t handle) anbox-0.0~git20191115/android/opengl/tests/ut_rendercontrol_enc/ut_rendercontrol.types000066400000000000000000000000321356361734700311610ustar00rootroot00000000000000uint32_t 32 0x%08x false anbox-0.0~git20191115/android/opengl/tests/ut_rendercontrol_enc/ut_rendercontrol_types.h000066400000000000000000000011561356361734700315000ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include anbox-0.0~git20191115/android/power/000077500000000000000000000000001356361734700170015ustar00rootroot00000000000000anbox-0.0~git20191115/android/power/Android.mk000066400000000000000000000017171356361734700207200ustar00rootroot00000000000000# Copyright (C) 2012 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. LOCAL_PATH := $(call my-dir) # HAL module implemenation stored in # hw/..so include $(CLEAR_VARS) LOCAL_MODULE_RELATIVE_PATH := hw LOCAL_CFLAGS += -DQEMU_HARDWARE LOCAL_SHARED_LIBRARIES := liblog libcutils LOCAL_SRC_FILES := power_qemu.c LOCAL_MODULE := power.goldfish LOCAL_MODULE_TAGS := optional include $(BUILD_SHARED_LIBRARY) anbox-0.0~git20191115/android/power/power_qemu.c000066400000000000000000000034731356361734700213370ustar00rootroot00000000000000/* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define LOG_TAG "emulator PowerHAL" #include #include #include #include #include #include static int qemud_fd; static void power_qemu_init(struct power_module *module) { qemud_fd = qemud_channel_open("hw-control"); if (qemud_fd < 0) ALOGE("Error connecting to qemud hw-control service\n"); } static void power_qemu_set_interactive(struct power_module *module, int on) { int r; r = qemud_channel_send(qemud_fd, on ? "power:screen_state:wake" : "power:screen_state:standby", -1); if (r < 0) ALOGE("Error sending power command to qemud hw-control service\n"); } static struct hw_module_methods_t power_qemu_module_methods = { .open = NULL, }; struct power_module HAL_MODULE_INFO_SYM = { .common = { .tag = HARDWARE_MODULE_TAG, .version_major = 1, .version_minor = 0, .id = POWER_HARDWARE_MODULE_ID, .name = "Emulator Power HAL", .author = "The Android Open Source Project", .methods = &power_qemu_module_methods, }, .init = power_qemu_init, .setInteractive = power_qemu_set_interactive, }; anbox-0.0~git20191115/android/qemu-props/000077500000000000000000000000001356361734700177555ustar00rootroot00000000000000anbox-0.0~git20191115/android/qemu-props/Android.mk000066400000000000000000000020031356361734700216610ustar00rootroot00000000000000# Copyright (C) 2009 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # this file is used to build emulator-specific program tools # that should only run in the emulator. # LOCAL_PATH := $(call my-dir) # The 'qemu-props' program is run from /system/etc/init.goldfish.rc # to setup various system properties sent by the emulator program. # include $(CLEAR_VARS) LOCAL_MODULE := qemu-props LOCAL_SRC_FILES := qemu-props.c LOCAL_SHARED_LIBRARIES := libcutils liblog include $(BUILD_EXECUTABLE) anbox-0.0~git20191115/android/qemu-props/qemu-props.c000066400000000000000000000061311356361734700222320ustar00rootroot00000000000000/* * Copyright (C) 2009 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* this program is used to read a set of system properties and their values * from the emulator program and set them in the currently-running emulated * system. It does so by connecting to the 'boot-properties' qemud service. * * This program should be run as root and called from * /system/etc/init.goldfish.rc exclusively. */ #define LOG_TAG "qemu-props" #define DEBUG 1 #if DEBUG # include # define DD(...) ALOGI(__VA_ARGS__) #else # define DD(...) ((void)0) #endif #include #include #include /* Name of the qemud service we want to connect to. */ #define QEMUD_SERVICE "boot-properties" #define MAX_TRIES 5 int main(void) { int qemud_fd, count = 0; /* try to connect to the qemud service */ { int tries = MAX_TRIES; while (1) { qemud_fd = qemud_channel_open( "boot-properties" ); if (qemud_fd >= 0) break; if (--tries <= 0) { DD("Could not connect after too many tries. Aborting"); return 1; } DD("waiting 1s to wait for qemud."); sleep(1); } } DD("connected to '%s' qemud service.", QEMUD_SERVICE); /* send the 'list' command to the service */ if (qemud_channel_send(qemud_fd, "list", -1) < 0) { DD("could not send command to '%s' service", QEMUD_SERVICE); return 1; } /* read each system property as a single line from the service, * until exhaustion. */ for (;;) { #define BUFF_SIZE (PROPERTY_KEY_MAX + PROPERTY_VALUE_MAX + 2) DD("receiving.."); char* q; char temp[BUFF_SIZE]; int len = qemud_channel_recv(qemud_fd, temp, sizeof temp - 1); /* lone NUL-byte signals end of properties */ if (len < 0 || len > BUFF_SIZE-1 || temp[0] == '\0') break; temp[len] = '\0'; /* zero-terminate string */ DD("received: %.*s", len, temp); /* separate propery name from value */ q = strchr(temp, '='); if (q == NULL) { DD("invalid format, ignored."); continue; } *q++ = '\0'; if (property_set(temp, q) < 0) { DD("could not set property '%s' to '%s'", temp, q); } else { count += 1; } } /* finally, close the channel and exit */ close(qemud_fd); DD("exiting (%d properties set).", count); return 0; } anbox-0.0~git20191115/android/qemud/000077500000000000000000000000001356361734700167605ustar00rootroot00000000000000anbox-0.0~git20191115/android/qemud/Android.mk000066400000000000000000000006321356361734700206720ustar00rootroot00000000000000# Copyright 2008 The Android Open Source Project # We're moving the emulator-specific platform libs to # development.git/tools/emulator/. The following test is to ensure # smooth builds even if the tree contains both versions. # LOCAL_PATH:= $(call my-dir) include $(CLEAR_VARS) LOCAL_SRC_FILES:= \ qemud.c LOCAL_SHARED_LIBRARIES := \ libcutils liblog LOCAL_MODULE:= qemud include $(BUILD_EXECUTABLE) anbox-0.0~git20191115/android/qemud/qemud.c000066400000000000000000001226441356361734700202500ustar00rootroot00000000000000#include #include #include #include #include #include #include #include #include #include #include #include /* * the qemud daemon program is only used within Android as a bridge * between the emulator program and the emulated system. it really works as * a simple stream multiplexer that works as follows: * * - qemud is started by init following instructions in * /system/etc/init.goldfish.rc (i.e. it is never started on real devices) * * - qemud communicates with the emulator program through a single serial * port, whose name is passed through a kernel boot parameter * (e.g. android.qemud=ttyS1) * * - qemud binds one unix local stream socket (/dev/socket/qemud, created * by init through /system/etc/init.goldfish.rc). * * * emulator <==serial==> qemud <---> /dev/socket/qemud <-+--> client1 * | * +--> client2 * * - the special channel index 0 is used by the emulator and qemud only. * other channel numbers correspond to clients. More specifically, * connection are created like this: * * * the client connects to /dev/socket/qemud * * * the client sends the service name through the socket, as * * * * qemud creates a "Client" object internally, assigns it an * internal unique channel number > 0, then sends a connection * initiation request to the emulator (i.e. through channel 0): * * connect:: * * where is the service name, and is a 2-hexchar * number corresponding to the channel number. * * * in case of success, the emulator responds through channel 0 * with: * * ok:connect: * * after this, all messages between the client and the emulator * are passed in pass-through mode. * * * if the emulator refuses the service connection, it will * send the following through channel 0: * * ko:connect::reason-for-failure * * * If the client closes the connection, qemud sends the following * to the emulator: * * disconnect: * * The same message is the opposite direction if the emulator * chooses to close the connection. * * * any command sent through channel 0 to the emulator that is * not properly recognized will be answered by: * * ko:unknown command * * * Internally, the daemon maintains a "Client" object for each client * connection (i.e. accepting socket connection). */ /* name of the single control socket used by the daemon */ #define CONTROL_SOCKET_NAME "qemud" #define DEBUG 0 #define T_ACTIVE 0 /* set to 1 to dump traffic */ #if DEBUG # define LOG_TAG "qemud" # include # define D(...) ALOGD(__VA_ARGS__) #else # define D(...) ((void)0) # define T(...) ((void)0) #endif #if T_ACTIVE # define T(...) D(__VA_ARGS__) #else # define T(...) ((void)0) #endif /** UTILITIES **/ static void fatal( const char* fmt, ... ) { va_list args; va_start(args, fmt); fprintf(stderr, "PANIC: "); vfprintf(stderr, fmt, args); fprintf(stderr, "\n" ); va_end(args); exit(1); } static void* xalloc( size_t sz ) { void* p; if (sz == 0) return NULL; p = malloc(sz); if (p == NULL) fatal( "not enough memory" ); return p; } #define xnew(p) (p) = xalloc(sizeof(*(p))) static void* xalloc0( size_t sz ) { void* p = xalloc(sz); memset( p, 0, sz ); return p; } #define xnew0(p) (p) = xalloc0(sizeof(*(p))) #define xfree(p) (free((p)), (p) = NULL) static void* xrealloc( void* block, size_t size ) { void* p = realloc( block, size ); if (p == NULL && size > 0) fatal( "not enough memory" ); return p; } #define xrenew(p,count) (p) = xrealloc((p),sizeof(*(p))*(count)) static int hex2int( const uint8_t* data, int len ) { int result = 0; while (len > 0) { int c = *data++; unsigned d; result <<= 4; do { d = (unsigned)(c - '0'); if (d < 10) break; d = (unsigned)(c - 'a'); if (d < 6) { d += 10; break; } d = (unsigned)(c - 'A'); if (d < 6) { d += 10; break; } return -1; } while (0); result |= d; len -= 1; } return result; } static void int2hex( int value, uint8_t* to, int width ) { int nn = 0; static const char hexchars[16] = "0123456789abcdef"; for ( --width; width >= 0; width--, nn++ ) { to[nn] = hexchars[(value >> (width*4)) & 15]; } } static int fd_read(int fd, void* to, int len) { int ret; do { ret = read(fd, to, len); } while (ret < 0 && errno == EINTR); return ret; } static int fd_write(int fd, const void* from, int len) { int ret; do { ret = write(fd, from, len); } while (ret < 0 && errno == EINTR); return ret; } static void fd_setnonblock(int fd) { int ret, flags; do { flags = fcntl(fd, F_GETFD); } while (flags < 0 && errno == EINTR); if (flags < 0) { fatal( "%s: could not get flags for fd %d: %s", __FUNCTION__, fd, strerror(errno) ); } do { ret = fcntl(fd, F_SETFD, flags | O_NONBLOCK); } while (ret < 0 && errno == EINTR); if (ret < 0) { fatal( "%s: could not set fd %d to non-blocking: %s", __FUNCTION__, fd, strerror(errno) ); } } static int fd_accept(int fd) { struct sockaddr from; socklen_t fromlen = sizeof(from); int ret; do { ret = accept(fd, &from, &fromlen); } while (ret < 0 && errno == EINTR); return ret; } /** FD EVENT LOOP **/ /* A Looper object is used to monitor activity on one or more * file descriptors (e.g sockets). * * - call looper_add() to register a function that will be * called when events happen on the file descriptor. * * - call looper_enable() or looper_disable() to enable/disable * the set of monitored events for a given file descriptor. * * - call looper_del() to unregister a file descriptor. * this does *not* close the file descriptor. * * Note that you can only provide a single function to handle * all events related to a given file descriptor. * You can call looper_enable/_disable/_del within a function * callback. */ /* the current implementation uses Linux's epoll facility * the event mask we use are simply combinations of EPOLLIN * EPOLLOUT, EPOLLHUP and EPOLLERR */ #include #define MAX_CHANNELS 16 #define MAX_EVENTS (MAX_CHANNELS+1) /* each channel + the serial fd */ /* the event handler function type, 'user' is a user-specific * opaque pointer passed to looper_add(). */ typedef void (*EventFunc)( void* user, int events ); /* bit flags for the LoopHook structure. * * HOOK_PENDING means that an event happened on the * corresponding file descriptor. * * HOOK_CLOSING is used to delay-close monitored * file descriptors. */ enum { HOOK_PENDING = (1 << 0), HOOK_CLOSING = (1 << 1), }; /* A LoopHook structure is used to monitor a given * file descriptor and record its event handler. */ typedef struct { int fd; int wanted; /* events we are monitoring */ int events; /* events that occured */ int state; /* see HOOK_XXX constants */ void* ev_user; /* user-provided handler parameter */ EventFunc ev_func; /* event handler callback */ } LoopHook; /* Looper is the main object modeling a looper object */ typedef struct { int epoll_fd; int num_fds; int max_fds; struct epoll_event* events; LoopHook* hooks; } Looper; /* initialize a looper object */ static void looper_init( Looper* l ) { l->epoll_fd = epoll_create(4); l->num_fds = 0; l->max_fds = 0; l->events = NULL; l->hooks = NULL; } /* finalize a looper object */ static void looper_done( Looper* l ) { xfree(l->events); xfree(l->hooks); l->max_fds = 0; l->num_fds = 0; close(l->epoll_fd); l->epoll_fd = -1; } /* return the LoopHook corresponding to a given * monitored file descriptor, or NULL if not found */ static LoopHook* looper_find( Looper* l, int fd ) { LoopHook* hook = l->hooks; LoopHook* end = hook + l->num_fds; for ( ; hook < end; hook++ ) { if (hook->fd == fd) return hook; } return NULL; } /* grow the arrays in the looper object */ static void looper_grow( Looper* l ) { int old_max = l->max_fds; int new_max = old_max + (old_max >> 1) + 4; int n; xrenew( l->events, new_max ); xrenew( l->hooks, new_max ); l->max_fds = new_max; /* now change the handles to all events */ for (n = 0; n < l->num_fds; n++) { struct epoll_event ev; LoopHook* hook = l->hooks + n; ev.events = hook->wanted; ev.data.ptr = hook; epoll_ctl( l->epoll_fd, EPOLL_CTL_MOD, hook->fd, &ev ); } } /* register a file descriptor and its event handler. * no event mask will be enabled */ static void looper_add( Looper* l, int fd, EventFunc func, void* user ) { struct epoll_event ev; LoopHook* hook; if (l->num_fds >= l->max_fds) looper_grow(l); hook = l->hooks + l->num_fds; hook->fd = fd; hook->ev_user = user; hook->ev_func = func; hook->state = 0; hook->wanted = 0; hook->events = 0; fd_setnonblock(fd); ev.events = 0; ev.data.ptr = hook; epoll_ctl( l->epoll_fd, EPOLL_CTL_ADD, fd, &ev ); l->num_fds += 1; } /* unregister a file descriptor and its event handler */ static void looper_del( Looper* l, int fd ) { LoopHook* hook = looper_find( l, fd ); if (!hook) { D( "%s: invalid fd: %d", __FUNCTION__, fd ); return; } /* don't remove the hook yet */ hook->state |= HOOK_CLOSING; epoll_ctl( l->epoll_fd, EPOLL_CTL_DEL, fd, NULL ); } /* enable monitoring of certain events for a file * descriptor. This adds 'events' to the current * event mask */ static void looper_enable( Looper* l, int fd, int events ) { LoopHook* hook = looper_find( l, fd ); if (!hook) { D("%s: invalid fd: %d", __FUNCTION__, fd ); return; } if (events & ~hook->wanted) { struct epoll_event ev; hook->wanted |= events; ev.events = hook->wanted; ev.data.ptr = hook; epoll_ctl( l->epoll_fd, EPOLL_CTL_MOD, fd, &ev ); } } /* disable monitoring of certain events for a file * descriptor. This ignores events that are not * currently enabled. */ static void looper_disable( Looper* l, int fd, int events ) { LoopHook* hook = looper_find( l, fd ); if (!hook) { D("%s: invalid fd: %d", __FUNCTION__, fd ); return; } if (events & hook->wanted) { struct epoll_event ev; hook->wanted &= ~events; ev.events = hook->wanted; ev.data.ptr = hook; epoll_ctl( l->epoll_fd, EPOLL_CTL_MOD, fd, &ev ); } } /* wait until an event occurs on one of the registered file * descriptors. Only returns in case of error !! */ static void looper_loop( Looper* l ) { for (;;) { int n, count; do { count = epoll_wait( l->epoll_fd, l->events, l->num_fds, -1 ); } while (count < 0 && errno == EINTR); if (count < 0) { D("%s: error: %s", __FUNCTION__, strerror(errno) ); return; } if (count == 0) { D("%s: huh ? epoll returned count=0", __FUNCTION__); continue; } /* mark all pending hooks */ for (n = 0; n < count; n++) { LoopHook* hook = l->events[n].data.ptr; hook->state = HOOK_PENDING; hook->events = l->events[n].events; } /* execute hook callbacks. this may change the 'hooks' * and 'events' array, as well as l->num_fds, so be careful */ for (n = 0; n < l->num_fds; n++) { LoopHook* hook = l->hooks + n; if (hook->state & HOOK_PENDING) { hook->state &= ~HOOK_PENDING; hook->ev_func( hook->ev_user, hook->events ); } } /* now remove all the hooks that were closed by * the callbacks */ for (n = 0; n < l->num_fds;) { struct epoll_event ev; LoopHook* hook = l->hooks + n; if (!(hook->state & HOOK_CLOSING)) { n++; continue; } hook[0] = l->hooks[l->num_fds-1]; l->num_fds -= 1; ev.events = hook->wanted; ev.data.ptr = hook; epoll_ctl( l->epoll_fd, EPOLL_CTL_MOD, hook->fd, &ev ); } } } #if T_ACTIVE char* quote( const void* data, int len ) { const char* p = data; const char* end = p + len; int count = 0; int phase = 0; static char* buff = NULL; for (phase = 0; phase < 2; phase++) { if (phase != 0) { xfree(buff); buff = xalloc(count+1); } count = 0; for (p = data; p < end; p++) { int c = *p; if (c == '\\') { if (phase != 0) { buff[count] = buff[count+1] = '\\'; } count += 2; continue; } if (c >= 32 && c < 127) { if (phase != 0) buff[count] = c; count += 1; continue; } if (c == '\t') { if (phase != 0) { memcpy(buff+count, "", 5); } count += 5; continue; } if (c == '\n') { if (phase != 0) { memcpy(buff+count, "", 4); } count += 4; continue; } if (c == '\r') { if (phase != 0) { memcpy(buff+count, "", 4); } count += 4; continue; } if (phase != 0) { buff[count+0] = '\\'; buff[count+1] = 'x'; buff[count+2] = "0123456789abcdef"[(c >> 4) & 15]; buff[count+3] = "0123456789abcdef"[ (c) & 15]; } count += 4; } } buff[count] = 0; return buff; } #endif /* T_ACTIVE */ /** PACKETS ** ** We need a way to buffer data before it can be sent to the ** corresponding file descriptor. We use linked list of Packet ** objects to do this. **/ typedef struct Packet Packet; #define MAX_PAYLOAD 4000 struct Packet { Packet* next; int len; int channel; uint8_t data[ MAX_PAYLOAD ]; }; /* we expect to alloc/free a lot of packets during * operations so use a single linked list of free packets * to keep things speedy and simple. */ static Packet* _free_packets; /* Allocate a packet */ static Packet* packet_alloc(void) { Packet* p = _free_packets; if (p != NULL) { _free_packets = p->next; } else { xnew(p); } p->next = NULL; p->len = 0; p->channel = -1; return p; } /* Release a packet. This takes the address of a packet * pointer that will be set to NULL on exit (avoids * referencing dangling pointers in case of bugs) */ static void packet_free( Packet* *ppacket ) { Packet* p = *ppacket; if (p) { p->next = _free_packets; _free_packets = p; *ppacket = NULL; } } /** PACKET RECEIVER ** ** Simple abstraction for something that can receive a packet ** from a FDHandler (see below) or something else. ** ** Send a packet to it with 'receiver_post' ** ** Call 'receiver_close' to indicate that the corresponding ** packet source was closed. **/ typedef void (*PostFunc) ( void* user, Packet* p ); typedef void (*CloseFunc)( void* user ); typedef struct { PostFunc post; CloseFunc close; void* user; } Receiver; /* post a packet to a receiver. Note that this transfers * ownership of the packet to the receiver. */ static __inline__ void receiver_post( Receiver* r, Packet* p ) { if (r->post) r->post( r->user, p ); else packet_free(&p); } /* tell a receiver the packet source was closed. * this will also prevent further posting to the * receiver. */ static __inline__ void receiver_close( Receiver* r ) { if (r->close) { r->close( r->user ); r->close = NULL; } r->post = NULL; } /** FD HANDLERS ** ** these are smart listeners that send incoming packets to a receiver ** and can queue one or more outgoing packets and send them when ** possible to the FD. ** ** note that we support clean shutdown of file descriptors, ** i.e. we try to send all outgoing packets before destroying ** the FDHandler. **/ typedef struct FDHandler FDHandler; typedef struct FDHandlerList FDHandlerList; struct FDHandler { int fd; FDHandlerList* list; char closing; Receiver receiver[1]; /* queue of outgoing packets */ int out_pos; Packet* out_first; Packet** out_ptail; FDHandler* next; FDHandler** pref; }; struct FDHandlerList { /* the looper that manages the fds */ Looper* looper; /* list of active FDHandler objects */ FDHandler* active; /* list of closing FDHandler objects. * these are waiting to push their * queued packets to the fd before * freeing themselves. */ FDHandler* closing; }; /* remove a FDHandler from its current list */ static void fdhandler_remove( FDHandler* f ) { f->pref[0] = f->next; if (f->next) f->next->pref = f->pref; } /* add a FDHandler to a given list */ static void fdhandler_prepend( FDHandler* f, FDHandler** list ) { f->next = list[0]; f->pref = list; list[0] = f; if (f->next) f->next->pref = &f->next; } /* initialize a FDHandler list */ static void fdhandler_list_init( FDHandlerList* list, Looper* looper ) { list->looper = looper; list->active = NULL; list->closing = NULL; } /* close a FDHandler (and free it). Note that this will not * perform a graceful shutdown, i.e. all packets in the * outgoing queue will be immediately free. * * this *will* notify the receiver that the file descriptor * was closed. * * you should call fdhandler_shutdown() if you want to * notify the FDHandler that its packet source is closed. */ static void fdhandler_close( FDHandler* f ) { /* notify receiver */ receiver_close(f->receiver); /* remove the handler from its list */ fdhandler_remove(f); /* get rid of outgoing packet queue */ if (f->out_first != NULL) { Packet* p; while ((p = f->out_first) != NULL) { f->out_first = p->next; packet_free(&p); } } /* get rid of file descriptor */ if (f->fd >= 0) { looper_del( f->list->looper, f->fd ); close(f->fd); f->fd = -1; } f->list = NULL; xfree(f); } /* Ask the FDHandler to cleanly shutdown the connection, * i.e. send any pending outgoing packets then auto-free * itself. */ static void fdhandler_shutdown( FDHandler* f ) { /* prevent later fdhandler_close() to * call the receiver's close. */ f->receiver->close = NULL; if (f->out_first != NULL && !f->closing) { /* move the handler to the 'closing' list */ f->closing = 1; fdhandler_remove(f); fdhandler_prepend(f, &f->list->closing); return; } fdhandler_close(f); } /* Enqueue a new packet that the FDHandler will * send through its file descriptor. */ static void fdhandler_enqueue( FDHandler* f, Packet* p ) { Packet* first = f->out_first; p->next = NULL; f->out_ptail[0] = p; f->out_ptail = &p->next; if (first == NULL) { f->out_pos = 0; looper_enable( f->list->looper, f->fd, EPOLLOUT ); } } /* FDHandler file descriptor event callback for read/write ops */ static void fdhandler_event( FDHandler* f, int events ) { int len; /* in certain cases, it's possible to have both EPOLLIN and * EPOLLHUP at the same time. This indicates that there is incoming * data to read, but that the connection was nonetheless closed * by the sender. Be sure to read the data before closing * the receiver to avoid packet loss. */ if (events & EPOLLIN) { Packet* p = packet_alloc(); int len; if ((len = fd_read(f->fd, p->data, MAX_PAYLOAD)) < 0) { D("%s: can't recv: %s", __FUNCTION__, strerror(errno)); packet_free(&p); } else if (len > 0) { p->len = len; p->channel = -101; /* special debug value, not used */ receiver_post( f->receiver, p ); } } if (events & (EPOLLHUP|EPOLLERR)) { /* disconnection */ D("%s: disconnect on fd %d", __FUNCTION__, f->fd); fdhandler_close(f); return; } if (events & EPOLLOUT && f->out_first) { Packet* p = f->out_first; int avail, len; avail = p->len - f->out_pos; if ((len = fd_write(f->fd, p->data + f->out_pos, avail)) < 0) { D("%s: can't send: %s", __FUNCTION__, strerror(errno)); } else { f->out_pos += len; if (f->out_pos >= p->len) { f->out_pos = 0; f->out_first = p->next; packet_free(&p); if (f->out_first == NULL) { f->out_ptail = &f->out_first; looper_disable( f->list->looper, f->fd, EPOLLOUT ); } } } } } /* Create a new FDHandler that monitors read/writes */ static FDHandler* fdhandler_new( int fd, FDHandlerList* list, Receiver* receiver ) { FDHandler* f = xalloc0(sizeof(*f)); f->fd = fd; f->list = list; f->receiver[0] = receiver[0]; f->out_first = NULL; f->out_ptail = &f->out_first; f->out_pos = 0; fdhandler_prepend(f, &list->active); looper_add( list->looper, fd, (EventFunc) fdhandler_event, f ); looper_enable( list->looper, fd, EPOLLIN ); return f; } /* event callback function to monitor accepts() on server sockets. * the convention used here is that the receiver will receive a * dummy packet with the new client socket in p->channel */ static void fdhandler_accept_event( FDHandler* f, int events ) { if (events & EPOLLIN) { /* this is an accept - send a dummy packet to the receiver */ Packet* p = packet_alloc(); D("%s: accepting on fd %d", __FUNCTION__, f->fd); p->data[0] = 1; p->len = 1; p->channel = fd_accept(f->fd); if (p->channel < 0) { D("%s: accept failed ?: %s", __FUNCTION__, strerror(errno)); packet_free(&p); return; } receiver_post( f->receiver, p ); } if (events & (EPOLLHUP|EPOLLERR)) { /* disconnecting !! */ D("%s: closing accept fd %d", __FUNCTION__, f->fd); fdhandler_close(f); return; } } /* Create a new FDHandler used to monitor new connections on a * server socket. The receiver must expect the new connection * fd in the 'channel' field of a dummy packet. */ static FDHandler* fdhandler_new_accept( int fd, FDHandlerList* list, Receiver* receiver ) { FDHandler* f = xalloc0(sizeof(*f)); f->fd = fd; f->list = list; f->receiver[0] = receiver[0]; fdhandler_prepend(f, &list->active); looper_add( list->looper, fd, (EventFunc) fdhandler_accept_event, f ); looper_enable( list->looper, fd, EPOLLIN ); listen( fd, 5 ); return f; } /** SERIAL CONNECTION STATE ** ** The following is used to handle the framing protocol ** used on the serial port connection. **/ /* each packet is made of a 6 byte header followed by a payload * the header looks like: * * offset size description * 0 2 a 2-byte hex string for the channel number * 4 4 a 4-char hex string for the size of the payload * 6 n the payload itself */ #define HEADER_SIZE 6 #define CHANNEL_OFFSET 0 #define LENGTH_OFFSET 2 #define CHANNEL_SIZE 2 #define LENGTH_SIZE 4 #define CHANNEL_CONTROL 0 /* The Serial object receives data from the serial port, * extracts the payload size and channel index, then sends * the resulting messages as a packet to a generic receiver. * * You can also use serial_send to send a packet through * the serial port. */ typedef struct Serial { FDHandler* fdhandler; /* used to monitor serial port fd */ Receiver receiver[1]; /* send payload there */ int in_len; /* current bytes in input packet */ int in_datalen; /* payload size, or 0 when reading header */ int in_channel; /* extracted channel number */ Packet* in_packet; /* used to read incoming packets */ } Serial; /* a callback called when the serial port's fd is closed */ static void serial_fd_close( Serial* s ) { fatal("unexpected serial port close !!"); } static void serial_dump( Packet* p, const char* funcname ) { T("%s: %03d bytes: '%s'", funcname, p->len, quote(p->data, p->len)); } /* a callback called when a packet arrives from the serial port's FDHandler. * * This will essentially parse the header, extract the channel number and * the payload size and store them in 'in_datalen' and 'in_channel'. * * After that, the payload is sent to the receiver once completed. */ static void serial_fd_receive( Serial* s, Packet* p ) { int rpos = 0, rcount = p->len; Packet* inp = s->in_packet; int inpos = s->in_len; serial_dump( p, __FUNCTION__ ); while (rpos < rcount) { int avail = rcount - rpos; /* first, try to read the header */ if (s->in_datalen == 0) { int wanted = HEADER_SIZE - inpos; if (avail > wanted) avail = wanted; memcpy( inp->data + inpos, p->data + rpos, avail ); inpos += avail; rpos += avail; if (inpos == HEADER_SIZE) { s->in_datalen = hex2int( inp->data + LENGTH_OFFSET, LENGTH_SIZE ); s->in_channel = hex2int( inp->data + CHANNEL_OFFSET, CHANNEL_SIZE ); if (s->in_datalen <= 0) { D("ignoring %s packet from serial port", s->in_datalen ? "empty" : "malformed"); s->in_datalen = 0; } //D("received %d bytes packet for channel %d", s->in_datalen, s->in_channel); inpos = 0; } } else /* then, populate the packet itself */ { int wanted = s->in_datalen - inpos; if (avail > wanted) avail = wanted; memcpy( inp->data + inpos, p->data + rpos, avail ); inpos += avail; rpos += avail; if (inpos == s->in_datalen) { if (s->in_channel < 0) { D("ignoring %d bytes addressed to channel %d", inpos, s->in_channel); } else { inp->len = inpos; inp->channel = s->in_channel; receiver_post( s->receiver, inp ); s->in_packet = inp = packet_alloc(); } s->in_datalen = 0; inpos = 0; } } } s->in_len = inpos; packet_free(&p); } /* send a packet to the serial port. * this assumes that p->len and p->channel contain the payload's * size and channel and will add the appropriate header. */ static void serial_send( Serial* s, Packet* p ) { Packet* h = packet_alloc(); //D("sending to serial %d bytes from channel %d: '%.*s'", p->len, p->channel, p->len, p->data); /* insert a small header before this packet */ h->len = HEADER_SIZE; int2hex( p->len, h->data + LENGTH_OFFSET, LENGTH_SIZE ); int2hex( p->channel, h->data + CHANNEL_OFFSET, CHANNEL_SIZE ); serial_dump( h, __FUNCTION__ ); serial_dump( p, __FUNCTION__ ); fdhandler_enqueue( s->fdhandler, h ); fdhandler_enqueue( s->fdhandler, p ); } /* initialize serial reader */ static void serial_init( Serial* s, int fd, FDHandlerList* list, Receiver* receiver ) { Receiver recv; recv.user = s; recv.post = (PostFunc) serial_fd_receive; recv.close = (CloseFunc) serial_fd_close; s->receiver[0] = receiver[0]; s->fdhandler = fdhandler_new( fd, list, &recv ); s->in_len = 0; s->in_datalen = 0; s->in_channel = 0; s->in_packet = packet_alloc(); } /** CLIENTS **/ typedef struct Client Client; typedef struct Multiplexer Multiplexer; /* A Client object models a single qemud client socket * connection in the emulated system. * * the client first sends the name of the system service * it wants to contact (no framing), then waits for a 2 * byte answer from qemud. * * the answer is either "OK" or "KO" to indicate * success or failure. * * In case of success, the client can send messages * to the service. * * In case of failure, it can disconnect or try sending * the name of another service. */ struct Client { Client* next; Client** pref; int channel; char registered; FDHandler* fdhandler; Multiplexer* multiplexer; }; struct Multiplexer { Client* clients; int last_channel; Serial serial[1]; Looper looper[1]; FDHandlerList fdhandlers[1]; }; static int multiplexer_open_channel( Multiplexer* mult, Packet* p ); static void multiplexer_close_channel( Multiplexer* mult, int channel ); static void multiplexer_serial_send( Multiplexer* mult, int channel, Packet* p ); static void client_dump( Client* c, Packet* p, const char* funcname ) { T("%s: client %p (%d): %3d bytes: '%s'", funcname, c, c->fdhandler->fd, p->len, quote(p->data, p->len)); } /* destroy a client */ static void client_free( Client* c ) { /* remove from list */ c->pref[0] = c->next; if (c->next) c->next->pref = c->pref; c->channel = -1; c->registered = 0; /* gently ask the FDHandler to shutdown to * avoid losing queued outgoing packets */ if (c->fdhandler != NULL) { fdhandler_shutdown(c->fdhandler); c->fdhandler = NULL; } xfree(c); } /* a function called when a client socket receives data */ static void client_fd_receive( Client* c, Packet* p ) { client_dump(c, p, __FUNCTION__); if (c->registered) { /* the client is registered, just send the * data through the serial port */ multiplexer_serial_send(c->multiplexer, c->channel, p); return; } if (c->channel > 0) { /* the client is waiting registration results. * this should not happen because the client * should wait for our 'ok' or 'ko'. * close the connection. */ D("%s: bad client sending data before end of registration", __FUNCTION__); BAD_CLIENT: packet_free(&p); client_free(c); return; } /* the client hasn't registered a service yet, * so this must be the name of a service, call * the multiplexer to start registration for * it. */ D("%s: attempting registration for service '%.*s'", __FUNCTION__, p->len, p->data); c->channel = multiplexer_open_channel(c->multiplexer, p); if (c->channel < 0) { D("%s: service name too long", __FUNCTION__); goto BAD_CLIENT; } D("%s: -> received channel id %d", __FUNCTION__, c->channel); packet_free(&p); } /* a function called when the client socket is closed. */ static void client_fd_close( Client* c ) { T("%s: client %p (%d)", __FUNCTION__, c, c->fdhandler->fd); /* no need to shutdown the FDHandler */ c->fdhandler = NULL; /* tell the emulator we're out */ if (c->channel > 0) multiplexer_close_channel(c->multiplexer, c->channel); /* free the client */ client_free(c); } /* a function called when the multiplexer received a registration * response from the emulator for a given client. */ static void client_registration( Client* c, int registered ) { Packet* p = packet_alloc(); /* sends registration status to client */ if (!registered) { D("%s: registration failed for client %d", __FUNCTION__, c->channel); memcpy( p->data, "KO", 2 ); p->len = 2; } else { D("%s: registration succeeded for client %d", __FUNCTION__, c->channel); memcpy( p->data, "OK", 2 ); p->len = 2; } client_dump(c, p, __FUNCTION__); fdhandler_enqueue(c->fdhandler, p); /* now save registration state */ c->registered = registered; if (!registered) { /* allow the client to try registering another service */ c->channel = -1; } } /* send data to a client */ static void client_send( Client* c, Packet* p ) { client_dump(c, p, __FUNCTION__); fdhandler_enqueue(c->fdhandler, p); } /* Create new client socket handler */ static Client* client_new( Multiplexer* mult, int fd, FDHandlerList* pfdhandlers, Client** pclients ) { Client* c; Receiver recv; xnew(c); c->multiplexer = mult; c->next = NULL; c->pref = &c->next; c->channel = -1; c->registered = 0; recv.user = c; recv.post = (PostFunc) client_fd_receive; recv.close = (CloseFunc) client_fd_close; c->fdhandler = fdhandler_new( fd, pfdhandlers, &recv ); /* add to client list */ c->next = *pclients; c->pref = pclients; *pclients = c; if (c->next) c->next->pref = &c->next; return c; } /** GLOBAL MULTIPLEXER **/ /* find a client by its channel */ static Client* multiplexer_find_client( Multiplexer* mult, int channel ) { Client* c = mult->clients; for ( ; c != NULL; c = c->next ) { if (c->channel == channel) return c; } return NULL; } /* handle control messages coming from the serial port * on CONTROL_CHANNEL. */ static void multiplexer_handle_control( Multiplexer* mult, Packet* p ) { /* connection registration success */ if (p->len == 13 && !memcmp(p->data, "ok:connect:", 11)) { int channel = hex2int(p->data+11, 2); Client* client = multiplexer_find_client(mult, channel); /* note that 'client' can be NULL if the corresponding * socket was closed before the emulator response arrived. */ if (client != NULL) { client_registration(client, 1); } else { D("%s: NULL client: '%.*s'", __FUNCTION__, p->len, p->data+11); } goto EXIT; } /* connection registration failure */ if (p->len == 13 && !memcmp(p->data, "ko:connect:",11)) { int channel = hex2int(p->data+11, 2); Client* client = multiplexer_find_client(mult, channel); if (client != NULL) client_registration(client, 0); goto EXIT; } /* emulator-induced client disconnection */ if (p->len == 13 && !memcmp(p->data, "disconnect:",11)) { int channel = hex2int(p->data+11, 2); Client* client = multiplexer_find_client(mult, channel); if (client != NULL) client_free(client); goto EXIT; } /* A message that begins with "X00" is a probe sent by * the emulator used to detect which version of qemud it runs * against (in order to detect 1.0/1.1 system images. Just * silently ignore it there instead of printing an error * message. */ if (p->len >= 3 && !memcmp(p->data,"X00",3)) { goto EXIT; } D("%s: unknown control message (%d bytes): '%.*s'", __FUNCTION__, p->len, p->len, p->data); EXIT: packet_free(&p); } /* a function called when an incoming packet comes from the serial port */ static void multiplexer_serial_receive( Multiplexer* mult, Packet* p ) { Client* client; T("%s: channel=%d '%.*s'", __FUNCTION__, p->channel, p->len, p->data); if (p->channel == CHANNEL_CONTROL) { multiplexer_handle_control(mult, p); return; } client = multiplexer_find_client(mult, p->channel); if (client != NULL) { client_send(client, p); return; } D("%s: discarding packet for unknown channel %d", __FUNCTION__, p->channel); packet_free(&p); } /* a function called when the serial reader closes */ static void multiplexer_serial_close( Multiplexer* mult ) { fatal("unexpected close of serial reader"); } /* a function called to send a packet to the serial port */ static void multiplexer_serial_send( Multiplexer* mult, int channel, Packet* p ) { p->channel = channel; serial_send( mult->serial, p ); } /* a function used by a client to allocate a new channel id and * ask the emulator to open it. 'service' must be a packet containing * the name of the service in its payload. * * returns -1 if the service name is too long. * * notice that client_registration() will be called later when * the answer arrives. */ static int multiplexer_open_channel( Multiplexer* mult, Packet* service ) { Packet* p = packet_alloc(); int len, channel; /* find a free channel number, assume we don't have many * clients here. */ { Client* c; TRY_AGAIN: channel = (++mult->last_channel) & 0xff; for (c = mult->clients; c != NULL; c = c->next) if (c->channel == channel) goto TRY_AGAIN; } len = snprintf((char*)p->data, sizeof p->data, "connect:%.*s:%02x", service->len, service->data, channel); if (len >= (int)sizeof(p->data)) { D("%s: weird, service name too long (%d > %d)", __FUNCTION__, len, sizeof(p->data)); packet_free(&p); return -1; } p->channel = CHANNEL_CONTROL; p->len = len; serial_send(mult->serial, p); return channel; } /* used to tell the emulator a channel was closed by a client */ static void multiplexer_close_channel( Multiplexer* mult, int channel ) { Packet* p = packet_alloc(); int len = snprintf((char*)p->data, sizeof(p->data), "disconnect:%02x", channel); if (len > (int)sizeof(p->data)) { /* should not happen */ return; } p->channel = CHANNEL_CONTROL; p->len = len; serial_send(mult->serial, p); } /* this function is used when a new connection happens on the control * socket. */ static void multiplexer_control_accept( Multiplexer* m, Packet* p ) { /* the file descriptor for the new socket connection is * in p->channel. See fdhandler_accept_event() */ int fd = p->channel; Client* client = client_new( m, fd, m->fdhandlers, &m->clients ); D("created client %p listening on fd %d", client, fd); /* free dummy packet */ packet_free(&p); } static void multiplexer_control_close( Multiplexer* m ) { fatal("unexpected multiplexer control close"); } static void multiplexer_init( Multiplexer* m, const char* serial_dev ) { int fd, control_fd; Receiver recv; /* initialize looper and fdhandlers list */ looper_init( m->looper ); fdhandler_list_init( m->fdhandlers, m->looper ); /* open the serial port */ do { fd = socket(AF_LOCAL, SOCK_STREAM, 0); } while (fd < 0 && errno == EINTR); struct sockaddr_un addr; memset(&addr, 0, sizeof(addr)); addr.sun_family = AF_UNIX; strncpy(addr.sun_path, serial_dev, sizeof(addr.sun_path)); if (connect(fd, (struct sockaddr*) &addr, sizeof(addr)) < 0) { close(fd); fd = -1; } if (fd < 0) { fatal( "%s: could not open '%s': %s", __FUNCTION__, serial_dev, strerror(errno) ); } /* initialize the serial reader/writer */ recv.user = m; recv.post = (PostFunc) multiplexer_serial_receive; recv.close = (CloseFunc) multiplexer_serial_close; serial_init( m->serial, fd, m->fdhandlers, &recv ); /* open the qemud control socket */ recv.user = m; recv.post = (PostFunc) multiplexer_control_accept; recv.close = (CloseFunc) multiplexer_control_close; fd = android_get_control_socket(CONTROL_SOCKET_NAME); if (fd < 0) { fatal("couldn't get fd for control socket '%s'", CONTROL_SOCKET_NAME); } fdhandler_new_accept( fd, m->fdhandlers, &recv ); /* initialize clients list */ m->clients = NULL; } /** MAIN LOOP **/ static Multiplexer _multiplexer[1]; int main( void ) { Multiplexer* m = _multiplexer; multiplexer_init(m, "/dev/qemud"); D( "entering main loop"); looper_loop( m->looper ); D( "unexpected termination !!" ); return 0; } anbox-0.0~git20191115/android/sensors/000077500000000000000000000000001356361734700173415ustar00rootroot00000000000000anbox-0.0~git20191115/android/sensors/Android.mk000066400000000000000000000022531356361734700212540ustar00rootroot00000000000000# Copyright (C) 2009 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. LOCAL_PATH := $(call my-dir) # HAL module implemenation stored in # hw/..so include $(CLEAR_VARS) LOCAL_MODULE_RELATIVE_PATH := hw LOCAL_SHARED_LIBRARIES := liblog libcutils LOCAL_SRC_FILES := sensors_qemu.c ifeq ($(TARGET_PRODUCT),vbox_x86) LOCAL_MODULE := sensors.vbox_x86 else LOCAL_MODULE := sensors.goldfish endif include $(BUILD_SHARED_LIBRARY) include $(CLEAR_VARS) LOCAL_MODULE_RELATIVE_PATH := hw LOCAL_SHARED_LIBRARIES := liblog libcutils LOCAL_SRC_FILES := sensors_qemu.c LOCAL_MODULE := sensors.ranchu include $(BUILD_SHARED_LIBRARY) anbox-0.0~git20191115/android/sensors/sensors_qemu.c000066400000000000000000000571361356361734700222440ustar00rootroot00000000000000/* * Copyright (C) 2009 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* this implements a sensors hardware library for the Android emulator. * the following code should be built as a shared library that will be * placed into /system/lib/hw/sensors.goldfish.so * * it will be loaded by the code in hardware/libhardware/hardware.c * which is itself called from com_android_server_SensorService.cpp */ /* we connect with the emulator through the "sensors" qemud service */ #define SENSORS_SERVICE_NAME "sensors" #define LOG_TAG "QemuSensors" #include #include #include #include #include #include #include #if 0 #define D(...) ALOGD(__VA_ARGS__) #else #define D(...) ((void)0) #endif #define E(...) ALOGE(__VA_ARGS__) #include /** SENSOR IDS AND NAMES **/ #define MAX_NUM_SENSORS 8 #define SUPPORTED_SENSORS ((1<"; } static int _sensorIdFromName( const char* name ) { int nn; if (name == NULL) return -1; for (nn = 0; nn < MAX_NUM_SENSORS; nn++) if (!strcmp(name, _sensorIds[nn].name)) return _sensorIds[nn].id; return -1; } /* return the current time in nanoseconds */ static int64_t now_ns(void) { struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); return (int64_t)ts.tv_sec * 1000000000 + ts.tv_nsec; } /** SENSORS POLL DEVICE ** ** This one is used to read sensor data from the hardware. ** We implement this by simply reading the data from the ** emulator through the QEMUD channel. **/ typedef struct SensorDevice { struct sensors_poll_device_1 device; sensors_event_t sensors[MAX_NUM_SENSORS]; uint32_t pendingSensors; int64_t timeStart; int64_t timeOffset; uint32_t active_sensors; int fd; pthread_mutex_t lock; } SensorDevice; /* Grab the file descriptor to the emulator's sensors service pipe. * This function returns a file descriptor on success, or -errno on * failure, and assumes the SensorDevice instance's lock is held. * * This is needed because set_delay(), poll() and activate() can be called * from different threads, and poll() is blocking. * * Note that the emulator's sensors service creates a new client for each * connection through qemud_channel_open(), where each client has its own * delay and set of activated sensors. This precludes calling * qemud_channel_open() on each request, because a typical emulated system * will do something like: * * 1) On a first thread, de-activate() all sensors first, then call poll(), * which results in the thread blocking. * * 2) On a second thread, slightly later, call set_delay() then activate() * to enable the acceleration sensor. * * The system expects this to unblock the first thread which will receive * new sensor events after the activate() call in 2). * * This cannot work if both threads don't use the same connection. * * TODO(digit): This protocol is brittle, implement another control channel * for set_delay()/activate()/batch() when supporting HAL 1.3 */ static int sensor_device_get_fd_locked(SensorDevice* dev) { /* Create connection to service on first call */ if (dev->fd < 0) { dev->fd = qemud_channel_open(SENSORS_SERVICE_NAME); if (dev->fd < 0) { int ret = -errno; E("%s: Could not open connection to service: %s", __FUNCTION__, strerror(-ret)); return ret; } } return dev->fd; } /* Send a command to the sensors virtual device. |dev| is a device instance and * |cmd| is a zero-terminated command string. Return 0 on success, or -errno * on failure. */ static int sensor_device_send_command_locked(SensorDevice* dev, const char* cmd) { int fd = sensor_device_get_fd_locked(dev); if (fd < 0) { return fd; } int ret = 0; if (qemud_channel_send(fd, cmd, strlen(cmd)) < 0) { ret = -errno; E("%s(fd=%d): ERROR: %s", __FUNCTION__, fd, strerror(errno)); } return ret; } /* Pick up one pending sensor event. On success, this returns the sensor * id, and sets |*event| accordingly. On failure, i.e. if there are no * pending events, return -EINVAL. * * Note: The device's lock must be acquired. */ static int sensor_device_pick_pending_event_locked(SensorDevice* d, sensors_event_t* event) { uint32_t mask = SUPPORTED_SENSORS & d->pendingSensors; if (mask) { uint32_t i = 31 - __builtin_clz(mask); d->pendingSensors &= ~(1U << i); *event = d->sensors[i]; event->sensor = i; event->version = sizeof(*event); D("%s: %d [%f, %f, %f]", __FUNCTION__, i, event->data[0], event->data[1], event->data[2]); return i; } E("No sensor to return!!! pendingSensors=0x%08x", d->pendingSensors); // we may end-up in a busy loop, slow things down, just in case. usleep(100000); return -EINVAL; } /* Block until new sensor events are reported by the emulator, or if a * 'wake' command is received through the service. On succes, return 0 * and updates the |pendingEvents| and |sensors| fields of |dev|. * On failure, return -errno. * * Note: The device lock must be acquired when calling this function, and * will still be held on return. However, the function releases the * lock temporarily during the blocking wait. */ static int sensor_device_poll_event_locked(SensorDevice* dev) { D("%s: dev=%p", __FUNCTION__, dev); int fd = sensor_device_get_fd_locked(dev); if (fd < 0) { E("%s: Could not get pipe channel: %s", __FUNCTION__, strerror(-fd)); return fd; } // Accumulate pending events into |events| and |new_sensors| mask // until a 'sync' or 'wake' command is received. This also simplifies the // code a bit. uint32_t new_sensors = 0U; sensors_event_t* events = dev->sensors; int64_t event_time = -1; int ret = 0; for (;;) { /* Release the lock since we're going to block on recv() */ pthread_mutex_unlock(&dev->lock); /* read the next event */ char buff[256]; int len = qemud_channel_recv(fd, buff, sizeof(buff) - 1U); /* re-acquire the lock to modify the device state. */ pthread_mutex_lock(&dev->lock); if (len < 0) { ret = -errno; E("%s(fd=%d): Could not receive event data len=%d, errno=%d: %s", __FUNCTION__, fd, len, errno, strerror(errno)); break; } buff[len] = 0; D("%s(fd=%d): received [%s]", __FUNCTION__, fd, buff); /* "wake" is sent from the emulator to exit this loop. */ /* TODO(digit): Is it still needed? */ if (!strcmp((const char*)buff, "wake")) { ret = 0x7FFFFFFF; break; } float params[3]; /* "acceleration:::" corresponds to an acceleration event */ if (sscanf(buff, "acceleration:%g:%g:%g", params+0, params+1, params+2) == 3) { new_sensors |= SENSORS_ACCELERATION; events[ID_ACCELERATION].acceleration.x = params[0]; events[ID_ACCELERATION].acceleration.y = params[1]; events[ID_ACCELERATION].acceleration.z = params[2]; events[ID_ACCELERATION].type = SENSOR_TYPE_ACCELEROMETER; continue; } /* "orientation:::" is sent when orientation * changes */ if (sscanf(buff, "orientation:%g:%g:%g", params+0, params+1, params+2) == 3) { new_sensors |= SENSORS_ORIENTATION; events[ID_ORIENTATION].orientation.azimuth = params[0]; events[ID_ORIENTATION].orientation.pitch = params[1]; events[ID_ORIENTATION].orientation.roll = params[2]; events[ID_ORIENTATION].orientation.status = SENSOR_STATUS_ACCURACY_HIGH; events[ID_ORIENTATION].type = SENSOR_TYPE_ORIENTATION; continue; } /* "magnetic:::" is sent for the params of the magnetic * field */ if (sscanf(buff, "magnetic:%g:%g:%g", params+0, params+1, params+2) == 3) { new_sensors |= SENSORS_MAGNETIC_FIELD; events[ID_MAGNETIC_FIELD].magnetic.x = params[0]; events[ID_MAGNETIC_FIELD].magnetic.y = params[1]; events[ID_MAGNETIC_FIELD].magnetic.z = params[2]; events[ID_MAGNETIC_FIELD].magnetic.status = SENSOR_STATUS_ACCURACY_HIGH; events[ID_MAGNETIC_FIELD].type = SENSOR_TYPE_MAGNETIC_FIELD; continue; } /* "temperature:" */ if (sscanf(buff, "temperature:%g", params+0) == 1) { new_sensors |= SENSORS_TEMPERATURE; events[ID_TEMPERATURE].temperature = params[0]; events[ID_TEMPERATURE].type = SENSOR_TYPE_TEMPERATURE; continue; } /* "proximity:" */ if (sscanf(buff, "proximity:%g", params+0) == 1) { new_sensors |= SENSORS_PROXIMITY; events[ID_PROXIMITY].distance = params[0]; events[ID_PROXIMITY].type = SENSOR_TYPE_PROXIMITY; continue; } /* "light:" */ if (sscanf(buff, "light:%g", params+0) == 1) { new_sensors |= SENSORS_LIGHT; events[ID_LIGHT].light = params[0]; events[ID_LIGHT].type = SENSOR_TYPE_LIGHT; continue; } /* "pressure:" */ if (sscanf(buff, "pressure:%g", params+0) == 1) { new_sensors |= SENSORS_PRESSURE; events[ID_PRESSURE].pressure = params[0]; events[ID_PRESSURE].type = SENSOR_TYPE_PRESSURE; continue; } /* "humidity:" */ if (sscanf(buff, "humidity:%g", params+0) == 1) { new_sensors |= SENSORS_HUMIDITY; events[ID_HUMIDITY].relative_humidity = params[0]; events[ID_HUMIDITY].type = SENSOR_TYPE_RELATIVE_HUMIDITY; continue; } /* "sync:

: generate encoder into dir\n"); fprintf(stderr, "\t-D : generate decoder into dir\n"); fprintf(stderr, "\t-i: input dir, local directory by default\n"); fprintf(stderr, "\t-T : generate attribute template into the input directory\n\t\tno other files are generated\n"); fprintf(stderr, "\t-W : generate wrapper into dir\n"); } int main(int argc, char *argv[]) { std::string encoderDir = ""; std::string decoderDir = ""; std::string wrapperDir = ""; std::string inDir = "."; bool generateAttributesTemplate = false; int c; while((c = getopt(argc, argv, "TE:D:i:hW:")) != -1) { switch(c) { case 'W': wrapperDir = std::string(optarg); break; case 'T': generateAttributesTemplate = true; break; case 'h': usage(argv[0]); exit(0); break; case 'E': encoderDir = std::string(optarg); break; case 'D': decoderDir = std::string(optarg); break; case 'i': inDir = std::string(optarg); break; case ':': fprintf(stderr, "Missing argument !!\n"); // fall through default: usage(argv[0]); exit(0); } } if (optind >= argc) { fprintf(stderr, "Usage: %s [options] \n", argv[0]); return BAD_USAGE; } if (encoderDir.size() == 0 && decoderDir.size() == 0 && generateAttributesTemplate == false && wrapperDir.size() == 0) { fprintf(stderr, "No output specified - aborting\n"); return BAD_USAGE; } std::string baseName = std::string(argv[optind]); ApiGen apiEntries(baseName); // init types; std::string typesFilename = inDir + "/" + baseName + TYPES_EXTENTION; if (TypeFactory::instance()->initFromFile(typesFilename) < 0) { fprintf(stderr, "missing or error reading types file: %s...ignored\n", typesFilename.c_str()); } std::string filename = inDir + "/" + baseName + SPEC_EXTENSION; if (apiEntries.readSpec(filename) < 0) { perror(filename.c_str()); return BAD_SPEC_FILE; } if (generateAttributesTemplate) { apiEntries.genAttributesTemplate(inDir + "/" + baseName + ATTRIB_EXTENSION); exit(0); } std::string attribFileName = inDir + "/" + baseName + ATTRIB_EXTENSION; if (apiEntries.readAttributes(attribFileName) < 0) { perror(attribFileName.c_str()); fprintf(stderr, "failed to parse attributes\n"); exit(1); } if (encoderDir.size() != 0) { apiEntries.genOpcodes(encoderDir + "/" + baseName + "_opcodes.h"); apiEntries.genContext(encoderDir + "/" + baseName + "_client_context.h", ApiGen::CLIENT_SIDE); apiEntries.genContextImpl(encoderDir + "/" + baseName + "_client_context.cpp", ApiGen::CLIENT_SIDE); apiEntries.genProcTypes(encoderDir + "/" + baseName + "_client_proc.h", ApiGen::CLIENT_SIDE); apiEntries.genFuncTable(encoderDir + "/" + baseName + "_ftable.h", ApiGen::CLIENT_SIDE); apiEntries.genEntryPoints(encoderDir + "/" + baseName + "_entry.cpp", ApiGen::CLIENT_SIDE); apiEntries.genEncoderHeader(encoderDir + "/" + baseName + "_enc.h"); apiEntries.genEncoderImpl(encoderDir + "/" + baseName + "_enc.cpp"); } if (decoderDir.size() != 0) { apiEntries.genOpcodes(decoderDir + "/" + baseName + "_opcodes.h"); apiEntries.genProcTypes(decoderDir + "/" + baseName + "_server_proc.h", ApiGen::SERVER_SIDE); apiEntries.genContext(decoderDir + "/" + baseName + "_server_context.h", ApiGen::SERVER_SIDE); apiEntries.genContextImpl(decoderDir + "/" + baseName + "_server_context.cpp", ApiGen::SERVER_SIDE); apiEntries.genDecoderHeader(decoderDir + "/" + baseName + "_dec.h"); apiEntries.genDecoderImpl(decoderDir + "/" + baseName + "_dec.cpp"); } if (wrapperDir.size() != 0) { apiEntries.genProcTypes(wrapperDir + "/" + baseName + "_wrapper_proc.h", ApiGen::WRAPPER_SIDE); apiEntries.genContext(wrapperDir + "/" + baseName + "_wrapper_context.h", ApiGen::WRAPPER_SIDE); apiEntries.genContextImpl(wrapperDir + "/" + baseName + "_wrapper_context.cpp", ApiGen::WRAPPER_SIDE); apiEntries.genEntryPoints(wrapperDir + "/" + baseName + "_wrapper_entry.cpp", ApiGen::WRAPPER_SIDE); } #ifdef DEBUG_DUMP int withPointers = 0; printf("%d functions found\n", int(apiEntries.size())); for (int i = 0; i < apiEntries.size(); i++) { if (apiEntries[i].hasPointers()) { withPointers++; apiEntries[i].print(); } } fprintf(stdout, "%d entries has poitners\n", withPointers); #endif } anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/strUtils.cpp000066400000000000000000000026611356361734700265350ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "strUtils.h" using namespace std; std::string getNextToken(const std::string & str, size_t pos, size_t * last, const std::string & delim) { if (str.size() == 0 || pos >= str.size()) return ""; pos = str.find_first_not_of(WHITESPACE, pos); if (pos == std::string::npos) return ""; *last = str.find_first_of(delim, pos); if (*last == std::string::npos) *last = str.size(); std::string retval = str.substr(pos, *last - pos); retval = trim(retval); return retval; } std::string trim(const string & str) { string result; string::size_type start = str.find_first_not_of(WHITESPACE, 0); string::size_type end = str.find_last_not_of(WHITESPACE); if (start == string::npos || end == string::npos) { result = string(""); } else { result = str.substr(start, end - start + 1); } return result; } anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/strUtils.h000066400000000000000000000017361356361734700262040ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef STR_UTILS_H_ #define STR_UTILS_H_ #include #include #define WHITESPACE " \t\n" std::string trim(const std::string & str); std::string getNextToken(const std::string & str, size_t pos, size_t * last, const std::string & delim); template std::string inline toString(const T& t) { std::stringstream ss; ss << t; return ss.str(); } #endif anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/000077500000000000000000000000001356361734700253355ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/run-tests.sh000077500000000000000000000063641356361734700276510ustar00rootroot00000000000000#!/bin/sh # Copyright 2014 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # set -e export LANG=C export LC_ALL=C PROGDIR=$(dirname "$0") PROGNAME=$(basename "$0") fatal () { echo "ERROR: $@" exit 1 } OPT_EMUGEN= OPT_HELP= OPT_OUT_DIR= OPT_TOOL= for OPT; do OPTARG=$(expr "x$OPT" : "x[^=]*=\\(.*\\)" || true) case $OPT in --help|-h|-?) OPT_HELP=true ;; --emugen=*) OPT_EMUGEN=$OPTARG ;; --out-dir=*) OPT_OUT_DIR=$OPTARG ;; --tool=*) OPT_TOOL=$OPTARG ;; -*) fatal "Invalid option '$OPT', see --help." ;; *) fatal "This script doesn't take arguments, see --help." ;; esac done if [ "$OPT_HELP" ]; then cat </input, and uses them as input to 'emugen'. It then compares the output to t./expected/ content. Valid options: --help|-h|-? Print this help. --out-dir= Generate outputs into . --emugen= Emugen program path, if not in path. --tool= Launch visual diff tool in case of differences. EOF exit 0 fi # Find emugen program EMUGEN= if [ "$OPT_EMUGEN" ]; then EMUGEN=$OPT_EMUGEN else EMUGEN=$(which emugen 2>/dev/null || true) if [ -z "$EMUGEN" ]; then fatal "Cannot find 'emugen' program in PATH, use --emugen= option." fi echo "Auto-config: --emugen=$EMUGEN" fi if [ ! -f "$EMUGEN" ]; then fatal "Emugen program doesn't exist: $EMUGEN" fi # Create output directory. OUT_DIR= if [ "$OPT_OUT_DIR" ]; then OUT_DIR=$OPT_OUT_DIR else OUT_DIR=/tmp/$USER-emugen-testing echo "Auto-config: --out-dir=$OUT_DIR" fi mkdir -p "$OUT_DIR" && rm -rf "$OUT_DIR/emugen" OUT_DIR=$OUT_DIR/emugen # Find test directories TEST_DIRS=$(cd "$PROGDIR" && find . -name "t.*" | sed -e 's|^\./||') for TEST_DIR in $TEST_DIRS; do IN=$PROGDIR/$TEST_DIR/input PREFIXES=$(cd $IN && find . -name "*.in" | sed -e 's|^\./||g' -e 's|\.in$||g') OUT=$OUT_DIR/$TEST_DIR mkdir -p "$OUT/encoder" mkdir -p "$OUT/decoder" mkdir -p "$OUT/wrapper" for PREFIX in $PREFIXES; do echo "Processing $IN/foo.*" $EMUGEN -i "$PROGDIR/$TEST_DIR/input" -D "$OUT/decoder" -E "$OUT/encoder" -W "$OUT/wrapper" $PREFIX done if ! diff -qr "$PROGDIR/$TEST_DIR/expected" "$OUT"; then if [ "$OPT_TOOL" ]; then $OPT_TOOL "$PROGDIR/$TEST_DIR/expected" "$OUT" else echo "ERROR: Invalid differences between actual and expected output!" diff -burN "$PROGDIR/$TEST_DIR/expected" "$OUT" exit 1 fi fi done echo "All good!" exit 0 anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/000077500000000000000000000000001356361734700260775ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/expected/000077500000000000000000000000001356361734700277005ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/expected/decoder/000077500000000000000000000000001356361734700313055ustar00rootroot00000000000000foo_dec.cpp000066400000000000000000000111061356361734700333270ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/expected/decoder// Generated Code - DO NOT EDIT !! // generated by 'emugen' #include #include "foo_opcodes.h" #include "foo_dec.h" #include "ProtocolUtils.h" #include "ChecksumCalculatorThreadInfo.h" #include typedef unsigned int tsize_t; // Target "size_t", which is 32-bit for now. It may or may not be the same as host's size_t when emugen is compiled. #ifdef OPENGL_DEBUG_PRINTOUT # define DEBUG(...) do { if (emugl_cxt_logger) { emugl_cxt_logger(__VA_ARGS__); } } while(0) #else # define DEBUG(...) ((void)0) #endif #ifdef CHECK_GLERROR # define SET_LASTCALL(name) sprintf(lastCall, #name) #else # define SET_LASTCALL(name) ((void)0) #endif using namespace emugl; size_t foo_decoder_context_t::decode(void *buf, size_t len, IOStream *stream) { size_t pos = 0; if (len < 8) return pos; unsigned char *ptr = (unsigned char *)buf; bool unknownOpcode = false; #ifdef CHECK_GL_ERROR char lastCall[256] = {0}; #endif while ((len - pos >= 8) && !unknownOpcode) { uint32_t opcode = *(uint32_t *)ptr; size_t packetLen = *(uint32_t *)(ptr + 4); if (len - pos < packetLen) return pos; bool useChecksum = ChecksumCalculatorThreadInfo::getVersion() > 0; size_t checksumSize = 0; if (useChecksum) { checksumSize = ChecksumCalculatorThreadInfo::checksumByteSize(); } switch(opcode) { case OP_fooAlphaFunc: { FooInt var_func = Unpack(ptr + 8); FooFloat var_ref = Unpack(ptr + 8 + 4); if (useChecksum) { ChecksumCalculatorThreadInfo::validOrDie(ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize, "8 + 4 + 4::decode, OP_foo_decoder_context_t: GL checksumCalculator failure\n"); } DEBUG("foo(%p): fooAlphaFunc(%d %f )\n", stream,var_func, var_ref); this->fooAlphaFunc(var_func, var_ref); SET_LASTCALL("fooAlphaFunc"); break; } case OP_fooIsBuffer: { uint32_t size_stuff __attribute__((unused)) = Unpack(ptr + 8); InputBuffer inptr_stuff(ptr + 8 + 4, size_stuff); if (useChecksum) { ChecksumCalculatorThreadInfo::validOrDie(ptr, 8 + 4 + size_stuff, ptr + 8 + 4 + size_stuff, checksumSize, "8 + 4 + size_stuff::decode, OP_foo_decoder_context_t: GL checksumCalculator failure\n"); } size_t totalTmpSize = sizeof(FooBoolean); totalTmpSize += checksumSize; unsigned char *tmpBuf = stream->alloc(totalTmpSize); DEBUG("foo(%p): fooIsBuffer(%p(%u) )\n", stream,(void*)(inptr_stuff.get()), size_stuff); *(FooBoolean *)(&tmpBuf[0]) = this->fooIsBuffer((void*)(inptr_stuff.get())); if (useChecksum) { ChecksumCalculatorThreadInfo::writeChecksum(&tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); } stream->flush(); SET_LASTCALL("fooIsBuffer"); break; } case OP_fooUnsupported: { uint32_t size_params __attribute__((unused)) = Unpack(ptr + 8); InputBuffer inptr_params(ptr + 8 + 4, size_params); if (useChecksum) { ChecksumCalculatorThreadInfo::validOrDie(ptr, 8 + 4 + size_params, ptr + 8 + 4 + size_params, checksumSize, "8 + 4 + size_params::decode, OP_foo_decoder_context_t: GL checksumCalculator failure\n"); } DEBUG("foo(%p): fooUnsupported(%p(%u) )\n", stream,(void*)(inptr_params.get()), size_params); this->fooUnsupported((void*)(inptr_params.get())); SET_LASTCALL("fooUnsupported"); break; } case OP_fooDoEncoderFlush: { FooInt var_param = Unpack(ptr + 8); if (useChecksum) { ChecksumCalculatorThreadInfo::validOrDie(ptr, 8 + 4, ptr + 8 + 4, checksumSize, "8 + 4::decode, OP_foo_decoder_context_t: GL checksumCalculator failure\n"); } DEBUG("foo(%p): fooDoEncoderFlush(%d )\n", stream,var_param); this->fooDoEncoderFlush(var_param); SET_LASTCALL("fooDoEncoderFlush"); break; } case OP_fooTakeConstVoidPtrConstPtr: { uint32_t size_param __attribute__((unused)) = Unpack(ptr + 8); InputBuffer inptr_param(ptr + 8 + 4, size_param); if (useChecksum) { ChecksumCalculatorThreadInfo::validOrDie(ptr, 8 + 4 + size_param, ptr + 8 + 4 + size_param, checksumSize, "8 + 4 + size_param::decode, OP_foo_decoder_context_t: GL checksumCalculator failure\n"); } DEBUG("foo(%p): fooTakeConstVoidPtrConstPtr(%p(%u) )\n", stream,(const void* const*)(inptr_param.get()), size_param); this->fooTakeConstVoidPtrConstPtr((const void* const*)(inptr_param.get())); SET_LASTCALL("fooTakeConstVoidPtrConstPtr"); break; } default: unknownOpcode = true; } //switch if (!unknownOpcode) { pos += packetLen; ptr += packetLen; } } // while return pos; } foo_dec.h000066400000000000000000000005471356361734700330030ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/expected/decoder// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef GUARD_foo_decoder_context_t #define GUARD_foo_decoder_context_t #include "IOStream.h" #include "foo_server_context.h" struct foo_decoder_context_t : public foo_server_context_t { size_t decode(void *buf, size_t bufsize, IOStream *stream); }; #endif // GUARD_foo_decoder_context_t foo_opcodes.h000066400000000000000000000005271356361734700337020ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/expected/decoder// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef __GUARD_foo_opcodes_h_ #define __GUARD_foo_opcodes_h_ #define OP_fooAlphaFunc 200 #define OP_fooIsBuffer 201 #define OP_fooUnsupported 202 #define OP_fooDoEncoderFlush 203 #define OP_fooTakeConstVoidPtrConstPtr 204 #define OP_last 205 #endif foo_server_context.cpp000066400000000000000000000013241356361734700356470ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/expected/decoder// Generated Code - DO NOT EDIT !! // generated by 'emugen' #include #include "foo_server_context.h" #include int foo_server_context_t::initDispatchByName(void *(*getProc)(const char *, void *userData), void *userData) { fooAlphaFunc = (fooAlphaFunc_server_proc_t) getProc("fooAlphaFunc", userData); fooIsBuffer = (fooIsBuffer_server_proc_t) getProc("fooIsBuffer", userData); fooUnsupported = (fooUnsupported_server_proc_t) getProc("fooUnsupported", userData); fooDoEncoderFlush = (fooDoEncoderFlush_server_proc_t) getProc("fooDoEncoderFlush", userData); fooTakeConstVoidPtrConstPtr = (fooTakeConstVoidPtrConstPtr_server_proc_t) getProc("fooTakeConstVoidPtrConstPtr", userData); return 0; } foo_server_context.h000066400000000000000000000011371356361734700353160ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/expected/decoder// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef __foo_server_context_t_h #define __foo_server_context_t_h #include "foo_server_proc.h" #include "foo_types.h" struct foo_server_context_t { fooAlphaFunc_server_proc_t fooAlphaFunc; fooIsBuffer_server_proc_t fooIsBuffer; fooUnsupported_server_proc_t fooUnsupported; fooDoEncoderFlush_server_proc_t fooDoEncoderFlush; fooTakeConstVoidPtrConstPtr_server_proc_t fooTakeConstVoidPtrConstPtr; virtual ~foo_server_context_t() {} int initDispatchByName( void *(*getProc)(const char *name, void *userData), void *userData); }; #endif foo_server_proc.h000066400000000000000000000011511356361734700345710ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/expected/decoder// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef __foo_server_proc_t_h #define __foo_server_proc_t_h #include "foo_types.h" #include "emugl/common/logging.h" #ifndef foo_APIENTRY #define foo_APIENTRY #endif typedef void (foo_APIENTRY *fooAlphaFunc_server_proc_t) (FooInt, FooFloat); typedef FooBoolean (foo_APIENTRY *fooIsBuffer_server_proc_t) (void*); typedef void (foo_APIENTRY *fooUnsupported_server_proc_t) (void*); typedef void (foo_APIENTRY *fooDoEncoderFlush_server_proc_t) (FooInt); typedef void (foo_APIENTRY *fooTakeConstVoidPtrConstPtr_server_proc_t) (const void* const*); #endif anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/expected/encoder/000077500000000000000000000000001356361734700313175ustar00rootroot00000000000000foo_client_context.cpp000066400000000000000000000013241356361734700356310ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/expected/encoder// Generated Code - DO NOT EDIT !! // generated by 'emugen' #include #include "foo_client_context.h" #include int foo_client_context_t::initDispatchByName(void *(*getProc)(const char *, void *userData), void *userData) { fooAlphaFunc = (fooAlphaFunc_client_proc_t) getProc("fooAlphaFunc", userData); fooIsBuffer = (fooIsBuffer_client_proc_t) getProc("fooIsBuffer", userData); fooUnsupported = (fooUnsupported_client_proc_t) getProc("fooUnsupported", userData); fooDoEncoderFlush = (fooDoEncoderFlush_client_proc_t) getProc("fooDoEncoderFlush", userData); fooTakeConstVoidPtrConstPtr = (fooTakeConstVoidPtrConstPtr_client_proc_t) getProc("fooTakeConstVoidPtrConstPtr", userData); return 0; } foo_client_context.h000066400000000000000000000015031356361734700352750ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/expected/encoder// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef __foo_client_context_t_h #define __foo_client_context_t_h #include "foo_client_proc.h" #include "foo_types.h" struct foo_client_context_t { fooAlphaFunc_client_proc_t fooAlphaFunc; fooIsBuffer_client_proc_t fooIsBuffer; fooUnsupported_client_proc_t fooUnsupported; fooDoEncoderFlush_client_proc_t fooDoEncoderFlush; fooTakeConstVoidPtrConstPtr_client_proc_t fooTakeConstVoidPtrConstPtr; virtual ~foo_client_context_t() {} typedef foo_client_context_t *CONTEXT_ACCESSOR_TYPE(void); static void setContextAccessor(CONTEXT_ACCESSOR_TYPE *f); int initDispatchByName( void *(*getProc)(const char *name, void *userData), void *userData); virtual void setError(unsigned int error){ (void)error; }; virtual unsigned int getError(){ return 0; }; }; #endif foo_client_proc.h000066400000000000000000000012451356361734700345570ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/expected/encoder// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef __foo_client_proc_t_h #define __foo_client_proc_t_h #include "foo_types.h" #include "emugl/common/logging.h" #ifndef foo_APIENTRY #define foo_APIENTRY #endif typedef void (foo_APIENTRY *fooAlphaFunc_client_proc_t) (void * ctx, FooInt, FooFloat); typedef FooBoolean (foo_APIENTRY *fooIsBuffer_client_proc_t) (void * ctx, void*); typedef void (foo_APIENTRY *fooUnsupported_client_proc_t) (void * ctx, void*); typedef void (foo_APIENTRY *fooDoEncoderFlush_client_proc_t) (void * ctx, FooInt); typedef void (foo_APIENTRY *fooTakeConstVoidPtrConstPtr_client_proc_t) (void * ctx, const void* const*); #endif foo_enc.cpp000066400000000000000000000114761356361734700333650ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/expected/encoder// Generated Code - DO NOT EDIT !! // generated by 'emugen' #include #include #include "foo_opcodes.h" #include "foo_enc.h" #include namespace { void enc_unsupported() { ALOGE("Function is unsupported\n"); } void fooAlphaFunc_enc(void *self , FooInt func, FooFloat ref) { foo_encoder_context_t *ctx = (foo_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_fooAlphaFunc;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, &func, 4); ptr += 4; memcpy(ptr, &ref, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } FooBoolean fooIsBuffer_enc(void *self , void* stuff) { foo_encoder_context_t *ctx = (foo_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_stuff = (4 * sizeof(float)); unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_stuff + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_fooIsBuffer;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_stuff; ptr += 4; memcpy(ptr, stuff, __size_stuff);ptr += __size_stuff; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; FooBoolean retval; stream->readback(&retval, 1); if (useChecksum) checksumCalculator->addBuffer(&retval, 1); if (useChecksum) { std::unique_ptr checksumBuf(new unsigned char[checksumSize]); stream->readback(checksumBuf.get(), checksumSize); if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { ALOGE("fooIsBuffer: GL communication error, please report this issue to b.android.com.\n"); abort(); } } return retval; } void fooDoEncoderFlush_enc(void *self , FooInt param) { foo_encoder_context_t *ctx = (foo_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + 4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_fooDoEncoderFlush;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; memcpy(ptr, ¶m, 4); ptr += 4; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; stream->flush(); } void fooTakeConstVoidPtrConstPtr_enc(void *self , const void* const* param) { foo_encoder_context_t *ctx = (foo_encoder_context_t *)self; IOStream *stream = ctx->m_stream; ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; bool useChecksum = checksumCalculator->getVersion() > 0; const unsigned int __size_param = ; unsigned char *ptr; unsigned char *buf; const size_t sizeWithoutChecksum = 8 + __size_param + 1*4; const size_t checksumSize = checksumCalculator->checksumByteSize(); const size_t totalSize = sizeWithoutChecksum + checksumSize; buf = stream->alloc(totalSize); ptr = buf; int tmp = OP_fooTakeConstVoidPtrConstPtr;memcpy(ptr, &tmp, 4); ptr += 4; memcpy(ptr, &totalSize, 4); ptr += 4; *(unsigned int *)(ptr) = __size_param; ptr += 4; memcpy(ptr, param, __size_param);ptr += __size_param; if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; } } // namespace foo_encoder_context_t::foo_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator) { m_stream = stream; m_checksumCalculator = checksumCalculator; this->fooAlphaFunc = &fooAlphaFunc_enc; this->fooIsBuffer = &fooIsBuffer_enc; this->fooUnsupported = (fooUnsupported_client_proc_t) &enc_unsupported; this->fooDoEncoderFlush = &fooDoEncoderFlush_enc; this->fooTakeConstVoidPtrConstPtr = &fooTakeConstVoidPtrConstPtr_enc; } foo_enc.h000066400000000000000000000010051356361734700330150ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/expected/encoder// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef GUARD_foo_encoder_context_t #define GUARD_foo_encoder_context_t #include "IOStream.h" #include "ChecksumCalculator.h" #include "foo_client_context.h" #include "fooUtils.h" #include "fooBase.h" struct foo_encoder_context_t : public foo_client_context_t { IOStream *m_stream; ChecksumCalculator *m_checksumCalculator; foo_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator); }; #endif // GUARD_foo_encoder_context_tfoo_entry.cpp000066400000000000000000000023071356361734700337520ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/expected/encoder// Generated Code - DO NOT EDIT !! // generated by 'emugen' #include #include #include "foo_client_context.h" #ifndef GL_TRUE extern "C" { void fooAlphaFunc(FooInt func, FooFloat ref); FooBoolean fooIsBuffer(void* stuff); void fooUnsupported(void* params); void fooDoEncoderFlush(FooInt param); void fooTakeConstVoidPtrConstPtr(const void* const* param); }; #endif #ifndef GET_CONTEXT static foo_client_context_t::CONTEXT_ACCESSOR_TYPE *getCurrentContext = NULL; void foo_client_context_t::setContextAccessor(CONTEXT_ACCESSOR_TYPE *f) { getCurrentContext = f; } #define GET_CONTEXT foo_client_context_t * ctx = getCurrentContext() #endif void fooAlphaFunc(FooInt func, FooFloat ref) { GET_CONTEXT; ctx->fooAlphaFunc(ctx, func, ref); } FooBoolean fooIsBuffer(void* stuff) { GET_CONTEXT; if (n == NULL) { LOG(ERROR) << "NULL stuff"; return; } return ctx->fooIsBuffer(ctx, stuff); } void fooUnsupported(void* params) { GET_CONTEXT; ctx->fooUnsupported(ctx, params); } void fooDoEncoderFlush(FooInt param) { GET_CONTEXT; ctx->fooDoEncoderFlush(ctx, param); } void fooTakeConstVoidPtrConstPtr(const void* const* param) { GET_CONTEXT; ctx->fooTakeConstVoidPtrConstPtr(ctx, param); } foo_ftable.h000066400000000000000000000010771356361734700335160ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/expected/encoder// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef __foo_client_ftable_t_h #define __foo_client_ftable_t_h static const struct _foo_funcs_by_name { const char *name; void *proc; } foo_funcs_by_name[] = { {"fooAlphaFunc", (void*)fooAlphaFunc}, {"fooIsBuffer", (void*)fooIsBuffer}, {"fooUnsupported", (void*)fooUnsupported}, {"fooDoEncoderFlush", (void*)fooDoEncoderFlush}, {"fooTakeConstVoidPtrConstPtr", (void*)fooTakeConstVoidPtrConstPtr}, }; static const int foo_num_funcs = sizeof(foo_funcs_by_name) / sizeof(struct _foo_funcs_by_name); #endif foo_opcodes.h000066400000000000000000000005271356361734700337140ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/expected/encoder// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef __GUARD_foo_opcodes_h_ #define __GUARD_foo_opcodes_h_ #define OP_fooAlphaFunc 200 #define OP_fooIsBuffer 201 #define OP_fooUnsupported 202 #define OP_fooDoEncoderFlush 203 #define OP_fooTakeConstVoidPtrConstPtr 204 #define OP_last 205 #endif anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/expected/wrapper/000077500000000000000000000000001356361734700313605ustar00rootroot00000000000000foo_wrapper_context.cpp000066400000000000000000000013331356361734700360740ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/expected/wrapper// Generated Code - DO NOT EDIT !! // generated by 'emugen' #include #include "foo_wrapper_context.h" #include int foo_wrapper_context_t::initDispatchByName(void *(*getProc)(const char *, void *userData), void *userData) { fooAlphaFunc = (fooAlphaFunc_wrapper_proc_t) getProc("fooAlphaFunc", userData); fooIsBuffer = (fooIsBuffer_wrapper_proc_t) getProc("fooIsBuffer", userData); fooUnsupported = (fooUnsupported_wrapper_proc_t) getProc("fooUnsupported", userData); fooDoEncoderFlush = (fooDoEncoderFlush_wrapper_proc_t) getProc("fooDoEncoderFlush", userData); fooTakeConstVoidPtrConstPtr = (fooTakeConstVoidPtrConstPtr_wrapper_proc_t) getProc("fooTakeConstVoidPtrConstPtr", userData); return 0; } foo_wrapper_context.h000066400000000000000000000013411356361734700355400ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/expected/wrapper// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef __foo_wrapper_context_t_h #define __foo_wrapper_context_t_h #include "foo_server_proc.h" #include "foo_types.h" struct foo_wrapper_context_t { fooAlphaFunc_wrapper_proc_t fooAlphaFunc; fooIsBuffer_wrapper_proc_t fooIsBuffer; fooUnsupported_wrapper_proc_t fooUnsupported; fooDoEncoderFlush_wrapper_proc_t fooDoEncoderFlush; fooTakeConstVoidPtrConstPtr_wrapper_proc_t fooTakeConstVoidPtrConstPtr; virtual ~foo_wrapper_context_t() {} typedef foo_wrapper_context_t *CONTEXT_ACCESSOR_TYPE(void); static void setContextAccessor(CONTEXT_ACCESSOR_TYPE *f); int initDispatchByName( void *(*getProc)(const char *name, void *userData), void *userData); }; #endif foo_wrapper_entry.cpp000066400000000000000000000021761356361734700355570ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/expected/wrapper// Generated Code - DO NOT EDIT !! // generated by 'emugen' #include #include #include "foo_wrapper_context.h" #ifndef GL_TRUE extern "C" { void fooAlphaFunc(FooInt func, FooFloat ref); FooBoolean fooIsBuffer(void* stuff); void fooUnsupported(void* params); void fooDoEncoderFlush(FooInt param); void fooTakeConstVoidPtrConstPtr(const void* const* param); }; #endif #ifndef GET_CONTEXT static foo_wrapper_context_t::CONTEXT_ACCESSOR_TYPE *getCurrentContext = NULL; void foo_wrapper_context_t::setContextAccessor(CONTEXT_ACCESSOR_TYPE *f) { getCurrentContext = f; } #define GET_CONTEXT foo_wrapper_context_t * ctx = getCurrentContext() #endif void fooAlphaFunc(FooInt func, FooFloat ref) { GET_CONTEXT; ctx->fooAlphaFunc( func, ref); } FooBoolean fooIsBuffer(void* stuff) { GET_CONTEXT; return ctx->fooIsBuffer( stuff); } void fooUnsupported(void* params) { GET_CONTEXT; ctx->fooUnsupported( params); } void fooDoEncoderFlush(FooInt param) { GET_CONTEXT; ctx->fooDoEncoderFlush( param); } void fooTakeConstVoidPtrConstPtr(const void* const* param) { GET_CONTEXT; ctx->fooTakeConstVoidPtrConstPtr( param); } foo_wrapper_proc.h000066400000000000000000000011601356361734700350160ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/expected/wrapper// Generated Code - DO NOT EDIT !! // generated by 'emugen' #ifndef __foo_wrapper_proc_t_h #define __foo_wrapper_proc_t_h #include "foo_types.h" #include "emugl/common/logging.h" #ifndef foo_APIENTRY #define foo_APIENTRY #endif typedef void (foo_APIENTRY *fooAlphaFunc_wrapper_proc_t) (FooInt, FooFloat); typedef FooBoolean (foo_APIENTRY *fooIsBuffer_wrapper_proc_t) (void*); typedef void (foo_APIENTRY *fooUnsupported_wrapper_proc_t) (void*); typedef void (foo_APIENTRY *fooDoEncoderFlush_wrapper_proc_t) (FooInt); typedef void (foo_APIENTRY *fooTakeConstVoidPtrConstPtr_wrapper_proc_t) (const void* const*); #endif anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/input/000077500000000000000000000000001356361734700272365ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/input/foo.attrib000066400000000000000000000004661356361734700312360ustar00rootroot00000000000000GLOBAL base_opcode 200 encoder_headers "fooUtils.h" "fooBase.h" fooIsBuffer dir stuff in len stuff (4 * sizeof(float)) param_check stuff if (n == NULL) { LOG(ERROR) << "NULL stuff"; return; } fooUnsupported dir params in flag unsupported fooDoEncoderFlush flag flushOnEncode anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/input/foo.in000066400000000000000000000004171356361734700303530ustar00rootroot00000000000000FOO_ENTRY(void, fooAlphaFunc, FooInt func, FooFloat ref) FOO_ENTRY(FooBoolean, fooIsBuffer, void* stuff) FOO_ENTRY(void, fooUnsupported, void* params) FOO_ENTRY(void, fooDoEncoderFlush, FooInt param) FOO_ENTRY(void, fooTakeConstVoidPtrConstPtr, const void* const* param) anbox-0.0~git20191115/external/android-emugl/host/tools/emugen/tests/t.001/input/foo.types000066400000000000000000000002361356361734700311100ustar00rootroot00000000000000FooBoolean 8 %d FooInt 32 %d FooShort 16 %d FooFloat 32 %f FooEnum 32 %08x FooVoid 0 %x FooChar 8 %d FooChar* 32 0x%08x void* 32 0x%08x void*const* 32 0x%08x anbox-0.0~git20191115/external/android-emugl/scripts/000077500000000000000000000000001356361734700222655ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/scripts/gen-headers.sh000077500000000000000000000060771356361734700250200ustar00rootroot00000000000000#!/bin/sh # Copyright (C) 2015 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Run this script to re-generate headers with the gen-entries.py script. set -e export LANG=C export LC_ALL=C PROGDIR=$(dirname "$0") panic () { echo "ERROR: $@" exit 1 } QEMU_TOP_DIR=$(cd $PROGDIR/../../.. && pwd -P) SCRIPT_DIR=android/scripts if [ ! -d "$QEMU_TOP_DIR/$SCRIPT_DIR" ]; then panic "Missing scripts directory: $QEMU_TOP_DIR/$SCRIPT_DIR" fi cd $QEMU_TOP_DIR GEN_ENTRIES=$SCRIPT_DIR/gen-entries.py if [ ! -f "$GEN_ENTRIES" ]; then panic "Missing script: $GEN_ENTRIES" fi FAILURES= # $1: Source file # $2: Target file # $3: gen-entries script. gen_functions_header () { local SRC_FILE="$1" local DST_FILE="$2" local GEN_ENTRIES="$3" if [ ! -f "$SRC_FILE" ]; then echo "ERROR: Missing source file: $SRC_FILE" FAILURES=true else echo "Generating $DST_FILE" $GEN_ENTRIES --mode=functions $SRC_FILE --output=$DST_FILE fi } # $1: Source file # $2: Target file # $3: gen-entries script. gen_funcargs_header () { local SRC_FILE="$1" local DST_FILE="$2" local GEN_ENTRIES="$3" if [ ! -f "$SRC_FILE" ]; then echo "ERROR: Missing source file: $SRC_FILE" FAILURES=true else echo "Generating $DST_FILE" $GEN_ENTRIES --mode=funcargs $SRC_FILE --output=$DST_FILE fi } ## ## libOpenglRender headers. ## LIBRENDER_DIR=distrib/android-emugl/host/libs/libOpenglRender LIBRENDER_INCLUDE=distrib/android-emugl/host/include/OpenglRender gen_funcargs_header \ "$LIBRENDER_DIR"/render_api.entries \ "$LIBRENDER_INCLUDE"/render_api_functions.h \ "$GEN_ENTRIES" ## ## libOpenGLESDispatch headers. ## OPENGLES_DISPATCH_SRCDIR=distrib/android-emugl/host/libs/libOpenGLESDispatch OPENGLES_DISPATCH_INCLUDE=distrib/android-emugl/host/include/OpenGLESDispatch gen_functions_header \ "$OPENGLES_DISPATCH_SRCDIR"/render_egl.entries \ "$OPENGLES_DISPATCH_INCLUDE"/RenderEGL_functions.h \ "$GEN_ENTRIES" gen_functions_header \ "$OPENGLES_DISPATCH_SRCDIR"/render_egl_extensions.entries \ "$OPENGLES_DISPATCH_INCLUDE"/RenderEGL_extensions_functions.h \ "$GEN_ENTRIES" GLES_ENTRIES="gles_common gles_extensions gles1_only gles1_extensions gles2_only \ gles2_extensions gles3_only" for ENTRY in $GLES_ENTRIES; do SRC_FILE=$OPENGLES_DISPATCH_SRCDIR/${ENTRY}.entries DST_FILE=$OPENGLES_DISPATCH_INCLUDE/${ENTRY}_functions.h gen_funcargs_header "$SRC_FILE" "$DST_FILE" "$GEN_ENTRIES" done if [ "$FAILURES" ]; then exit 1 fi anbox-0.0~git20191115/external/android-emugl/shared/000077500000000000000000000000001356361734700220445ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/shared/CMakeLists.txt000066400000000000000000000000741356361734700246050ustar00rootroot00000000000000add_subdirectory(emugl) add_subdirectory(OpenglCodecCommon) anbox-0.0~git20191115/external/android-emugl/shared/OpenglCodecCommon/000077500000000000000000000000001356361734700253775ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/shared/OpenglCodecCommon/CMakeLists.txt000066400000000000000000000005131356361734700301360ustar00rootroot00000000000000set(SOURCES ChecksumCalculator.cpp ChecksumCalculator.h ChecksumCalculatorThreadInfo.cpp ChecksumCalculatorThreadInfo.h CMakeLists.txt ErrorLog.h gl_base_types.h GLDecoderContextData.h glUtils.cpp glUtils.h Makefile ProtocolUtils.h) add_library(OpenglCodecCommon STATIC ${SOURCES}) anbox-0.0~git20191115/external/android-emugl/shared/OpenglCodecCommon/ChecksumCalculator.cpp000066400000000000000000000124251356361734700316630ustar00rootroot00000000000000/* * Copyright (C) 2016 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "ChecksumCalculator.h" #include #include #include // Checklist when implementing new protocol: // 1. update CHECKSUMHELPER_MAX_VERSION // 2. update maxChecksumSize() // 3. update checksumByteSize() // 4. update addBuffer, writeChecksum, resetChecksum, validate // change CHECKSUMHELPER_MAX_VERSION when you want to update the protocol version #define CHECKSUMHELPER_MAX_VERSION 1 // checksum buffer size // Please add a new checksum buffer size when implementing a new protocol, // as well as modifying the maxChecksumSize function. static const size_t kV1ChecksumSize = 8; static constexpr size_t maxChecksumSize() { return 0 > kV1ChecksumSize ? 0 : kV1ChecksumSize; } static const size_t kMaxChecksumSize = maxChecksumSize(); // utility macros to create checksum string at compilation time #define CHECKSUMHELPER_VERSION_STR_PREFIX "ANDROID_EMU_CHECKSUM_HELPER_v" #define CHECKSUMHELPER_MACRO_TO_STR(x) #x #define CHECKSUMHELPER_MACRO_VAL_TO_STR(x) CHECKSUMHELPER_MACRO_TO_STR(x) static const uint32_t kMaxVersion = CHECKSUMHELPER_MAX_VERSION; static const char* kMaxVersionStrPrefix = CHECKSUMHELPER_VERSION_STR_PREFIX; static const char* kMaxVersionStr = CHECKSUMHELPER_VERSION_STR_PREFIX CHECKSUMHELPER_MACRO_VAL_TO_STR(CHECKSUMHELPER_MAX_VERSION); #undef CHECKSUMHELPER_MAX_VERSION #undef CHECKSUMHELPER_VERSION_STR_PREFIX #undef CHECKSUMHELPER_MACRO_TO_STR #undef CHECKSUMHELPER_MACRO_VAL_TO_STR uint32_t ChecksumCalculator::getMaxVersion() {return kMaxVersion;} const char* ChecksumCalculator::getMaxVersionStr() {return kMaxVersionStr;} const char* ChecksumCalculator::getMaxVersionStrPrefix() {return kMaxVersionStrPrefix;} bool ChecksumCalculator::setVersion(uint32_t version) { if (version > kMaxVersion) { // unsupported version LOG_CHECKSUMHELPER("%s: ChecksumCalculator Set Unsupported version Version %d\n", __FUNCTION__, m_version); return false; } if (m_isEncodingChecksum) { // setVersion is called in the middle of encoding checksums LOG_CHECKSUMHELPER("%s: called between addBuffer and writeChecksum\n", __FUNCTION__); return false; } m_version = version; LOG_CHECKSUMHELPER("%s: ChecksumCalculator Set Version %d\n", __FUNCTION__, m_version); return true; } size_t ChecksumCalculator::checksumByteSize() const { switch (m_version) { case 0: return 0; case 1: return sizeof(uint32_t) + sizeof(m_numWrite); default: return 0; } } void ChecksumCalculator::addBuffer(const void* buf, size_t packetLen) { m_isEncodingChecksum = true; switch (m_version) { case 1: m_v1BufferTotalLength += packetLen; break; } } bool ChecksumCalculator::writeChecksum(void* outputChecksum, size_t outputChecksumLen) { if (outputChecksumLen < checksumByteSize()) return false; char *checksumPtr = (char *)outputChecksum; switch (m_version) { case 1: { // protocol v1 is to reverse the packetLen and write it at the end uint32_t val = computeV1Checksum(); memcpy(checksumPtr, &val, sizeof(val)); memcpy(checksumPtr+sizeof(val), &m_numWrite, sizeof(m_numWrite)); break; } } resetChecksum(); m_numWrite++; return true; } void ChecksumCalculator::resetChecksum() { switch (m_version) { case 1: m_v1BufferTotalLength = 0; break; } m_isEncodingChecksum = false; } bool ChecksumCalculator::validate(const void* expectedChecksum, size_t expectedChecksumLen) { size_t checksumSize = checksumByteSize(); if (expectedChecksumLen != checksumSize) { m_numRead++; resetChecksum(); return false; } // buffers for computing the checksum unsigned char sChecksumBuffer[kMaxChecksumSize]; switch (m_version) { case 1: { uint32_t val = computeV1Checksum(); memcpy(sChecksumBuffer, &val, sizeof(val)); memcpy(sChecksumBuffer+sizeof(val), &m_numRead, sizeof(m_numRead)); break; } } bool isValid = !memcmp(sChecksumBuffer, expectedChecksum, checksumSize); m_numRead++; resetChecksum(); return isValid; } uint32_t ChecksumCalculator::computeV1Checksum() { uint32_t revLen = m_v1BufferTotalLength; revLen = (revLen & 0xffff0000) >> 16 | (revLen & 0x0000ffff) << 16; revLen = (revLen & 0xff00ff00) >> 8 | (revLen & 0x00ff00ff) << 8; revLen = (revLen & 0xf0f0f0f0) >> 4 | (revLen & 0x0f0f0f0f) << 4; revLen = (revLen & 0xcccccccc) >> 2 | (revLen & 0x33333333) << 2; revLen = (revLen & 0xaaaaaaaa) >> 1 | (revLen & 0x55555555) << 1; return revLen; } anbox-0.0~git20191115/external/android-emugl/shared/OpenglCodecCommon/ChecksumCalculator.h000066400000000000000000000167341356361734700313370ustar00rootroot00000000000000/* * Copyright (C) 2016 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include // Set TRACE_CHECKSUMHELPER to 1 to debug creation/destruction of GLprotocol // instances. #define TRACE_CHECKSUMHELPER 0 #if TRACE_CHECKSUMHELPER #define LOG_CHECKSUMHELPER(...) fprintf(stderr, __VA_ARGS__) #else #define LOG_CHECKSUMHELPER(...) #endif // ChecksumCalculator adds checksum as an array of bytes to GL pipe communication, which // size depends on the protocol version. Each pipe should use one ChecksumCalculator. // It can: // (1) take a list of buffers one by one and compute their checksum string, // in this case the checksum should be as the data in those buffers are // concatenated; // (2) compute the checksum of the buffer list, then either write them into // a buffer provided by user, or compare it against a checksum provided // by user // (3) support different checksum version in future. // // For backward compatibility, checksum version 0 behaves the same as there is // no checksum (i.e., checksumByteSize returns 0, validate always returns true, // addBuffer and writeCheckSum does nothing). // // Notice that to detect package lost, ChecksumCalculator also keeps track of how // many times it generates/validates checksums, and might use it as part of the // checksum. // // To evaluate checksums from a list of data buffers buf1, buf2... Please call // addBuffer(buf1, buf1len), addBuffer(buf2, buf2len) ... in order. // Then if the checksum needs to be encoded into a buffer, one needs to allocate // a checksum buffer with size checksumByteSize(), and call // writeChecksum(checksumBuffer) to write the checksum to the buffer. // If the checksum needs to be validated against an existing one, one needs to // call validate(existChecksum, existChecksumLen). // // The checksum generator and validator must be set to the same version, and // the validator must check ALL checksums in the order they are generated, // otherwise the validation function will return false. // // It is allowed to change the checksum version between calculating two // checksums. This is designed for backward compatibility reason. // // Example 1, encoding and decoding: // // bool testChecksum(void* buf, size_t bufLen) { // // encoding message // ChecksumCalculator encoder; // encoder.setVersion(1); // encoder.addBuffer(buf, bufLen); // std::vector message(bufLen + encoder.checksumByteSize()); // memcpy(&message[0], buf, bufLen); // encoder.writeChecksum(&message[0] + bufLen, encoder.checksumByteSize()); // // // decoding message // ChecksumCalculator decoder; // decoder.setVersion(1); // decoder.addBuffer(&message[0], bufLen); // return decoder.validate(&message[0] + bufLen, decoder.checksumByteSize()); // } // The return value is true. // // Example 2, decoding will fail if the order of messages is wrong: // // bool testChecksumOrder(void* buf1, size_t bufLen1, // void* buf2, size_t bufLen2) { // // encoding messages // ChecksumCalculator encoder; // encoder.setVersion(1); // // std::vector message1(bufLen1 + encoder.checksumByteSize()); // std::vector message2(bufLen2 + encoder.checksumByteSize()); // // encoder.addBuffer(buf1, bufLen1); // std::vector message1(bufLen1 + encoder.checksumByteSize()); // memcpy(&message1[0], buf1, bufLen1); // encoder.writeChecksum(&message1[0] + bufLen1, encoder.checksumByteSize()); // // encoder.addBuffer(buf2, bufLen2); // std::vector message2(bufLen2 + encoder.checksumByteSize()); // memcpy(&message2[0], buf2, bufLen2); // encoder.writeChecksum(&message2[0] + bufLen2, encoder.checksumByteSize()); // // // decoding messages // ChecksumCalculator decoder; // decoder.setVersion(1); // decoder.addBuffer(&message2[0], bufLen2); // // returns false because the decoding order is not consistent with // // encoding order // if (!decoder.validate(&message2[0]+bufLen2, decoder.checksumByteSize())) { // return false; // } // // decoder.addBuffer(&message1[0], bufLen1); // if (!decoder.validate(&message1[0]+bufLen1, decoder.checksumByteSize())) { // return false; // } // // return false; // } class ChecksumCalculator { public: // Get and set current checksum version uint32_t getVersion() const { return m_version; } // Call setVersion to set a checksum version. It should be called before // addBuffer(), writeChecksum() and validate(). And it should be called // exact once per rendering thread if both host and guest support checksum. // It won't be called if either host or guest does not support checksum. bool setVersion(uint32_t version); // Maximum supported checksum version static uint32_t getMaxVersion(); // A version string that looks like "ANDROID_EMU_CHECKSUM_HELPER_v1" // Used multiple times when the guest queries the maximum supported version // from the host. // The library owns the returned pointer. The returned pointer will be // deconstructed when unloading library. static const char* getMaxVersionStr(); static const char* getMaxVersionStrPrefix(); // Size of checksum in the current version size_t checksumByteSize() const; // Update the current checksum value from the data // at |buf| of |bufLen| bytes. Once all buffers // have been added, call writeChecksum() to store // the final checksum value and reset its state. void addBuffer(const void* buf, size_t bufLen); // Write the checksum from the list of buffers to outputChecksum // Will reset the list of buffers by calling resetChecksum. // Return false if the buffer is not long enough // Please query buffer size from checksumByteSize() bool writeChecksum(void* outputChecksum, size_t outputChecksumLen); // Restore the states for computing checksums. // Automatically called at the end of writeChecksum and validate. // Can also be used to abandon the current checksum being calculated. // Notes: it doesn't update the internal read / write counter void resetChecksum(); // Calculate the checksum from the list of buffers and // compare it with the checksum encoded in expectedChecksum // Will reset the list of buffers by calling resetChecksum. bool validate(const void* expectedChecksum, size_t expectedChecksumLen); protected: uint32_t m_version = 0; // A temporary state used to compute the total length of a list of buffers, // if addBuffer is called. uint32_t m_numRead = 0; uint32_t m_numWrite = 0; // m_isEncodingChecksum is true when between addBuffer and writeChecksum bool m_isEncodingChecksum = false; private: // Compute a 32bit checksum // Used in protocol v1 uint32_t computeV1Checksum(); // The buffer used in protocol version 1 to compute checksum. uint32_t m_v1BufferTotalLength = 0; }; ChecksumCalculatorThreadInfo.cpp000066400000000000000000000070611356361734700335500ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/shared/OpenglCodecCommon/* * Copyright (C) 2016 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "ChecksumCalculatorThreadInfo.h" #include "emugl/common/crash_reporter.h" #include "emugl/common/lazy_instance.h" #include "emugl/common/thread_store.h" #include #include #include namespace { class ChecksumCalculatorThreadStore : public ::emugl::ThreadStore { public: ChecksumCalculatorThreadStore() : ::emugl::ThreadStore(NULL) {} }; #ifdef TRACE_CHECKSUMHELPER std::atomic sNumInstances(0); #endif // TRACE_CHECKSUMHELPER } static ::emugl::LazyInstance s_tls = LAZY_INSTANCE_INIT; static ChecksumCalculatorThreadInfo* getChecksumCalculatorThreadInfo() { return static_cast(s_tls->get()); } ChecksumCalculatorThreadInfo::ChecksumCalculatorThreadInfo() { LOG_CHECKSUMHELPER( "%s: Checksum thread created (%u instances)\n", __FUNCTION__, (size_t)sNumInstances); s_tls->set(this); } ChecksumCalculatorThreadInfo::~ChecksumCalculatorThreadInfo() { LOG_CHECKSUMHELPER( "%s: GLprotocol destroyed (%u instances)\n", __FUNCTION__, (size_t)sNumInstances); s_tls->set(NULL); } uint32_t ChecksumCalculatorThreadInfo::getVersion() { return getChecksumCalculatorThreadInfo()->m_protocol.getVersion(); } bool ChecksumCalculatorThreadInfo::setVersion(uint32_t version) { return getChecksumCalculatorThreadInfo()->m_protocol.setVersion(version); } size_t ChecksumCalculatorThreadInfo::checksumByteSize() { return getChecksumCalculatorThreadInfo()->m_protocol.checksumByteSize(); } bool ChecksumCalculatorThreadInfo::writeChecksum(void* buf, size_t bufLen, void* outputChecksum, size_t outputChecksumLen) { ChecksumCalculator& protocol = getChecksumCalculatorThreadInfo()->m_protocol; protocol.addBuffer(buf, bufLen); return protocol.writeChecksum(outputChecksum, outputChecksumLen); } bool ChecksumCalculatorThreadInfo::validate(void* buf, size_t bufLen, void* checksum, size_t checksumLen) { ChecksumCalculator& protocol = getChecksumCalculatorThreadInfo()->m_protocol; protocol.addBuffer(buf, bufLen); return protocol.validate(checksum, checksumLen); } void ChecksumCalculatorThreadInfo::validOrDie(void* buf, size_t bufLen, void* checksum, size_t checksumLen, const char* message) { // We should actually call crashhandler_die(message), but I don't think we // can link to that library from here if (!validate(buf, bufLen, checksum, checksumLen)) { emugl_crash_reporter(emugl::LogLevel::FATAL, message); } } anbox-0.0~git20191115/external/android-emugl/shared/OpenglCodecCommon/ChecksumCalculatorThreadInfo.h000066400000000000000000000034361356361734700332760ustar00rootroot00000000000000/* * Copyright (C) 2016 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include "ChecksumCalculator.h" // ChecksumCalculatorThreadInfo is the class that makes ChecksumCalculator // thread-safe. On the host, please only use ChecksumCalculator through this // class. class ChecksumCalculatorThreadInfo { public: ChecksumCalculatorThreadInfo(); ~ChecksumCalculatorThreadInfo(); static uint32_t getVersion(); static bool setVersion(uint32_t version); static uint32_t getMaxVersion(); static const char* getMaxVersionString() { return ChecksumCalculator::getMaxVersionStr(); } static size_t checksumByteSize(); static bool writeChecksum(void* buf, size_t bufLen, void* outputChecksum, size_t outputChecksumLen); static bool validate(void* buf, size_t bufLen, void* checksum, size_t checksumLen); static void validOrDie(void* buf, size_t bufLen, void* checksum, size_t checksumLen, const char* message); private: ChecksumCalculator m_protocol; }; anbox-0.0~git20191115/external/android-emugl/shared/OpenglCodecCommon/ErrorLog.h000066400000000000000000000015571356361734700273130ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _ERROR_LOG_H_ #define _ERROR_LOG_H_ #include #define ERR(...) fprintf(stderr, __VA_ARGS__) #define EMUGL_DEBUG #ifdef EMUGL_DEBUG # define DBG(...) fprintf(stderr, __VA_ARGS__) #else # define DBG(...) ((void)0) #endif #endif // _ERROR_LOG_H_ anbox-0.0~git20191115/external/android-emugl/shared/OpenglCodecCommon/GLDecoderContextData.h000066400000000000000000000051061356361734700315010ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include #include #include // Convenient class used to hold the common context data shared // by both the GLESv1 and GLESv2 decoders. This corresponds to // vertex attribute buffers. class GLDecoderContextData { public: // List of supported vertex attribute indices, as they appear in // a glVertexAttribPointer() call. typedef enum { VERTEX_LOCATION = 0, NORMAL_LOCATION = 1, COLOR_LOCATION = 2, POINTSIZE_LOCATION = 3, TEXCOORD0_LOCATION = 4, TEXCOORD1_LOCATION = 5, TEXCOORD2_LOCATION = 6, TEXCOORD3_LOCATION = 7, TEXCOORD4_LOCATION = 8, TEXCOORD5_LOCATION = 9, TEXCOORD6_LOCATION = 10, TEXCOORD7_LOCATION = 11, MATRIXINDEX_LOCATION = 12, WEIGHT_LOCATION = 13, LAST_LOCATION = 14 } PointerDataLocation; // Default constructor. GLDecoderContextData(int numLocations = kMaxVertexAttributes) : mPointerData(), mNumLocations(static_cast(numLocations)) { mPointerData.resize(mNumLocations); } // Store |len| bytes from |data| into the buffer associated with // vertex attribute index |loc|. void storePointerData(unsigned int loc, void *data, size_t len) { if (loc < mNumLocations) { std::string& ptrData = mPointerData[loc]; ptrData.assign(reinterpret_cast(data), len); } else { // User error, don't do anything here } } // Return pointer to data associated with vertex attribute index |loc| void* pointerData(unsigned int loc) const { if (loc < mNumLocations) { return const_cast(mPointerData[loc].c_str()); } else { // User error. Return nullptr. return nullptr; } } private: static const int kMaxVertexAttributes = 64; std::vector mPointerData; unsigned mNumLocations = 0; }; anbox-0.0~git20191115/external/android-emugl/shared/OpenglCodecCommon/Makefile000066400000000000000000000003231356361734700270350ustar00rootroot00000000000000 ROOT=../.. include $(ROOT)/make/commondefs CXXFILES = TcpStream.cpp GLClientState.cpp glUtils.cpp CXXINCS += -I$(ROOT)/libs/GLESv1 -I$(ROOT)/include LIBRARY_NAME = libcodecCommon.a include $(COMMONRULES) anbox-0.0~git20191115/external/android-emugl/shared/OpenglCodecCommon/ProtocolUtils.h000066400000000000000000000123121356361734700303710ustar00rootroot00000000000000#ifndef EMUGL_PROTOCOL_UTILS_H #define EMUGL_PROTOCOL_UTILS_H #include #include #include #include namespace emugl { // Helper macro #define COMPILE_ASSERT(cond) static char kAssert##__LINE__[1 - 2 * !(cond)] __attribute__((unused)) = { 0 } // Helper template: is_pointer. // is_pointer::value is true iff |T| is a pointer type. template struct is_pointer { static const bool value = false; }; template struct is_pointer { static const bool value = true; }; // A helper template to extract values form the wire protocol stream // and convert them to appropriate host values. // // The wire protocol uses 32-bit exclusively when transferring // GLintptr or GLsizei values, as well as opaque handles like GLeglImage, // from the guest (even when the guest is 64-bit). // // The corresponding host definitions depend on the host bitness. For // example, GLintptr is 64-bit on linux-x86_64. The following is a set // of templates that can simplify the conversion of protocol values // into host ones. // // The most important one is: // // unpack(const void* ptr) // // Which reads bytes from |ptr|, using |SIZE_TYPE| as the underlying // sized-integer specifier (e.g. 'uint32_t'), and converting the result // into a |HOST_TYPE| value. For example: // // unpack(ptr + 12); // // will read a 4-byte value from |ptr + 12| and convert it into // an EGLImage, which is a host void*. The template detects host // pointer types to perform proper type casting. // // TODO(digit): Add custom unpackers to handle generic opaque void* values. // and map them to unique 32-bit values. template struct UnpackerT {}; template struct UnpackerT { static inline T unpack(const void* ptr) { COMPILE_ASSERT(sizeof(T) == sizeof(S)); return (T)(*(S*)(ptr)); } }; template struct UnpackerT { static inline T unpack(const void* ptr) { return (T)(uintptr_t)(*(S*)(ptr)); } }; template <> struct UnpackerT { static inline float unpack(const void* ptr) { union { float f; uint32_t u; } v; v.u = *(uint32_t*)(ptr); return v.f; } }; template <> struct UnpackerT { static inline double unpack(const void* ptr) { union { double d; uint32_t u; } v; v.u = *(uint64_t*)(ptr); return v.d; } }; template <> struct UnpackerT { static inline ssize_t unpack(const void* ptr) { return (ssize_t)*(int32_t*)(ptr); } }; template inline T Unpack(const void* ptr) { return UnpackerT::value>::unpack(ptr); } // Helper class used to ensure input buffers passed to EGL/GL functions // are properly aligned (preventing crashes with some backends). // Usage example: // // InputBuffer inputBuffer(ptr, size); // glDoStuff(inputBuffer.get()); // // inputBuffer.get() will return the original value of |ptr| if it was // aligned on an 8-byte boundary. Otherwise, it will return the address // of an aligned heap-allocated copy of the original |size| bytes starting // from |ptr|. The heap block is released at scope exit. class InputBuffer { public: InputBuffer(const void* input, size_t size, size_t align = 8) : mBuff(input), mIsCopy(false) { if (((uintptr_t)input & (align - 1U)) != 0) { void* newBuff = malloc(size); memcpy(newBuff, input, size); mBuff = newBuff; mIsCopy = true; } } ~InputBuffer() { if (mIsCopy) { free((void*)mBuff); } } const void* get() const { return mBuff; } private: const void* mBuff; bool mIsCopy; }; // Helper class used to ensure that output buffers passed to EGL/GL functions // are aligned on 8-byte addresses. // Usage example: // // ptr = stream->alloc(size); // OutputBuffer outputBuffer(ptr, size); // glGetStuff(outputBuffer.get()); // outputBuffer.flush(); // // outputBuffer.get() returns the original value of |ptr| if it was already // aligned on an 8=byte boundary. Otherwise, it returns the size of an heap // allocated zeroed buffer of |size| bytes. // // outputBuffer.flush() copies the content of the heap allocated buffer back // to |ptr| explictly, if needed. If a no-op if |ptr| was aligned. class OutputBuffer { public: OutputBuffer(unsigned char* ptr, size_t size, size_t align = 8) : mOrgBuff(ptr), mBuff(ptr), mSize(size) { if (((uintptr_t)ptr & (align - 1U)) != 0) { void* newBuff = calloc(1, size); mBuff = newBuff; } } ~OutputBuffer() { if (mBuff != mOrgBuff) { free(mBuff); } } void* get() const { return mBuff; } void flush() { if (mBuff != mOrgBuff) { memcpy(mOrgBuff, mBuff, mSize); } } private: unsigned char* mOrgBuff; void* mBuff; size_t mSize; }; } // namespace emugl #endif // EMUGL_PROTOCOL_UTILS_H anbox-0.0~git20191115/external/android-emugl/shared/OpenglCodecCommon/glUtils.cpp000066400000000000000000000263561356361734700275420ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "glUtils.h" #include "ErrorLog.h" #include size_t glSizeof(GLenum type) { size_t retval = 0; switch(type) { case GL_BYTE: case GL_UNSIGNED_BYTE: retval = 1; break; case GL_SHORT: case GL_UNSIGNED_SHORT: case GL_HALF_FLOAT_OES: retval = 2; break; case GL_INT: case GL_FLOAT: case GL_FIXED: case GL_BOOL: retval = 4; break; #ifdef GL_DOUBLE case GL_DOUBLE: retval = 8; break; #endif case GL_FLOAT_VEC2: case GL_INT_VEC2: case GL_BOOL_VEC2: retval = 8; break; case GL_INT_VEC3: case GL_BOOL_VEC3: case GL_FLOAT_VEC3: retval = 12; break; case GL_FLOAT_VEC4: case GL_BOOL_VEC4: case GL_INT_VEC4: case GL_FLOAT_MAT2: retval = 16; break; case GL_FLOAT_MAT3: retval = 36; break; case GL_FLOAT_MAT4: retval = 64; break; case GL_SAMPLER_2D: case GL_SAMPLER_CUBE: retval = 4; break; default: ERR("**** ERROR unknown type 0x%x (%s,%d)\n", type, __FUNCTION__,__LINE__); } return retval; } size_t glUtilsParamSize(GLenum param) { size_t s = 0; switch(param) { case GL_DEPTH_TEST: case GL_DEPTH_FUNC: case GL_DEPTH_BITS: case GL_MAX_CLIP_PLANES: case GL_GREEN_BITS: case GL_MAX_MODELVIEW_STACK_DEPTH: case GL_MAX_PROJECTION_STACK_DEPTH: case GL_MAX_TEXTURE_STACK_DEPTH: case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES: case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES: case GL_NUM_COMPRESSED_TEXTURE_FORMATS: case GL_MAX_TEXTURE_SIZE: case GL_TEXTURE_GEN_MODE_OES: case GL_TEXTURE_ENV_MODE: case GL_FOG_MODE: case GL_FOG_DENSITY: case GL_FOG_START: case GL_FOG_END: case GL_SPOT_EXPONENT: case GL_CONSTANT_ATTENUATION: case GL_LINEAR_ATTENUATION: case GL_QUADRATIC_ATTENUATION: case GL_SHININESS: case GL_LIGHT_MODEL_TWO_SIDE: case GL_POINT_SIZE: case GL_POINT_SIZE_MIN: case GL_POINT_SIZE_MAX: case GL_POINT_FADE_THRESHOLD_SIZE: case GL_CULL_FACE_MODE: case GL_FRONT_FACE: case GL_SHADE_MODEL: case GL_DEPTH_WRITEMASK: case GL_DEPTH_CLEAR_VALUE: case GL_STENCIL_FAIL: case GL_STENCIL_PASS_DEPTH_FAIL: case GL_STENCIL_PASS_DEPTH_PASS: case GL_STENCIL_REF: case GL_STENCIL_WRITEMASK: case GL_MATRIX_MODE: case GL_MODELVIEW_STACK_DEPTH: case GL_PROJECTION_STACK_DEPTH: case GL_TEXTURE_STACK_DEPTH: case GL_ALPHA_TEST_FUNC: case GL_ALPHA_TEST_REF: case GL_ALPHA_TEST: case GL_BLEND_DST: case GL_BLEND_SRC: case GL_BLEND: case GL_LOGIC_OP_MODE: case GL_SCISSOR_TEST: case GL_MAX_TEXTURE_UNITS: case GL_ACTIVE_TEXTURE: case GL_ALPHA_BITS: case GL_ARRAY_BUFFER_BINDING: case GL_BLUE_BITS: case GL_CLIENT_ACTIVE_TEXTURE: case GL_CLIP_PLANE0: case GL_CLIP_PLANE1: case GL_CLIP_PLANE2: case GL_CLIP_PLANE3: case GL_CLIP_PLANE4: case GL_CLIP_PLANE5: case GL_COLOR_ARRAY: case GL_COLOR_ARRAY_BUFFER_BINDING: case GL_COLOR_ARRAY_SIZE: case GL_COLOR_ARRAY_STRIDE: case GL_COLOR_ARRAY_TYPE: case GL_COLOR_LOGIC_OP: case GL_COLOR_MATERIAL: case GL_PACK_ALIGNMENT: case GL_PERSPECTIVE_CORRECTION_HINT: case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES: case GL_POINT_SIZE_ARRAY_STRIDE_OES: case GL_POINT_SIZE_ARRAY_TYPE_OES: case GL_POINT_SMOOTH: case GL_POINT_SMOOTH_HINT: case GL_POINT_SPRITE_OES: case GL_COORD_REPLACE_OES: case GL_COMBINE_ALPHA: case GL_SRC0_RGB: case GL_SRC1_RGB: case GL_SRC2_RGB: case GL_OPERAND0_RGB: case GL_OPERAND1_RGB: case GL_OPERAND2_RGB: case GL_SRC0_ALPHA: case GL_SRC1_ALPHA: case GL_SRC2_ALPHA: case GL_OPERAND0_ALPHA: case GL_OPERAND1_ALPHA: case GL_OPERAND2_ALPHA: case GL_RGB_SCALE: case GL_ALPHA_SCALE: case GL_COMBINE_RGB: case GL_POLYGON_OFFSET_FACTOR: case GL_POLYGON_OFFSET_FILL: case GL_POLYGON_OFFSET_UNITS: case GL_RED_BITS: case GL_RESCALE_NORMAL: case GL_SAMPLE_ALPHA_TO_COVERAGE: case GL_SAMPLE_ALPHA_TO_ONE: case GL_SAMPLE_BUFFERS: case GL_SAMPLE_COVERAGE: case GL_SAMPLE_COVERAGE_INVERT: case GL_SAMPLE_COVERAGE_VALUE: case GL_SAMPLES: case GL_STENCIL_BITS: case GL_STENCIL_CLEAR_VALUE: case GL_STENCIL_FUNC: case GL_STENCIL_TEST: case GL_STENCIL_VALUE_MASK: case GL_STENCIL_BACK_FUNC: case GL_STENCIL_BACK_VALUE_MASK: case GL_STENCIL_BACK_REF: case GL_STENCIL_BACK_FAIL: case GL_STENCIL_BACK_PASS_DEPTH_FAIL: case GL_STENCIL_BACK_PASS_DEPTH_PASS: case GL_STENCIL_BACK_WRITEMASK: case GL_TEXTURE_2D: case GL_TEXTURE_BINDING_2D: case GL_TEXTURE_BINDING_CUBE_MAP: case GL_TEXTURE_BINDING_EXTERNAL_OES: case GL_TEXTURE_COORD_ARRAY: case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING: case GL_TEXTURE_COORD_ARRAY_SIZE: case GL_TEXTURE_COORD_ARRAY_STRIDE: case GL_TEXTURE_COORD_ARRAY_TYPE: case GL_UNPACK_ALIGNMENT: case GL_VERTEX_ARRAY: case GL_VERTEX_ARRAY_BUFFER_BINDING: case GL_VERTEX_ARRAY_SIZE: case GL_VERTEX_ARRAY_STRIDE: case GL_VERTEX_ARRAY_TYPE: case GL_SPOT_CUTOFF: case GL_TEXTURE_MIN_FILTER: case GL_TEXTURE_MAG_FILTER: case GL_TEXTURE_WRAP_S: case GL_TEXTURE_WRAP_T: case GL_GENERATE_MIPMAP: case GL_GENERATE_MIPMAP_HINT: case GL_RENDERBUFFER_WIDTH_OES: case GL_RENDERBUFFER_HEIGHT_OES: case GL_RENDERBUFFER_INTERNAL_FORMAT_OES: case GL_RENDERBUFFER_RED_SIZE_OES: case GL_RENDERBUFFER_GREEN_SIZE_OES: case GL_RENDERBUFFER_BLUE_SIZE_OES: case GL_RENDERBUFFER_ALPHA_SIZE_OES: case GL_RENDERBUFFER_DEPTH_SIZE_OES: case GL_RENDERBUFFER_STENCIL_SIZE_OES: case GL_RENDERBUFFER_BINDING: case GL_FRAMEBUFFER_BINDING: case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES: case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES: case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES: case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES: case GL_FENCE_STATUS_NV: case GL_FENCE_CONDITION_NV: case GL_TEXTURE_WIDTH_QCOM: case GL_TEXTURE_HEIGHT_QCOM: case GL_TEXTURE_DEPTH_QCOM: case GL_TEXTURE_INTERNAL_FORMAT_QCOM: case GL_TEXTURE_FORMAT_QCOM: case GL_TEXTURE_TYPE_QCOM: case GL_TEXTURE_IMAGE_VALID_QCOM: case GL_TEXTURE_NUM_LEVELS_QCOM: case GL_TEXTURE_TARGET_QCOM: case GL_TEXTURE_OBJECT_VALID_QCOM: case GL_BLEND_EQUATION_RGB_OES: case GL_BLEND_EQUATION_ALPHA_OES: case GL_BLEND_DST_RGB_OES: case GL_BLEND_SRC_RGB_OES: case GL_BLEND_DST_ALPHA_OES: case GL_BLEND_SRC_ALPHA_OES: case GL_MAX_LIGHTS: case GL_SHADER_TYPE: case GL_DELETE_STATUS: case GL_COMPILE_STATUS: case GL_INFO_LOG_LENGTH: case GL_SHADER_SOURCE_LENGTH: case GL_CURRENT_PROGRAM: case GL_LINK_STATUS: case GL_VALIDATE_STATUS: case GL_ATTACHED_SHADERS: case GL_ACTIVE_UNIFORMS: case GL_ACTIVE_ATTRIBUTES: case GL_SUBPIXEL_BITS: case GL_MAX_CUBE_MAP_TEXTURE_SIZE: case GL_NUM_SHADER_BINARY_FORMATS: case GL_SHADER_COMPILER: case GL_MAX_VERTEX_ATTRIBS: case GL_MAX_VERTEX_UNIFORM_VECTORS: case GL_MAX_VARYING_VECTORS: case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS: case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS: case GL_MAX_FRAGMENT_UNIFORM_VECTORS: case GL_MAX_RENDERBUFFER_SIZE: case GL_MAX_TEXTURE_IMAGE_UNITS: case GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES: case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES: case GL_LINE_WIDTH: s = 1; break; case GL_ALIASED_LINE_WIDTH_RANGE: case GL_ALIASED_POINT_SIZE_RANGE: case GL_DEPTH_RANGE: case GL_MAX_VIEWPORT_DIMS: case GL_SMOOTH_POINT_SIZE_RANGE: case GL_SMOOTH_LINE_WIDTH_RANGE: s= 2; break; case GL_SPOT_DIRECTION: case GL_POINT_DISTANCE_ATTENUATION: case GL_CURRENT_NORMAL: s = 3; break; case GL_CURRENT_VERTEX_ATTRIB: case GL_CURRENT_TEXTURE_COORDS: case GL_CURRENT_COLOR: case GL_FOG_COLOR: case GL_AMBIENT: case GL_DIFFUSE: case GL_SPECULAR: case GL_EMISSION: case GL_POSITION: case GL_LIGHT_MODEL_AMBIENT: case GL_TEXTURE_ENV_COLOR: case GL_SCISSOR_BOX: case GL_VIEWPORT: case GL_TEXTURE_CROP_RECT_OES: case GL_COLOR_CLEAR_VALUE: case GL_COLOR_WRITEMASK: case GL_AMBIENT_AND_DIFFUSE: case GL_BLEND_COLOR: s = 4; break; case GL_MODELVIEW_MATRIX: case GL_PROJECTION_MATRIX: case GL_TEXTURE_MATRIX: s = 16; break; default: ERR("glUtilsParamSize: unknow param 0x%08x\n", param); s = 1; // assume 1 } return s; } void glUtilsPackPointerData(unsigned char *dst, unsigned char *src, int size, GLenum type, unsigned int stride, unsigned int datalen) { unsigned int vsize = size * glSizeof(type); if (stride == 0) stride = vsize; if (stride == vsize) { memcpy(dst, src, datalen); } else { for (unsigned int i = 0; i < datalen; i += vsize) { memcpy(dst, src, vsize); dst += vsize; src += stride; } } } int glUtilsPixelBitSize(GLenum format, GLenum type) { int components = 0; int componentsize = 0; int pixelsize = 0; switch(type) { case GL_BYTE: case GL_UNSIGNED_BYTE: componentsize = 8; break; case GL_SHORT: case GL_UNSIGNED_SHORT: case GL_UNSIGNED_SHORT_5_6_5: case GL_UNSIGNED_SHORT_4_4_4_4: case GL_UNSIGNED_SHORT_5_5_5_1: case GL_RGB565_OES: case GL_RGB5_A1_OES: case GL_RGBA4_OES: pixelsize = 16; break; case GL_INT: case GL_UNSIGNED_INT: case GL_FLOAT: case GL_FIXED: case GL_UNSIGNED_INT_24_8_OES: pixelsize = 32; break; default: ERR("glUtilsPixelBitSize: unknown pixel type - assuming pixel data 0\n"); componentsize = 0; } if (pixelsize == 0) { switch(format) { #if 0 case GL_RED: case GL_GREEN: case GL_BLUE: #endif case GL_ALPHA: case GL_LUMINANCE: case GL_DEPTH_COMPONENT: case GL_DEPTH_STENCIL_OES: components = 1; break; case GL_LUMINANCE_ALPHA: components = 2; break; case GL_RGB: #if 0 case GL_BGR: #endif components = 3; break; case GL_RGBA: case GL_BGRA_EXT: components = 4; break; default: ERR("glUtilsPixelBitSize: unknown pixel format...\n"); components = 0; } pixelsize = components * componentsize; } return pixelsize; } anbox-0.0~git20191115/external/android-emugl/shared/OpenglCodecCommon/glUtils.h000066400000000000000000000021261356361734700271740ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include #include #include #include #ifdef __cplusplus extern "C" { #endif size_t glSizeof(GLenum type); size_t glUtilsParamSize(GLenum param); void glUtilsPackPointerData(unsigned char *dst, unsigned char *str, int size, GLenum type, unsigned int stride, unsigned int datalen); int glUtilsPixelBitSize(GLenum format, GLenum type); #ifdef __cplusplus } #endif anbox-0.0~git20191115/external/android-emugl/shared/OpenglCodecCommon/gl_base_types.h000066400000000000000000000036401356361734700303730ustar00rootroot00000000000000/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __GL_BASE_TYPES__H #define __GL_BASE_TYPES__H #include #ifndef gles1_APIENTRY #define gles1_APIENTRY KHRONOS_APIENTRY #endif #ifndef gles2_APIENTRY #define gles2_APIENTRY KHRONOS_APIENTRY #endif typedef void GLvoid; typedef unsigned int GLenum; typedef unsigned char GLboolean; typedef unsigned int GLbitfield; typedef char GLchar; typedef khronos_int8_t GLbyte; typedef short GLshort; typedef int GLint; typedef int GLsizei; typedef khronos_uint8_t GLubyte; typedef unsigned short GLushort; typedef unsigned int GLuint; typedef khronos_float_t GLfloat; typedef khronos_float_t GLclampf; typedef khronos_int32_t GLfixed; typedef khronos_int32_t GLclampx; typedef khronos_intptr_t GLintptr; typedef khronos_ssize_t GLsizeiptr; typedef char *GLstr; /* JR XXX Treating this as an in handle - is this correct? */ typedef void * GLeglImageOES; /* ErrorCode */ #ifndef GL_INVALID_ENUM #define GL_NO_ERROR 0 #define GL_INVALID_ENUM 0x0500 #define GL_INVALID_VALUE 0x0501 #define GL_INVALID_OPERATION 0x0502 #define GL_STACK_OVERFLOW 0x0503 #define GL_STACK_UNDERFLOW 0x0504 #define GL_OUT_OF_MEMORY 0x0505 #endif #endif anbox-0.0~git20191115/external/android-emugl/shared/emugl/000077500000000000000000000000001356361734700231555ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/shared/emugl/CMakeLists.txt000066400000000000000000000000311356361734700257070ustar00rootroot00000000000000add_subdirectory(common) anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/000077500000000000000000000000001356361734700244455ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/CMakeLists.txt000066400000000000000000000012621356361734700272060ustar00rootroot00000000000000set(COMMON_SOURCES condition_variable.h crash_reporter.cpp crash_reporter.h id_to_object_map.cpp id_to_object_map.h lazy_instance.cpp lazy_instance.h logging.cpp logging.h message_channel.cpp message_channel.h mutex.h mutex_unittest.cpp pod_vector.cpp pod_vector.h scoped_pointer_vector.h shared_library.cpp shared_library.h smart_ptr.cpp smart_ptr.h sockets.cpp sockets.h thread.h thread_pthread.cpp thread_store.cpp thread_store.h thread_unittest.cpp unique_integer_map.h) add_library(emugl_common STATIC ${COMMON_SOURCES}) target_link_libraries(emugl_common dl pthread) anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/condition_variable.h000066400000000000000000000044141356361734700304540ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef EMUGL_CONDITION_VARIABLE_H #define EMUGL_CONDITION_VARIABLE_H #include "emugl/common/mutex.h" #include "emugl/common/pod_vector.h" #ifdef _WIN32 #include #else #include #endif namespace emugl { // A class that implements a condition variable, which can be used in // association with a Mutex to blocking-wait for specific conditions. // Useful to implement various synchronization data structures. // For an example, see ::emugl::MessageChannel. class ConditionVariable { public: #ifdef _WIN32 // Default constructor. ConditionVariable(); // Destructor. ~ConditionVariable(); // Wait until the condition variable is signaled. Note that spurious // wakeups are always a possibility, so always check the condition // in a loop, i.e. do: // // while (!condition) { condVar.wait(&lock); } // // instead of: // // if (!condition) { condVar.wait(&lock); } // void wait(Mutex* userLock); // Signal that a condition was reached. This will wake at most one // waiting thread that is blocked on wait(). void signal(); private: PodVector mWaiters; Mutex mLock; #else // !_WIN32 // Note: on Posix systems, make it a naive wrapper around pthread_cond_t. ConditionVariable() { pthread_cond_init(&mCond, NULL); } ~ConditionVariable() { pthread_cond_destroy(&mCond); } void wait(Mutex* userLock) { pthread_cond_wait(&mCond, &userLock->mLock); } void signal() { pthread_cond_signal(&mCond); } private: pthread_cond_t mCond; #endif // !_WIN32 }; } // namespace emugl #endif // EMUGL_CONDITION_VARIABLE_H anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/condition_variable_unittest.cpp000066400000000000000000000014621356361734700327460ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "emugl/common/condition_variable.h" #include "emugl/common/mutex.h" #include namespace emugl { TEST(ConditionVariable, init) { ConditionVariable cond; } } // namespace emugl anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/condition_variable_win32.cpp000066400000000000000000000062701356361734700320330ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "emugl/common/condition_variable.h" #include "emugl/common/lazy_instance.h" #include "emugl/common/mutex.h" #include "emugl/common/pod_vector.h" // Technical note: this is loosely based on the Chromium implementation // of ConditionVariable. This version works on Windows XP and above and // doesn't try to use Vista's CONDITION_VARIABLE types. namespace emugl { namespace { // Helper class which implements a free list of event handles. class WaitEventStorage { public: WaitEventStorage() : mFreeHandles(), mLock() {} ~WaitEventStorage() { for (size_t n = 0; n < mFreeHandles.size(); ++n) { CloseHandle(mFreeHandles[n]); } } HANDLE alloc() { HANDLE handle; mLock.lock(); size_t size = mFreeHandles.size(); if (size > 0) { handle = mFreeHandles[size - 1U]; mFreeHandles.remove(size - 1U); } else { handle = CreateEvent(NULL, TRUE, FALSE, NULL); } mLock.unlock(); return handle; } void free(HANDLE h) { mLock.lock(); ResetEvent(h); mFreeHandles.push_back(h); mLock.unlock(); } private: PodVector mFreeHandles; Mutex mLock; }; LazyInstance sWaitEvents = LAZY_INSTANCE_INIT; } // namespace ConditionVariable::ConditionVariable() : mWaiters(), mLock() {} ConditionVariable::~ConditionVariable() { mLock.lock(); for (size_t n = 0; n < mWaiters.size(); ++n) { CloseHandle(mWaiters[n]); } mWaiters.resize(0U); mLock.unlock(); } void ConditionVariable::wait(Mutex* userLock) { // Grab new waiter event handle. mLock.lock(); HANDLE handle = sWaitEvents->alloc(); mWaiters.push_back(handle); mLock.unlock(); // Unlock user lock then wait for event. userLock->unlock(); WaitForSingleObject(handle, INFINITE); // NOTE: The handle has been removed from mWaiters here, // see signal() below. Close/recycle the event. sWaitEvents->free(handle); userLock->lock(); } void ConditionVariable::signal() { mLock.lock(); size_t size = mWaiters.size(); if (size > 0U) { // NOTE: This wakes up the thread that went to sleep most // recently (LIFO) for performance reason. For better // fairness, using (FIFO) would be appropriate. HANDLE handle = mWaiters[size - 1U]; mWaiters.remove(size - 1U); SetEvent(handle); // NOTE: The handle will be closed/recycled by the waiter. } else { // Nothing to signal. } mLock.unlock(); } } // namespace emugl anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/crash_reporter.cpp000066400000000000000000000017671356361734700302060ustar00rootroot00000000000000/* * Copyright (C) 2016 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "crash_reporter.h" #include void default_crash_reporter(const emugl::LogLevel &level, const char* format, ...) { abort(); } logger_t emugl_crash_reporter = default_crash_reporter; void set_emugl_crash_reporter(logger_t crash_reporter) { if (crash_reporter) { emugl_crash_reporter = crash_reporter; } else { emugl_crash_reporter = default_crash_reporter; } } anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/crash_reporter.h000066400000000000000000000013511356361734700276400ustar00rootroot00000000000000/* * Copyright (C) 2016 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include "emugl/common/logging.h" extern logger_t emugl_crash_reporter; void set_emugl_crash_reporter(logger_t crash_reporter); anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/id_to_object_map.cpp000066400000000000000000000134321356361734700304350ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "emugl/common/id_to_object_map.h" #include namespace emugl { namespace { typedef IdToObjectMapBase::KeyType KeyType; enum { kMinShift = 3, kMaxShift = 31, kMinCapacity = (1 << kMinShift), kLoadScale = 1024, kMinLoad = kLoadScale/4, // 25% minimum load. kMaxLoad = kLoadScale*3/4, // 75% maximum load. kInvalidKey = IdToObjectMapBase::kMaxId + 1U, kTombstone = IdToObjectMapBase::kMaxId + 2U, }; // Return a number that indicates if the current |capacity| is appropriate // to hold |size| items in our map. // -1 -> the capacity is too small and needs to be increased. // 0 -> the capacity is ok. // +1 -> the capacity is too large and needs to be decreased. int capacityCompare(size_t shift, size_t size) { size_t capacity = 1U << shift; // Essentially, one can rewrite: // load < minLoad // as: // size / capacity < minLoad // capacity * minLoad > size if (capacity * kMinLoad > size * kLoadScale) return +1; // Similarly, one can rewrite: // load > maxLoad // as: // size / capacity > maxLoad // capacity * maxLoad < size if (capacity * kMaxLoad < size * kLoadScale) return -1; return 0; } size_t probeKeys(const KeyType* keys, size_t shift, KeyType key) { static const int kPrimes[] = { 1, /* For 1 << 0 */ 2, 3, 7, 13, 31, 61, 127, 251, 509, 1021, 2039, 4093, 8191, 16381, 32749, 65521, /* For 1 << 16 */ 131071, 262139, 524287, 1048573, 2097143, 4194301, 8388593, 16777213, 33554393, 67108859, 134217689, 268435399, 536870909, 1073741789, 2147483647 /* For 1 << 31 */ }; size_t slot = key % kPrimes[shift]; size_t step = 0; for (;;) { KeyType k = keys[slot]; if (k == kInvalidKey || k == kTombstone || k == key) return slot; step += 1; slot = (slot + step) & (1U << shift); } } } // namespace IdToObjectMapBase::IdToObjectMapBase() : mCount(0), mShift(kMinShift) { size_t capacity = 1U << mShift; mKeys = static_cast(::calloc(sizeof(mKeys[0]), capacity)); mValues = static_cast(::calloc(sizeof(mValues[0]), capacity)); for (size_t n = 0; n < capacity; ++n) { mKeys[n] = kInvalidKey; } } IdToObjectMapBase::~IdToObjectMapBase() { mShift = 0; mCount = 0; ::free(mKeys); ::free(mValues); } bool IdToObjectMapBase::contains(KeyType key) const { size_t slot = probeKeys(mKeys, mShift, key); switch (mKeys[slot]) { case kInvalidKey: case kTombstone: return false; default: ; } return true; } bool IdToObjectMapBase::find(KeyType key, void** value) const { size_t slot = probeKeys(mKeys, mShift, key); if (!isValidKey(mKeys[slot])) { *value = NULL; return false; } *value = mValues[slot]; return true; } void* IdToObjectMapBase::set(KeyType key, void* value) { if (!value) return remove(key); size_t slot = probeKeys(mKeys, mShift, key); void* result; if (isValidKey(mKeys[slot])) { result = mValues[slot]; mValues[slot] = value; } else { mKeys[slot] = key; mValues[slot] = value; result = NULL; mCount++; resize(mCount); } return result; } void* IdToObjectMapBase::remove(KeyType key) { size_t slot = probeKeys(mKeys, mShift, key); if (!isValidKey(mKeys[slot])) return NULL; void* result = mValues[slot]; mValues[slot] = NULL; mKeys[slot] = kTombstone; mCount--; return result; } void IdToObjectMapBase::resize(size_t newSize) { int ret = capacityCompare(mShift, newSize); if (!ret) return; size_t oldCapacity = 1U << mShift; size_t newShift = mShift; if (ret < 0) { // Capacity is too small and must be increased. do { if (newShift == kMaxShift) break; ++newShift; } while (capacityCompare(newShift, newSize) < 0); } else { // Capacity is too large and must be decreased. do { if (newShift == kMinShift) break; newShift--; } while (capacityCompare(newShift, newSize) > 0); } if (newShift == mShift) return; // Allocate new arrays. size_t newCapacity = 1U << newShift; KeyType* newKeys = static_cast( ::calloc(sizeof(newKeys[0]), newCapacity)); void** newValues = static_cast( ::calloc(sizeof(newValues[0]), newCapacity)); for (size_t n = 0; n < newCapacity; ++n) newKeys[n] = kInvalidKey; // Copy old entries into new arrays. for (size_t n = 0; n < oldCapacity; ++n) { KeyType key = mKeys[n]; if (isValidKey(key)) { size_t newSlot = probeKeys(newKeys, newShift, key); newKeys[newSlot] = key; newValues[newSlot] = mValues[n]; } } // Swap arrays, and get rid of old ones. ::free(mKeys); ::free(mValues); mKeys = newKeys; mValues = newValues; mShift = newShift; } } // namespace emugl anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/id_to_object_map.h000066400000000000000000000123721356361734700301040ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef EMUGL_COMMON_ID_TO_OBJECT_MAP_H #define EMUGL_COMMON_ID_TO_OBJECT_MAP_H #include namespace emugl { // Base implementation class for IdToObjectMap template. // Used to reduce template-instanciated code generation. class IdToObjectMapBase { public: // The type of keys in this map. typedef unsigned KeyType; // Values higher than kMaxId cannot be used as map keys. enum { kMaxId = 0xfffffffdU, }; static inline bool isValidKey(KeyType key) { return key <= kMaxId; } protected: IdToObjectMapBase(); ~IdToObjectMapBase(); void clear(); // Return size inline size_t size() const { return mCount; } inline size_t capacity() const { return 1U << mShift; } // Return true iff the map contains a given key. bool contains(KeyType key) const; // Find a value associated with a given |key| in the map. // On success, return true and sets |*value| to the value/pointer, // which is _still_ owned by the map. // On failure, return false and sets |*value| to NULL. bool find(KeyType key, void** value) const; // Associate a value with a given |key| in the map. // Return the old value for the key, if any. Caller is responsible // for freeing it. void* set(KeyType key, void* value); // Remove the value associated with a given |key|. // Return the old value, if any. Caller is responsible for // freeing it. void* remove(KeyType key); size_t mCount; size_t mShift; KeyType* mKeys; void** mValues; private: // Resize the map if needed to ensure it can hold at least |newSize| // entries. void resize(size_t newSize); }; // A templated data container that acts as a dictionary mapping unsigned // integer keys to heap-allocated objects of type T. The dictionary // owns the objects associated with its keys, and automatically destroys // them when it is destroyed, or during replacement or removal. template class IdToObjectMap : public IdToObjectMapBase { public: // Initialize an empty instance. IdToObjectMap() : IdToObjectMapBase() {} // Destroy this instance. ~IdToObjectMap() { clear(); } // Return the number of items in this map. inline size_t size() const { return IdToObjectMapBase::size(); } // Return true iff the map is empty. inline bool empty() const { return !IdToObjectMapBase::size(); } // Remove all items from the map. void clear(); // Returns true iff the dictionary contains a value for |key|. inline bool contains(KeyType key) const { return IdToObjectMapBase::contains(key); } // Find the value corresponding to |key| in this map. // On success, return true, and sets |*value| to point to the // value (still owned by the instance). On failure, return false. inline bool find(KeyType key, T** value) const { return IdToObjectMapBase::find(key, reinterpret_cast(value)); } // Return the value associated with a given |key|, or NULL if it is // not in the map. Result is still owned by the map. inline T* get(KeyType key) const { T* result = NULL; this->find(key, &result); return result; } // Associate |value| with a given |key|. Returns true if a previous // value was replaced, and false if this is the first time a value // was associated with the given key. IMPORTANT: This transfers // ownership of |value| to the map instance. In case of replacement, // the old value is automatically destroyed. Using NULL as the value // is equivalent to calling remove(). bool set(KeyType key, T* value); // Remove any value associated with |key|. // Return true iff a value was associated with the key and destroyed // by this function, false if there was no value associated with the // key (or if it was NULL). bool remove(KeyType key); }; template void IdToObjectMap::clear() { size_t n = capacity(); while (n > 0) { --n; if (!isValidKey(mKeys[n])) continue; delete static_cast(mValues[n]); mValues[n] = NULL; mKeys[n] = kMaxId + 1U; } mCount = 0; } template bool IdToObjectMap::set(KeyType key, T* value) { T* oldValue = static_cast(IdToObjectMapBase::set(key, value)); if (!oldValue) { return false; } delete oldValue; return true; } template bool IdToObjectMap::remove(KeyType key) { T* oldValue = static_cast(IdToObjectMapBase::remove(key)); if (!oldValue) return false; delete oldValue; return true; } } // namespace emugl #endif // EMUGL_COMMON_ID_TO_OBJECT_MAP_H anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/id_to_object_map_unittest.cpp000066400000000000000000000060071356361734700323740ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "emugl/common/id_to_object_map.h" #include namespace emugl { namespace { typedef IdToObjectMapBase::KeyType KeyType; class Foo { public: Foo() : mVal(0) {} Foo(int val) : mVal(val) {} ~Foo() {} int val() const { return mVal; } void setVal(int val) { mVal = val; } private: int mVal; }; } // namespace TEST(IdToObjectMap, Empty) { IdToObjectMap map; EXPECT_TRUE(map.empty()); EXPECT_EQ(0U, map.size()); } TEST(IdToObjectMap, SetIntegerRange) { IdToObjectMap map; KeyType kMax = 10000; // Add all items in the map. for (KeyType n = 0; n < kMax; ++n) { EXPECT_FALSE(map.set(n, new Foo(n))) << "For key " << n; } // Check final size. EXPECT_EQ(static_cast(kMax), map.size()); // Find all items in the map. for (KeyType n = 0; n < kMax; ++n) { EXPECT_TRUE(map.contains(n)) << "For key " << n; Foo* foo = NULL; EXPECT_TRUE(map.find(n, &foo)) << "For key " << n; if (foo) { EXPECT_EQ(static_cast(n), foo->val()) << "For key " << n; } } } TEST(IdToObjectMap, RemoveAll) { IdToObjectMap map; KeyType kMax = 10000; // Add all items in the map. for (KeyType n = 0; n < kMax; ++n) { EXPECT_FALSE(map.set(n, new Foo(n))) << "For key " << n; } EXPECT_EQ(static_cast(kMax), map.size()); for (KeyType n = 0; n < kMax; ++n) { EXPECT_TRUE(map.remove(n)) << "For key " << n; } EXPECT_EQ(0U, map.size()); } TEST(IdToObjectMap, RemoveOdd) { IdToObjectMap map; KeyType kMax = 10000; // Add all items in the map. for (KeyType n = 0; n < kMax; ++n) { EXPECT_FALSE(map.set(n, new Foo(n))) << "For key " << n; } EXPECT_EQ(static_cast(kMax), map.size()); for (KeyType n = 0; n < kMax; ++n) { if (n & 1) { EXPECT_TRUE(map.remove(n)) << "For key " << n; } } EXPECT_EQ(static_cast(kMax / 2), map.size()); for (KeyType n = 0; n < kMax; ++n) { if (n & 1) { EXPECT_FALSE(map.contains(n)) << "For key " << n; } else { EXPECT_TRUE(map.contains(n)) << "For key " << n; Foo* foo = NULL; EXPECT_TRUE(map.find(n, &foo)) << "For key " << n; if (foo) { EXPECT_EQ(static_cast(n), foo->val()); } } } } } // namespace emugl anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/lazy_instance.cpp000066400000000000000000000050131356361734700300130ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "emugl/common/lazy_instance.h" #ifdef _WIN32 # define WIN32_LEAN_AND_MEAN 1 # include #else # include #endif namespace emugl { namespace internal { typedef LazyInstanceState::AtomicType AtomicType; #if defined(__GNUC__) static inline void compilerBarrier() { __asm__ __volatile__ ("" : : : "memory"); } #else #error "Your compiler is not supported" #endif #if defined(__i386__) || defined(__x86_64__) || defined(__arm__) || defined(__aarch64__) # define acquireBarrier() compilerBarrier() # define releaseBarrier() compilerBarrier() #else # error "Your CPU is not supported" #endif static inline AtomicType loadAcquire(AtomicType volatile* ptr) { AtomicType ret = *ptr; acquireBarrier(); return ret; } static inline void storeRelease(AtomicType volatile* ptr, AtomicType value) { releaseBarrier(); *ptr = value; } static int atomicCompareAndSwap(AtomicType volatile* ptr, int expected, int value) { #ifdef _WIN32 return InterlockedCompareExchange(ptr, value, expected); #elif defined(__GNUC__) return __sync_val_compare_and_swap(ptr, expected, value); #else #error "Your compiler is not supported" #endif } static void yieldThread() { #ifdef _WIN32 ::Sleep(0); #else sched_yield(); #endif } bool LazyInstanceState::inInitState() { return loadAcquire(&mState) == STATE_INIT; } bool LazyInstanceState::needConstruction() { AtomicType state = loadAcquire(&mState); if (mState == STATE_DONE) return false; state = atomicCompareAndSwap(&mState, STATE_INIT, STATE_CONSTRUCTING); if (state == STATE_INIT) return true; do { yieldThread(); state = loadAcquire(&mState); } while (state != STATE_DONE); return false; } void LazyInstanceState::doneConstructing() { storeRelease(&mState, STATE_DONE); } } // namespace internal } // namespace emugl anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/lazy_instance.h000066400000000000000000000112211356361734700274560ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef EMUGL_COMMON_LAZY_INSTANCE_H #define EMUGL_COMMON_LAZY_INSTANCE_H #include #ifdef _WIN32 # define WIN32_LEAN_AND_MEAN 1 # include #endif namespace emugl { namespace internal { // A LazyInstance is a helper template that can be used to perform // thread-safe lazy initialization of static C++ objects without forcing // the generation of C++ static constructors in the final executable. // // In a nutshell, you can replace a statement like: // // static Foo gFoo; // // With: // // static LazyInstance gFoo = LAZY_INSTANCE_INIT; // // In the first case, a hidden static C++ constructor is embedded in the // final executable, and executed at *load* *time* to call the Foo::Foo // constructor on the gFoo object. // // On the second case, gFoo will only be initialized lazily, i.e. the first // time any code actually tries to access the variable. // // Note that access is slightly different, i.e.: // // gFoo.get() returns a reference to the lazy-initialized object. // gFoo.ptr() returns a pointer to it. // gFoo->Something() is equivalent to doing gFoo.ptr()->Something(). // // 'gFoo' is stored in the .bss section and this doesn't use heap allocation. // This class can only be used to perform lazy initialization through the // class' default constructor. For more specialized cases, you will have // to create a derived class, e.g.: // // class FoorWithDefaultParams : public Foo { // public: // FooWithDefaultParams() : Foo() {} // }; // // LazyInstance gFoo = LAZY_INSTANCE_INIT; // // The implementation of LazyInstance relies on atomic operations and // POD-struct class definitions, i.e. one that doesn't have any constructor, // destructor, virtual members, or private ones, and that can be // zero-initialized at link time. // // You can also use LazyInstance<> instances as static local variables, // e.g.: // // Foo* getFooSingleton() { // static LazyInstance sFoo = LAZY_INSTANCE_INIT; // return sFoo.ptr(); // } // // This is useful on Windows which doesn't support thread-safe lazy // initialization of static C++ local variables, or when the code is // compiled with -fno-threadsafe-statics. // // This class is heavily inspired by Chromium's implementation of the // same-named class (see $CHROMIUM/src/base/lazy_instance.h). // Atomic state variable type. Used to ensure to synchronize concurrent // initialization and access without incurring the full cost of a mutex // lock/unlock. struct LazyInstanceState { enum { STATE_INIT = 0, STATE_CONSTRUCTING = 1, STATE_DONE = 2, }; bool inInitState(); bool needConstruction(); void doneConstructing(); #ifdef _WIN32 typedef LONG volatile AtomicType; #else typedef int volatile AtomicType; #endif volatile AtomicType mState; }; #define LAZY_INSTANCE_STATE_INIT \ { ::emugl::internal::LazyInstanceState::STATE_INIT } } // namespace internal // LazyInstance template definition, see comment above for usage // instructions. It is crucial to make this a POD-struct compatible // type [1]. // // [1] http://en.wikipedia.org/wiki/Plain_Old_Data_Structures // template struct LazyInstance { bool hasInstance() const { return !mState.inInitState(); } T& get() const { return *ptr(); } T* ptr() const; const T* operator->() const { return ptr(); } T* operator->() { return ptr(); } T& operator*() { return get(); } // Really private, do not use. union { mutable internal::LazyInstanceState mState; double mPadding; }; mutable char mStorage[sizeof(T)]; }; // Initialization value, must resolve to all-0 to ensure the object // instance is actually placed in the .bss #define LAZY_INSTANCE_INIT { { LAZY_INSTANCE_STATE_INIT }, { 0 } } template T* LazyInstance::ptr() const { if (mState.needConstruction()) { new (mStorage) T(); mState.doneConstructing(); } return reinterpret_cast(mStorage); } } // namespace emugl #endif // EMUGL_COMMON_LAZY_INSTANCE_H anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/lazy_instance_unittest.cpp000066400000000000000000000100101356361734700317430ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "emugl/common/lazy_instance.h" #include "emugl/common/mutex.h" #include "emugl/common/testing/test_thread.h" #include namespace emugl { namespace { class Foo { public: Foo() : mValue(42) {} int get() const { return mValue; } void set(int value) { mValue = value; } ~Foo() { mValue = 13; } private: int mValue; }; class StaticCounter { public: StaticCounter() { Mutex::AutoLock lock(mMutex); mCounter++; } int getValue() const { Mutex::AutoLock lock(mMutex); return mCounter; } private: static Mutex mMutex; static int mCounter; }; // NOTE: This introduces a static C++ constructor for this object file, // but that's ok because a LazyInstance should not be used to // test the behaviour of LazyInstance :-) Mutex StaticCounter::mMutex; int StaticCounter::mCounter = 0; } // namespace TEST(LazyInstance, HasInstance) { LazyInstance foo_instance = LAZY_INSTANCE_INIT; EXPECT_FALSE(foo_instance.hasInstance()); EXPECT_FALSE(foo_instance.hasInstance()); foo_instance.ptr(); EXPECT_TRUE(foo_instance.hasInstance()); } TEST(LazyInstance, Simple) { LazyInstance foo_instance = LAZY_INSTANCE_INIT; Foo* foo1 = foo_instance.ptr(); EXPECT_TRUE(foo1); EXPECT_EQ(42, foo_instance->get()); foo1->set(10); EXPECT_EQ(10, foo_instance->get()); EXPECT_EQ(foo1, foo_instance.ptr()); } // For the following test, launch 1000 threads that each try to get // the instance pointer of a lazy instance. Then verify that they're all // the same value. // // The lazy instance has a special constructor that will increment a // global counter. This allows us to ensure that it is only called once. // namespace { // The following is the shared structure between all threads. struct MultiState { MultiState(LazyInstance* staticCounter) : mMutex(), mStaticCounter(staticCounter), mCount(0) {} enum { kMaxThreads = 1000, }; Mutex mMutex; LazyInstance* mStaticCounter; size_t mCount; void* mValues[kMaxThreads]; TestThread* mThreads[kMaxThreads]; }; // The thread function for the test below. static void* threadFunc(void* param) { MultiState* state = static_cast(param); Mutex::AutoLock lock(state->mMutex); if (state->mCount < MultiState::kMaxThreads) { state->mValues[state->mCount++] = state->mStaticCounter->ptr(); } return NULL; } } // namespace TEST(LazyInstance, MultipleThreads) { LazyInstance counter_instance = LAZY_INSTANCE_INIT; MultiState state(&counter_instance); const size_t kNumThreads = MultiState::kMaxThreads; // Create all threads. for (size_t n = 0; n < kNumThreads; ++n) { state.mThreads[n] = new TestThread(threadFunc, &state); } // Wait for their completion. for (size_t n = 0; n < kNumThreads; ++n) { state.mThreads[n]->join(); } // Now check that the constructor was only called once. EXPECT_EQ(1, counter_instance->getValue()); // Now compare all the store values, they should be the same. StaticCounter* expectedValue = counter_instance.ptr(); for (size_t n = 0; n < kNumThreads; ++n) { EXPECT_EQ(expectedValue, state.mValues[n]) << "For thread " << n; } for (size_t n = 0; n < kNumThreads; ++n) { delete state.mThreads[n]; } } } // namespace emugl anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/logging.cpp000066400000000000000000000020741356361734700266020ustar00rootroot00000000000000/* * Copyright (C) 2016 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "emugl/common/logging.h" void default_logger(const emugl::LogLevel &level, const char* fmt, ...) { } logger_t emugl_logger = default_logger; logger_t emugl_cxt_logger = default_logger; void set_emugl_logger(logger_t f) { if (!f) { emugl_logger = default_logger; } else { emugl_logger = f; } } void set_emugl_cxt_logger(logger_t f) { if (!f) { emugl_cxt_logger = default_logger; } else { emugl_cxt_logger = f; } } anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/logging.h000066400000000000000000000025031356361734700262440ustar00rootroot00000000000000/* * Copyright (C) 2016 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef EMUGL_COMMON_LOGGING_H_ #define EMUGL_COMMON_LOGGING_H_ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wredundant-decls" namespace emugl { enum class LogLevel { TRACE, DEBUG, INFO, WARNING, ERROR, FATAL, }; } // namespace emugl typedef void (*logger_t)(const emugl::LogLevel &level, const char* fmt, ...); extern logger_t emugl_logger; extern logger_t emugl_cxt_logger; void set_emugl_logger(logger_t f); void set_emugl_cxt_logger(logger_t f); #define GL_LOGGING 1 #if GL_LOGGING #define GL_LOG(...) do { \ emugl_logger(__VA_ARGS__); \ } while (0) #define GL_CXT_LOG(...) do { \ emugl_cxt_logger(__VA_ARGS__); \ } while (0) #else #define GL_LOG(...) 0 #endif #pragma GCC diagnostic pop #endif anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/message_channel.cpp000066400000000000000000000030501356361734700302630ustar00rootroot00000000000000// Copyright 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "emugl/common/message_channel.h" namespace emugl { MessageChannelBase::MessageChannelBase(size_t capacity) : mPos(0U), mCount(0U), mCapacity(capacity), mLock(), mCanRead(), mCanWrite() {} MessageChannelBase::~MessageChannelBase() {} size_t MessageChannelBase::beforeWrite() { mLock.lock(); while (mCount >= mCapacity) { mCanWrite.wait(&mLock); } size_t result = mPos + mCount; if (result >= mCapacity) { result -= mCapacity; } return result; } void MessageChannelBase::afterWrite() { mCount++; mCanRead.signal(); mLock.unlock(); } size_t MessageChannelBase::beforeRead() { mLock.lock(); while (mCount == 0) { mCanRead.wait(&mLock); } return mPos; } void MessageChannelBase::afterRead() { if (++mPos == mCapacity) { mPos = 0U; } mCount--; mCanWrite.signal(); mLock.unlock(); } } // namespace emugl anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/message_channel.h000066400000000000000000000056401356361734700277370ustar00rootroot00000000000000// Copyright 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef EMUGL_COMMON_MESSAGE_CHANNEL_H #define EMUGL_COMMON_MESSAGE_CHANNEL_H #include "emugl/common/condition_variable.h" #include "emugl/common/mutex.h" #include namespace emugl { // Base non-templated class used to reduce the amount of template // specialization. class MessageChannelBase { public: // Constructor. |capacity| is the buffer capacity in messages. MessageChannelBase(size_t capacity); // Destructor. ~MessageChannelBase(); protected: // Call this method in the sender thread before writing a new message. // This returns the position of the available slot in the message array // where to copy the new fixed-size message. After the copy, call // afterWrite(). size_t beforeWrite(); // To be called after beforeWrite() and copying a new fixed-size message // into the array. This signal the receiver thread that there is a new // incoming message. void afterWrite(); // Call this method in the receiver thread before reading a new message. // This returns the position in the message array where the new message // can be read. Caller must process the message, then call afterRead(). size_t beforeRead(); // To be called in the receiver thread after beforeRead() and processing // the corresponding message. void afterRead(); private: size_t mPos; size_t mCount; size_t mCapacity; Mutex mLock; ConditionVariable mCanRead; ConditionVariable mCanWrite; }; // Helper class used to implement an uni-directional IPC channel between // two threads. The channel can be used to send fixed-size messages of type // |T|, with an internal buffer size of |CAPACITY| items. All calls are // blocking. // // Usage is pretty straightforward: // // - From the sender thread, call send(msg); // - From the receiver thread, call receive(&msg); // template class MessageChannel : public MessageChannelBase { public: MessageChannel() : MessageChannelBase(CAPACITY) {} void send(const T& msg) { size_t pos = beforeWrite(); mItems[pos] = msg; afterWrite(); } void receive(T* msg) { size_t pos = beforeRead(); *msg = mItems[pos]; afterRead(); } private: T mItems[CAPACITY]; }; } // namespace emugl #endif // EMUGL_COMMON_MESSAGE_CHANNEL_H anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/message_channel_unittest.cpp000066400000000000000000000051421356361734700322260ustar00rootroot00000000000000// Copyright 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "emugl/common/message_channel.h" #include "emugl/common/testing/test_thread.h" #include #include namespace emugl { namespace { struct PingPongState { MessageChannel in; MessageChannel out; }; void* pingPongFunction(void* param) { for (;;) { PingPongState* s = static_cast(param); std::string str; s->in.receive(&str); s->out.send(str); if (str == "quit") { break; } } return 0; } } // namespace TEST(MessageChannel, SingleThreadWithInt) { MessageChannel channel; channel.send(1); channel.send(2); channel.send(3); int ret; channel.receive(&ret); EXPECT_EQ(1, ret); channel.receive(&ret); EXPECT_EQ(2, ret); channel.receive(&ret); EXPECT_EQ(3, ret); } TEST(MessageChannel, SingleThreadWithStdString) { MessageChannel channel; channel.send(std::string("foo")); channel.send(std::string("bar")); channel.send(std::string("zoo")); std::string str; channel.receive(&str); EXPECT_STREQ("foo", str.c_str()); channel.receive(&str); EXPECT_STREQ("bar", str.c_str()); channel.receive(&str); EXPECT_STREQ("zoo", str.c_str()); } TEST(MessageChannel, TwoThreadsPingPong) { PingPongState state; TestThread* thread = new TestThread(pingPongFunction, &state); std::string str; const size_t kCount = 100; for (size_t n = 0; n < kCount; ++n) { state.in.send(std::string("foo")); state.in.send(std::string("bar")); state.in.send(std::string("zoo")); state.out.receive(&str); EXPECT_STREQ("foo", str.c_str()); state.out.receive(&str); EXPECT_STREQ("bar", str.c_str()); state.out.receive(&str); EXPECT_STREQ("zoo", str.c_str()); } state.in.send(std::string("quit")); state.out.receive(&str); EXPECT_STREQ("quit", str.c_str()); thread->join(); } } // namespace emugl anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/mutex.h000066400000000000000000000036741356361734700257720ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef EMUGL_MUTEX_H #define EMUGL_MUTEX_H #ifdef _WIN32 # define WIN32_LEAN_AND_MEAN 1 # include #else # include #endif namespace emugl { class ConditionVariable; // Simple wrapper class for mutexes. class Mutex { public: // Constructor. Mutex() { #ifdef _WIN32 ::InitializeCriticalSection(&mLock); #else ::pthread_mutex_init(&mLock, NULL); #endif } // Destructor. ~Mutex() { #ifdef _WIN32 ::DeleteCriticalSection(&mLock); #else ::pthread_mutex_destroy(&mLock); #endif } // Acquire the mutex. void lock() { #ifdef _WIN32 ::EnterCriticalSection(&mLock); #else ::pthread_mutex_lock(&mLock); #endif } // Release the mutex. void unlock() { #ifdef _WIN32 ::LeaveCriticalSection(&mLock); #else ::pthread_mutex_unlock(&mLock); #endif } // Helper class to lock / unlock a mutex automatically on scope // entry and exit. class AutoLock { public: AutoLock(Mutex& mutex) : mMutex(&mutex) { mMutex->lock(); } ~AutoLock() { mMutex->unlock(); } private: Mutex* mMutex; }; private: #ifdef _WIN32 CRITICAL_SECTION mLock; #else friend class ConditionVariable; pthread_mutex_t mLock; #endif }; } // namespace emugl #endif // EMUGL_MUTEX_H anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/mutex_unittest.cpp000066400000000000000000000054651356361734700302640ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "emugl/common/mutex.h" #include "emugl/common/testing/test_thread.h" #include namespace emugl { // Check that construction and destruction doesn't crash. TEST(Mutex, ConstructionDestruction) { Mutex lock; } // Check that a simple lock + unlock works. TEST(Mutex, LockUnlock) { Mutex lock; lock.lock(); lock.unlock(); } // Check that AutoLock compiles and doesn't crash. TEST(Mutex, AutoLock) { Mutex mutex; Mutex::AutoLock lock(mutex); } // Wrapper class for threads. Does not use emugl::Thread intentionally. // Common data type used by the following tests below. struct ThreadParams { ThreadParams() : mutex(), counter(0) {} Mutex mutex; int counter; }; // This thread function uses Mutex::lock/unlock to synchronize a counter // increment operation. static void* threadFunction(void* param) { ThreadParams* p = static_cast(param); p->mutex.lock(); p->counter++; p->mutex.unlock(); return NULL; } TEST(Mutex, Synchronization) { const size_t kNumThreads = 2000; TestThread* threads[kNumThreads]; ThreadParams p; // Create and launch all threads. for (size_t n = 0; n < kNumThreads; ++n) { threads[n] = new TestThread(threadFunction, &p); } // Wait until their completion. for (size_t n = 0; n < kNumThreads; ++n) { threads[n]->join(); delete threads[n]; } EXPECT_EQ(static_cast(kNumThreads), p.counter); } // This thread function uses a Mutex::AutoLock to protect the counter. static void* threadAutoLockFunction(void* param) { ThreadParams* p = static_cast(param); Mutex::AutoLock lock(p->mutex); p->counter++; return NULL; } TEST(Mutex, AutoLockSynchronization) { const size_t kNumThreads = 2000; TestThread* threads[kNumThreads]; ThreadParams p; // Create and launch all threads. for (size_t n = 0; n < kNumThreads; ++n) { threads[n] = new TestThread(threadAutoLockFunction, &p); } // Wait until their completion. for (size_t n = 0; n < kNumThreads; ++n) { threads[n]->join(); delete threads[n]; } EXPECT_EQ(static_cast(kNumThreads), p.counter); } } // namespace emugl anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/pod_vector.cpp000066400000000000000000000106321356361734700273170ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "emugl/common/pod_vector.h" #include #include #define USE_MALLOC_USABLE_SIZE 0 namespace emugl { static inline void swapPointers(char** p1, char** p2) { char* tmp = *p1; *p1 = *p2; *p2 = tmp; } PodVectorBase::PodVectorBase(const PodVectorBase& other) { initFrom(other.begin(), other.byteSize()); } PodVectorBase& PodVectorBase::operator=(const PodVectorBase& other) { initFrom(other.begin(), other.byteSize()); return *this; } PodVectorBase::~PodVectorBase() { if (mBegin) { // Sanity. ::memset(mBegin, 0xee, byteSize()); ::free(mBegin); mBegin = NULL; mEnd = NULL; mLimit = NULL; } } void PodVectorBase::initFrom(const void* from, size_t fromLen) { if (!fromLen || !from) { mBegin = NULL; mEnd = NULL; mLimit = NULL; } else { mBegin = static_cast(::malloc(fromLen)); mEnd = mLimit = mBegin + fromLen; ::memcpy(mBegin, from, fromLen); } } void PodVectorBase::assignFrom(const PodVectorBase& other) { resize(other.byteSize(), 1U); ::memmove(begin(), other.begin(), byteSize()); } void PodVectorBase::resize(size_t newSize, size_t itemSize) { const size_t kMaxSize = maxItemCapacity(itemSize); size_t oldCapacity = itemCapacity(itemSize); const size_t kMinCapacity = 256 / itemSize; if (newSize < oldCapacity) { // Only shrink if the new size is really small. if (newSize < oldCapacity / 2 && oldCapacity > kMinCapacity) { reserve(newSize, itemSize); } } else if (newSize > oldCapacity) { size_t newCapacity = oldCapacity; while (newCapacity < newSize) { size_t newCapacity2 = newCapacity + (newCapacity >> 2) + 8; if (newCapacity2 < newCapacity || newCapacity > kMaxSize) { newCapacity = kMaxSize; } else { newCapacity = newCapacity2; } } reserve(newCapacity, itemSize); } mEnd = mBegin + newSize * itemSize; } void PodVectorBase::reserve(size_t newSize, size_t itemSize) { if (newSize == 0) { ::free(mBegin); mBegin = NULL; mEnd = NULL; mLimit = NULL; return; } size_t oldByteSize = byteSize(); size_t newByteCapacity = newSize * itemSize; char* newBegin = static_cast(::realloc(mBegin, newByteCapacity)); mBegin = newBegin; mEnd = newBegin + oldByteSize; #if USE_MALLOC_USABLE_SIZE size_t usableSize = malloc_usable_size(mBegin); if (usableSize > newByteCapacity) { newByteCapacity = usableSize - (usableSize % itemSize); } #endif mLimit = newBegin + newByteCapacity; // Sanity. if (newByteCapacity > oldByteSize) { ::memset(mBegin + oldByteSize, 0, newByteCapacity - oldByteSize); } } void PodVectorBase::removeAt(size_t itemPos, size_t itemSize) { size_t count = itemCount(itemSize); if (itemPos < count) { size_t pos = itemPos * itemSize; ::memmove(mBegin + pos, mBegin + pos + itemSize, byteSize() - pos - itemSize); resize(count - 1U, itemSize); } } void* PodVectorBase::insertAt(size_t itemPos, size_t itemSize) { size_t count = this->itemCount(itemSize); resize(count + 1, itemSize); size_t pos = itemPos * itemSize; if (itemPos < count) { ::memmove(mBegin + pos + itemSize, mBegin + pos, count * itemSize - pos); // Sanity to avoid copying pointers and other bad stuff. ::memset(mBegin + pos, 0, itemSize); } return mBegin + pos; } void PodVectorBase::swapAll(PodVectorBase* other) { swapPointers(&mBegin, &other->mBegin); swapPointers(&mEnd, &other->mEnd); swapPointers(&mLimit, &other->mLimit); } } // namespace emugl anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/pod_vector.h000066400000000000000000000221261356361734700267650ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef EMUGL_COMMON_POD_VECTOR_H #define EMUGL_COMMON_POD_VECTOR_H #include #ifndef __STDC_LIMIT_MACROS #define __STDC_LIMIT_MACROS 1 #endif #ifndef __STDC_FORMAT_MACROS #define __STDC_FORMAT_MACROS 1 #endif #include #ifndef SIZE_MAX #error "You must define __STDC_LIMIT_MACROS before including " #endif namespace emugl { // A PodVector is a templated vector-like type that is used to store // POD-struct compatible items only. This allows the implementation to // use ::memmove() to move items, and also malloc_usable_size() to // determine the best capacity. // // std::vector<> is capable of doing this in theory, using horrible // templating tricks that make error messages very difficult to // understand. // // Note that a PodVector can be used to store items that contain pointers, // as long as these do not point to items in the same container. // // The PodVector provides methods that also follow the std::vector<> // conventions, i.e. push_back() is an alias for append(). // // NOTE: This is a re-implementation of // external/qemu/android/base/containers/PodVector.h for emugl. // PodVectorBase is a base, non-templated, implementation class that all // PodVector instances derive from. This is used to reduce template // specialization. Do not use directly, i..e it's an implementation detail. class PodVectorBase { protected: PodVectorBase() : mBegin(NULL), mEnd(NULL), mLimit(NULL) {} explicit PodVectorBase(const PodVectorBase& other); PodVectorBase& operator=(const PodVectorBase& other); ~PodVectorBase(); bool empty() const { return mEnd == mBegin; } size_t byteSize() const { return mEnd - mBegin; } size_t byteCapacity() const { return mLimit - mBegin; } void* begin() { return mBegin; } const void* begin() const { return mBegin; } void* end() { return mEnd; } const void* end() const { return mEnd; } void* itemAt(size_t pos, size_t itemSize) { return mBegin + pos * itemSize; } const void* itemAt(size_t pos, size_t itemSize) const { return mBegin + pos * itemSize; } void assignFrom(const PodVectorBase& other); inline size_t itemCount(size_t itemSize) const { return byteSize() / itemSize; } inline size_t itemCapacity(size_t itemSize) const { return byteCapacity() / itemSize; } inline size_t maxItemCapacity(size_t itemSize) const { return SIZE_MAX / itemSize; } void resize(size_t newSize, size_t itemSize); void reserve(size_t newSize, size_t itemSize); void removeAt(size_t index, size_t itemSize); void* insertAt(size_t index, size_t itemSize); void swapAll(PodVectorBase* other); char* mBegin; char* mEnd; char* mLimit; private: void initFrom(const void* from, size_t fromLen); }; // A PodVector holds a vector (dynamically resizable array) or items // that must be POD-struct compatible (i.e. they cannot have constructors, // destructors, or virtual members). This allows the implementation to be // small, fast and efficient, memory-wise. // // If you want to implement a vector of C++ objects, consider using // std::vector<> instead, but keep in mind that this implies a non-trivial // cost when appending, inserting, removing items in the collection. // template class PodVector : public PodVectorBase { public: // Default constructor for an empty PodVector PodVector() : PodVectorBase() {} // Copy constructor. This copies all items from |other| into // the new instance with ::memmove(). PodVector(const PodVector& other) : PodVectorBase(other) {} // Assignment operator. PodVector& operator=(const PodVector& other) { this->assignFrom(other); return *this; } // Destructor, this simply releases the internal storage block that // holds all the items, but doesn't touch them otherwise. ~PodVector() {} // Return true iff the PodVector instance is empty, i.e. does not // have any items. bool empty() const { return PodVectorBase::empty(); } // Return the number of items in the current PodVector instance. size_t size() const { return PodVectorBase::itemCount(sizeof(T)); } // Return the current capacity in the current PodVector instance. // Do not use directly, except if you know what you're doing. Try to // use resize() or reserve() instead. size_t capacity() const { return PodVectorBase::itemCapacity(sizeof(T)); } // Return the maximum capacity of any PodVector instance. static inline size_t maxCapacity() { return SIZE_MAX / sizeof(T); } // Resize the vector to ensure it can hold |newSize| // items. This may or may not call reserve() under the hood. // It's a fatal error to try to resize above maxCapacity(). void resize(size_t newSize) { PodVectorBase::resize(newSize, sizeof(T)); } // Resize the vector's storage array to ensure that it can hold at // least |newSize| items. It's a fatal error to try to resize above // maxCapacity(). void reserve(size_t newSize) { PodVectorBase::reserve(newSize, sizeof(T)); } // Return a pointer to the first item in the vector. This is only // valid until the next call to any function that changes the size // or capacity of the vector. Can be NULL if the vector is empty. T* begin() { return reinterpret_cast(PodVectorBase::begin()); } // Return a constant pointer to the first item in the vector. This is // only valid until the next call to any function that changes the // size of capacity of the vector. const T* begin() const { return reinterpret_cast(PodVectorBase::begin()); } // Return a pointer past the last item in the vector. I.e. if the // result is not NULL, then |result - 1| points to the last item. // Can be NULL if the vector is empty. T* end() { return reinterpret_cast(PodVectorBase::end()); } // Return a constant pointer past the last item in the vector. I.e. if // the result is not NULL, then |result - 1| points to the last item. // Can be NULL if the vector is empty. const T* end() const { return reinterpret_cast(PodVectorBase::end()); } // Returns a reference to the item a position |index| in the vector. // It may be a fatal error to access an out-of-bounds position. T& operator[](size_t index) { return *reinterpret_cast( PodVectorBase::itemAt(index, sizeof(T))); } const T& operator[](size_t index) const { return *reinterpret_cast( PodVectorBase::itemAt(index, sizeof(T))); } // Increase the vector's size by 1, then move all items past a given // position to the right. Return the position of the insertion point // to let the caller copy the content it desires there. It's preferrable // to use insert() directly, which will do the item copy for you. T* emplace(size_t index) { return reinterpret_cast( PodVectorBase::insertAt(index, sizeof(T))); } // Insert an item at a given position. |index| is the insertion position // which must be between 0 and size() included, or a fatal error may // occur. |item| is a reference to an item to copy into the array, // byte-by-byte. void insert(size_t index, const T& item) { *(this->emplace(index)) = item; } // Prepend an item at the start of a vector. This moves all vector items // to the right, and is thus costly. |item| is a reference to an item // to copy to the start of the vector. void prepend(const T& item) { *(this->emplace(0U)) = item; } // Append an item at the end of a vector. Specialized version of insert() // which always uses size() as the insertion position. void append(const T& item) { *(this->emplace(this->size())) = item; } // Remove the item at a given position. |index| is the position of the // item to delete. It must be between 0 and size(), included, or // a fatal error may occur. Deleting the item at position size() // doesn't do anything. void remove(size_t index) { PodVectorBase::removeAt(index, sizeof(T)); } void swap(PodVector* other) { PodVectorBase::swapAll(other); } // Compatibility methods for std::vector<> void push_back(const T& item) { append(item); } void pop() { remove(0U); } typedef T* iterator; typedef const T* const_iterator; }; } // namespace emugl #endif // EMUGL_COMMON_POD_VECTOR_H anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/pod_vector_unittest.cpp000066400000000000000000000065531356361734700312650ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "emugl/common/pod_vector.h" #include namespace emugl { static int hashIndex(size_t n) { return static_cast(((n >> 14) * 13773) + (n * 51)); } TEST(PodVector, Empty) { PodVector v; EXPECT_TRUE(v.empty()); EXPECT_EQ(0U, v.size()); } TEST(PodVector, AppendOneItem) { PodVector v; v.append(10234); EXPECT_FALSE(v.empty()); EXPECT_EQ(1U, v.size()); EXPECT_EQ(10234, v[0]); } TEST(PodVector, AppendLotsOfItems) { PodVector v; const size_t kMaxCount = 10000; for (size_t n = 0; n < kMaxCount; ++n) { v.append(hashIndex(n)); } EXPECT_EQ(kMaxCount, v.size()); for (size_t n = 0; n < kMaxCount; ++n) { EXPECT_EQ(hashIndex(n), v[n]) << "At index " << n; } } TEST(PodVector, RemoveFrontItems) { PodVector v; const size_t kMaxCount = 100; for (size_t n = 0; n < kMaxCount; ++n) { v.append(hashIndex(n)); } EXPECT_EQ(kMaxCount, v.size()); for (size_t n = 0; n < kMaxCount; ++n) { EXPECT_EQ(hashIndex(n), v[0]) << "At index " << n; v.remove(0U); EXPECT_EQ(kMaxCount - n - 1U, v.size()) << "At index " << n; } } TEST(PodVector, PrependItems) { PodVector v; const size_t kMaxCount = 100; for (size_t n = 0; n < kMaxCount; ++n) { v.prepend(hashIndex(n)); } EXPECT_EQ(kMaxCount, v.size()); for (size_t n = 0; n < kMaxCount; ++n) { EXPECT_EQ(hashIndex(kMaxCount - n - 1), v[n]) << "At index " << n; } } TEST(PodVector, ResizeExpands) { PodVector v; const size_t kMaxCount = 100; const size_t kMaxCount2 = 10000; for (size_t n = 0; n < kMaxCount; ++n) { v.append(hashIndex(n)); } EXPECT_EQ(kMaxCount, v.size()); v.resize(kMaxCount2); EXPECT_EQ(kMaxCount2, v.size()); for (size_t n = 0; n < kMaxCount; ++n) { EXPECT_EQ(hashIndex(n), v[n]) << "At index " << n; } } TEST(PodVector, ResizeTruncates) { PodVector v; const size_t kMaxCount = 10000; const size_t kMaxCount2 = 10; for (size_t n = 0; n < kMaxCount; ++n) { v.append(hashIndex(n)); } EXPECT_EQ(kMaxCount, v.size()); v.resize(kMaxCount2); EXPECT_EQ(kMaxCount2, v.size()); for (size_t n = 0; n < kMaxCount2; ++n) { EXPECT_EQ(hashIndex(n), v[n]) << "At index " << n; } } TEST(PodVector, AssignmentOperator) { PodVector v1; const size_t kMaxCount = 10000; for (size_t n = 0; n < kMaxCount; ++n) { v1.append(hashIndex(n)); } EXPECT_EQ(kMaxCount, v1.size()); PodVector v2; v2 = v1; v1.reserve(0); EXPECT_EQ(kMaxCount, v2.size()); for (size_t n = 0; n < kMaxCount; ++n) { EXPECT_EQ(hashIndex(n), v2[n]) << "At index " << n; } } } // namespace emugl anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/scoped_pointer_vector.h000066400000000000000000000015411356361734700312160ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef EMUGL_COMMON_SCOPED_POINTER_VECTOR_H #define EMUGL_COMMON_SCOPED_POINTER_VECTOR_H namespace emugl { template class ScopedPointerVector { ScopedPointerVector }; } // namespace emugl #endif // EMUGL_COMMON_SCOPED_POINTER_VECTOR_H anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/shared_library.cpp000066400000000000000000000107301356361734700301440ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "emugl/common/shared_library.h" #include #include #include #ifndef _WIN32 #include #include #endif namespace emugl { // static SharedLibrary* SharedLibrary::open(const char* libraryName) { char error[1]; return open(libraryName, error, sizeof(error)); } #ifdef _WIN32 // static SharedLibrary* SharedLibrary::open(const char* libraryName, char* error, size_t errorSize) { HMODULE lib = LoadLibrary(libraryName); if (lib) { return new SharedLibrary(lib); } if (errorSize == 0) { return NULL; } // Convert error into human-readable message. DWORD errorCode = ::GetLastError(); LPSTR message = NULL; size_t messageLen = FormatMessageA( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, errorCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR) &message, 0, NULL); int ret = snprintf(error, errorSize, "%.*s", (int)messageLen, message); if (ret < 0 || ret == static_cast(errorSize)) { // snprintf() on Windows doesn't behave as expected by C99, // this path is to ensure that the result is always properly // zero-terminated. ret = static_cast(errorSize - 1); error[ret] = '\0'; } // Remove any trailing \r\n added by FormatMessage if (ret > 0 && error[ret - 1] == '\n') { error[--ret] = '\0'; } if (ret > 0 && error[ret - 1] == '\r') { error[--ret] = '\0'; } return NULL; } SharedLibrary::SharedLibrary(HandleType lib) : mLib(lib) {} SharedLibrary::~SharedLibrary() { if (mLib) { FreeLibrary(mLib); } } SharedLibrary::FunctionPtr SharedLibrary::findSymbol( const char* symbolName) const { if (!mLib || !symbolName) { return NULL; } return reinterpret_cast( GetProcAddress(mLib, symbolName)); } #else // !_WIN32 // static SharedLibrary* SharedLibrary::open(const char* libraryName, char* error, size_t errorSize) { const char* libPath = libraryName; char* path = NULL; const char* libBaseName = strrchr(libraryName, '/'); if (!libBaseName) { libBaseName = libraryName; } if (!strchr(libBaseName, '.')) { // There is no extension in this library name, so append one. #ifdef __APPLE__ static const char kDllExtension[] = ".dylib"; #else static const char kDllExtension[] = ".so"; #endif size_t pathLen = strlen(libraryName) + sizeof(kDllExtension); path = static_cast(malloc(pathLen)); snprintf(path, pathLen, "%s%s", libraryName, kDllExtension); libPath = path; } dlerror(); // clear error. #ifdef __APPLE__ // On OSX, some libraries don't include an extension (notably OpenGL) // On OSX we try to open |libraryName| first. If that doesn't exist, // we try |libraryName|.dylib void* lib = dlopen(libraryName, RTLD_NOW); if (lib == NULL) { lib = dlopen(libPath, RTLD_NOW); } #else void* lib = dlopen(libPath, RTLD_NOW); #endif if (path) { free(path); } if (lib) { return new SharedLibrary(lib); } snprintf(error, errorSize, "%s", dlerror()); return NULL; } SharedLibrary::SharedLibrary(HandleType lib) : mLib(lib) {} SharedLibrary::~SharedLibrary() { if (mLib) { dlclose(mLib); } } SharedLibrary::FunctionPtr SharedLibrary::findSymbol( const char* symbolName) const { if (!mLib || !symbolName) { return NULL; } return reinterpret_cast(dlsym(mLib, symbolName)); } #endif // !_WIN32 } // namespace emugl anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/shared_library.h000066400000000000000000000062331356361734700276140ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef EMUGL_COMMON_SHARED_LIBRARY_H #define EMUGL_COMMON_SHARED_LIBRARY_H #include #ifdef _WIN32 #include #endif namespace emugl { // A class used to open a platform-specific shared library, and probe // it for symbols. Usage is the following: // // // Open the library. // SharedLibrary* library = SharedLibrary::open("libFoo"); // if (!library) { // ... could not find / open library! // } // // //Probe for function symbol. // FunctionPtr my_func = library->findSymbol("my_func"); // // // Closes library/ // delete library; // class SharedLibrary { public: // Open a given library. If |libraryName| has no extension, a // platform-appropriate extension is added and that path is opened. // If the |libraryName| has an extension, that form is opened. // // On OSX, some libraries don't include an extension (notably OpenGL) // On OSX we try to open |libraryName| first. If that doesn't exist, // we try |libraryName|.dylib // // On success, returns a new SharedLibrary instance that must be // deleted by the caller. static SharedLibrary* open(const char* libraryName); // A variant of open() that can report a human-readable error if loading // the library fails. |error| is a caller-provided buffer of |errorSize| // bytes that will be filled with snprintf() and always zero terminated. // // On success, return a new SharedLibrary instance, and do not touch // the content of |error|. On failure, return NULL, and sets the content // of |error|. static SharedLibrary* open(const char* libraryName, char* error, size_t errorSize); // Closes an existing SharedLibrary instance. ~SharedLibrary(); // Generic function pointer type, for values returned by the // findSymbol() method. typedef void (*FunctionPtr)(void); // Probe a given SharedLibrary instance to find a symbol named // |symbolName| in it. Return its address as a FunctionPtr, or // NULL if the symbol is not found. FunctionPtr findSymbol(const char* symbolName) const; private: #ifdef _WIN32 typedef HMODULE HandleType; #else typedef void* HandleType; #endif // Constructor intentionally hidden. SharedLibrary(HandleType); HandleType mLib; }; // Macro to compose emugl shared library name under various OS and bitness // eg. // on x86_64, EMUGL_LIBNAME("foo") --> "lib64foo" # define EMUGL_LIBNAME(name) "lib" name } // namespace emugl #endif // EMUGL_COMMON_SHARED_LIBRARY_H anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/shared_library_unittest.cpp000066400000000000000000000110721356361734700321030ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "emugl/common/shared_library.h" #include #include #include #include // Hack to get the current executable's full path. namespace testing { namespace internal { extern std::string g_executable_path; } // namespace internal } // namespace testing namespace emugl { namespace { // Return the name/path of the test shared library to load. // Note that this doesn't include a platform-specific extension. // This assumes that the test shared library is under the lib/ sub-directory // of the current executable's path! std::string GetTestLibraryName() { #ifdef __x86_64__ static const char kLibraryPrefix[] = "lib64"; static const char kSubDir[] = "lib64/"; #else static const char kLibraryPrefix[] = "lib"; static const char kSubDir[] = "lib/"; #endif static const char kTestLibrarySuffix[] = "emugl_test_shared_library"; const char* exec_path = testing::internal::g_executable_path.c_str(); #ifdef _WIN32 const char* p = strrchr(exec_path, '/'); const char* p2 = strrchr(exec_path, '\\'); if (p2) { if (!p || p2 > p) { p = p2; } } #else const char* p = strrchr(exec_path, '/'); #endif std::string path; if (!p) { path = "./"; } else { path = std::string(exec_path, p - exec_path + 1U); } path += kSubDir; path += kLibraryPrefix; path += kTestLibrarySuffix; printf("Library path: %s\n", path.c_str()); return path; } class SharedLibraryTest : public testing::Test { public: SharedLibraryTest() { // Locate the shared library mLibraryPath = GetTestLibraryName(); } ~SharedLibraryTest() {} const char* library_path() const { return mLibraryPath.c_str(); } private: std::string mLibraryPath; }; class ScopedSharedLibrary { public: explicit ScopedSharedLibrary(const SharedLibrary* lib) : mLib(lib) {} ~ScopedSharedLibrary() { delete mLib; } const SharedLibrary* get() const { return mLib; } const SharedLibrary* operator->() { return mLib; } void release() { delete mLib; mLib = NULL; } private: const SharedLibrary* mLib; }; } // namespace TEST_F(SharedLibraryTest, Open) { ScopedSharedLibrary lib(SharedLibrary::open(library_path())); EXPECT_TRUE(lib.get()); } TEST_F(SharedLibraryTest, OpenFailureWithError) { char error[256]; error[0] = '\0'; SharedLibrary* lib = SharedLibrary::open("/tmp/does/not/exists", error, sizeof(error)); EXPECT_FALSE(lib); EXPECT_TRUE(error[0]) << "Could not get error string when failing to load library"; printf("Expected library load failure: [%s]\n", error); } TEST_F(SharedLibraryTest, OpenLibraryWithExtension) { std::string path = library_path(); // test extension append ScopedSharedLibrary libNoExtension(SharedLibrary::open(path.c_str())); EXPECT_TRUE(libNoExtension.get()); libNoExtension.release(); #ifdef _WIN32 path += ".dll"; #elif defined(__APPLE__) // try to open the library without an extension path += ".dylib"; #else path += ".so"; #endif // test open with prepended extension ScopedSharedLibrary lib(SharedLibrary::open(path.c_str())); EXPECT_TRUE(lib.get()); } #ifdef __APPLE__ TEST_F(SharedLibraryTest, OpenLibraryWithoutExtension) { const char* library = "/System/Library/Frameworks/OpenGL.framework/OpenGL"; ScopedSharedLibrary lib(SharedLibrary::open(library)); EXPECT_TRUE(lib.get()); } #endif TEST_F(SharedLibraryTest, FindSymbol) { ScopedSharedLibrary lib(SharedLibrary::open(library_path())); EXPECT_TRUE(lib.get()); if (lib.get()) { typedef int (*FooFunction)(void); FooFunction foo_func = reinterpret_cast( lib->findSymbol("foo_function")); EXPECT_TRUE(foo_func); EXPECT_EQ(42, (*foo_func)()); } } } // namespace emugl anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/smart_ptr.cpp000066400000000000000000000045221356361734700271670ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "emugl/common/smart_ptr.h" #ifdef _WIN32 #define WIN32_LEAN_AND_MEAN #include #endif namespace emugl { // Thread-safe atomic reference-counting type. class RefCount { public: RefCount() : mCount(1) {} ~RefCount() {} // Technically not thread-safe, use only for testing. int count() const { return (int)mCount; } void increment() { #ifdef _WIN32 InterlockedIncrement(&mCount); #else __sync_fetch_and_add(&mCount, 1); #endif } bool decrement() { #ifdef _WIN32 return InterlockedDecrement(&mCount) == 0; #else return __sync_add_and_fetch(&mCount, -1) == 0; #endif } private: #ifdef _WIN32 LONG mCount; #else int mCount; #endif }; // SmartPtrBase implementation. SmartPtrBase::SmartPtrBase(void* ptr) : mPtr(ptr), mRefCount(NULL) { if (mPtr) mRefCount = new RefCount(); } SmartPtrBase::SmartPtrBase(const SmartPtrBase& other) : mPtr(other.mPtr), mRefCount(other.mRefCount) { if (mRefCount) mRefCount->increment(); } int SmartPtrBase::getRefCount() const { return mRefCount ? mRefCount->count() : 0; } void SmartPtrBase::addRef() { if (mRefCount) mRefCount->increment(); } void* SmartPtrBase::copyFrom(const SmartPtrBase& other) { void* old_ptr = release(); mPtr = other.mPtr; mRefCount = other.mRefCount; if (mRefCount) mRefCount->increment(); return old_ptr; } void* SmartPtrBase::release() { void* old_ptr = mPtr; RefCount* old_refcount = mRefCount; if (old_refcount) { mPtr = NULL; mRefCount = NULL; if (old_refcount->decrement()) { delete old_refcount; return old_ptr; } } return NULL; } } // namespace emugl anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/smart_ptr.h000066400000000000000000000120111356361734700266240ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef EMUGL_SMART_PTR_H #define EMUGL_SMART_PTR_H #include namespace emugl { // Hidden atomic ref-counting implementation. class RefCount; // Base class for all templated SmartPtr<> instances. Reduces // template expansion and code. Consider this to be an implementation // detail of SmartPtr<>, so don't rely on anything here. class SmartPtrBase { public: // Defrault constructor. SmartPtrBase() : mPtr(NULL), mRefCount(NULL) {} // Normal constructor. This takes ownership of |ptr|, though only // template instances are capable of destroying the object. explicit SmartPtrBase(void* ptr); // Copy-constructor, this increments the reference count. SmartPtrBase(const SmartPtrBase& other); // Assignment operator, also increments the reference count. SmartPtrBase& operator=(const SmartPtrBase& other); // Nothing happens in this destructor, the real work must be performed // in subclasses. ~SmartPtrBase() {} // Used to enable 'if (smart_ptr) { ... }' properly. operator void*() const { return mPtr; } // Return internal reference count value, only use for unit testing. int getRefCount() const; protected: // Used internally to increment the reference count. void addRef(); // Copy the |other| into this instance, returns the old pointer value // if it needs to be destroyed by the caller, or NULL otherwise. void* copyFrom(const SmartPtrBase& other); // Used internally to decrement the reference count, if it reaches 0, // returns the pointer to be destroyed, NULL otherwise. void* release(); void* mPtr; RefCount* mRefCount; }; // The real template class to be used for smart pointers. // Typical uses: // // SmartPtr ptr(new Foo()); // takes ownership. // SmartPtr ptr2; // empty pointer. // ptr2 = ptr; // copies pointer + increment reference count. // Foo* obj = ptr.Ptr(); // access pointed object. // ptr->DoStuff(); // operate directly on pointed object. // (*ptr)->DoStuff(); // same here. // // On scope exit, the internal reference count is decremented and the // object is deleted automatically when it reaches 0, indicating that // there are no more owners. // // IMPORTANT: You need to be sure that only one 'chain' of smart pointers // own a given object. I.e. the following is incorrect: // // Foo* foo = new Foo(); // create new instance. // SmartPtr ptr(foo); // |ptr| takes ownership of |foo|. // SmartPtr ptr2(foo); // |ptr2| takes also ownership of |foo|. // // The problem is that |ptr| and |ptr2| don't know anything about each // other, and will not share the same reference count. Once a smart pointer // owns an object, only use other smart pointers that are copy-constructed // or assigned with the initial one to keep everything consistent. template class SmartPtr : public emugl::SmartPtrBase { public: // Default constructor. The instance holds a NULL pointer. SmartPtr() : SmartPtrBase() {} // Regular constructor, takes ownership of |ptr|. explicit SmartPtr(T* ptr) : SmartPtrBase(ptr) {} // Copy-constructor, |this| and |other| will share the same internal // reference count, which is incremented by 1. SmartPtr(const SmartPtr& other) : SmartPtrBase(reinterpret_cast(other)) {} // Assignment operator, same semantics as copy-constructor. SmartPtr& operator=(const SmartPtr& other) { void* old_ptr = copyFrom(static_cast(other)); if (old_ptr) delete reinterpret_cast(old_ptr); return *this; } // Destructor, decrements reference count and destroys the object // if it reaches 0 (indicating this was the last owning smart pointer). ~SmartPtr() { void* ptr = release(); if (ptr) delete reinterpret_cast(ptr); } // Return owned object instance, or NULL. T* Ptr() const { return reinterpret_cast(mPtr); } // Return owned object instance, or NULL const T* constPtr() const { return reinterpret_cast(mPtr); } // Operate directly on owned object. T* operator->() const { return Ptr(); } // Return reference to owned object. T& operator*() const { return *Ptr(); } }; } // namespace emugl #endif // EMUGL_SMART_PTR_H anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/smart_ptr_unittest.cpp000066400000000000000000000063751356361734700311360ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "emugl/common/smart_ptr.h" #include namespace emugl { // This Test sub-class is used to track allocations and deallocations of // the MyTestClass instances that are created through newInstance(). // See below for typical usage. class SmartPtrTest : public testing::Test { public: SmartPtrTest() : mNewCount(0), mDeleteCount(0), mDoCount(0) {} ~SmartPtrTest() { mNewCount = 0; mDoCount = 0; mDeleteCount = 0; } class MyClass; MyClass* newInstance() { return new MyClass(this); } class MyClass { public: MyClass(SmartPtrTest* test) : mTest(test) { mTest->mNewCount++; } void doStuff() { mTest->mDoCount++; } ~MyClass() { mTest->mDeleteCount++; } private: SmartPtrTest* mTest; }; int mNewCount; int mDeleteCount; int mDoCount; }; TEST_F(SmartPtrTest, Empty) { SmartPtr ptr; EXPECT_FALSE(ptr.Ptr()); EXPECT_EQ(0, mNewCount); EXPECT_EQ(0, mDeleteCount); EXPECT_EQ(0, mDoCount); } TEST_F(SmartPtrTest, SingleRef) { MyClass* obj = newInstance(); EXPECT_EQ(1, mNewCount); { SmartPtr ptr(obj); EXPECT_EQ(obj, ptr.Ptr()); EXPECT_EQ(1, mNewCount); EXPECT_EQ(0, mDeleteCount); EXPECT_EQ(0, mDoCount); } // Check that the object was deleted. EXPECT_EQ(1, mDeleteCount); } TEST_F(SmartPtrTest, CopyConstructor) { MyClass* obj = newInstance(); EXPECT_EQ(1, mNewCount); { SmartPtr ptr1(obj); { SmartPtr ptr2(ptr1); EXPECT_EQ(2, ptr1.getRefCount()); EXPECT_EQ(2, ptr2.getRefCount()); EXPECT_EQ(1, mNewCount); EXPECT_EQ(0, mDeleteCount); EXPECT_EQ(0, mDoCount); } EXPECT_EQ(1, mNewCount); EXPECT_EQ(0, mDeleteCount); EXPECT_EQ(0, mDoCount); } EXPECT_EQ(1, mNewCount); EXPECT_EQ(1, mDeleteCount); EXPECT_EQ(0, mDoCount); } TEST_F(SmartPtrTest, AssignmentOperator) { SmartPtr ptr1(newInstance()); SmartPtr ptr2(newInstance()); EXPECT_EQ(2, mNewCount); EXPECT_EQ(0, mDeleteCount); EXPECT_EQ(0, mDoCount); ptr2 = ptr1; EXPECT_EQ(2, mNewCount); EXPECT_EQ(1, mDeleteCount); EXPECT_EQ(ptr1.Ptr(), ptr2.Ptr()); EXPECT_EQ(2, ptr1.getRefCount()); EXPECT_EQ(2, ptr2.getRefCount()); } TEST_F(SmartPtrTest, ArrowOperator) { SmartPtr ptr(newInstance()); ptr->doStuff(); EXPECT_EQ(1, mDoCount); (*ptr).doStuff(); EXPECT_EQ(2, mDoCount); } } // namespace emugl anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/sockets.cpp000066400000000000000000000142171356361734700266310ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "emugl/common/sockets.h" #include #ifdef _WIN32 #include #include #else #include #include #include #include #include #endif #include #include #include #include namespace emugl { namespace { static void socketSetDontLinger(int s) { #ifdef _WIN32 // TODO: Verify default behavior on WINDOWS #else // Ungraceful shutdown, no reason to linger at all struct linger so_linger; so_linger.l_onoff = 1; so_linger.l_linger = 0; if(setsockopt(s, SOL_SOCKET, SO_LINGER, &so_linger, sizeof so_linger) < 0) perror("Setting socket option SO_LINGER={on, 0} failed"); #endif } static void socketSetReuseAddress(int s) { #ifdef _WIN32 // The default behaviour on Windows is equivalent to SO_REUSEADDR // so we don't need to set this option. Moreover, one should never // set this option with WinSock because it's badly implemented and // generates a huge security issue. See: // http://msdn.microsoft.com/en-us/library/windows/desktop/ms740621(v=vs.85).aspx #else int val = 1; if(setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val)) < 0) perror("Setting socket option SO_REUSEADDR failed"); #endif } // Helper union to store a socket address. struct SockAddr { socklen_t len; union { sockaddr generic; sockaddr_in inet; #ifndef _WIN32 sockaddr_un local; #endif }; int getFamily() const { return generic.sa_family; } void initEmpty() { ::memset(this, 0, sizeof(*this)); this->len = static_cast(sizeof(*this)); } int initFromInet(uint32_t ip_address, int port) { if (port < 0 || port >= 65536) return -EINVAL; ::memset(this, 0, sizeof(*this)); this->inet.sin_family = AF_INET; this->inet.sin_port = htons(port); this->inet.sin_addr.s_addr = htonl(ip_address); this->len = sizeof(this->inet); return 0; } int initFromLocalhost(int port) { return initFromInet(0x7f000001, port); } #ifndef _WIN32 // Initialize the SockAddr from a Unix path. Returns 0 on success, // or -errno code on failure. int initFromUnixPath(const char* path) { if (!path || !path[0]) return -EINVAL; size_t pathLen = ::strlen(path); if (pathLen >= sizeof(local.sun_path)) return -E2BIG; ::memset(this, 0, sizeof(*this)); this->local.sun_family = AF_LOCAL; ::memcpy(this->local.sun_path, path, pathLen + 1U); this->len = pathLen + offsetof(sockaddr_un, sun_path); return 0; } #endif }; int socketBindInternal(const SockAddr* addr, int socketType) { int s = ::socket(addr->getFamily(), socketType, 0); if (s < 0) { perror("Could not create socket to bind"); return -errno; } socketSetDontLinger(s); socketSetReuseAddress(s); // Bind to the socket. if (::bind(s, &addr->generic, addr->len) < 0 || ::listen(s, 5) < 0) { int ret = -errno; perror("Could not bind or listen to socket"); ::close(s); return ret; } return s; } int socketConnectInternal(const SockAddr* addr, int socketType) { int s = ::socket(addr->getFamily(), socketType, 0); if (s < 0) { perror("Could not create socket to connect"); return -errno; } socketSetDontLinger(s); socketSetReuseAddress(s); int ret; do { ret = ::connect(s, &addr->generic, addr->len); } while (ret < 0 && errno == EINTR); if (ret < 0) { ret = -errno; ::close(s); return ret; } return s; } } // namespace void socketTcpDisableNagle(int s) { // disable Nagle algorithm to improve bandwidth of small // packets which are quite common in our implementation. #ifdef _WIN32 DWORD flag; #else int flag; #endif flag = 1; setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (const char*)&flag, sizeof(flag)); } int socketGetPort(int s) { SockAddr addr; addr.initEmpty(); if (getsockname(s, &addr.generic, &addr.len) < 0) { return -errno; } switch (addr.generic.sa_family) { case AF_INET: return ntohs(addr.inet.sin_port); default: ; } return -EINVAL; } #ifndef _WIN32 int socketLocalServer(const char* path, int socketType) { SockAddr addr; int ret = addr.initFromUnixPath(path); if (ret < 0) { return ret; } return socketBindInternal(&addr, socketType); } int socketLocalClient(const char* path, int socketType) { SockAddr addr; int ret = addr.initFromUnixPath(path); if (ret < 0) { return ret; } return socketConnectInternal(&addr, socketType); } #endif // !_WIN32 int socketTcpLoopbackServer(int port, int socketType) { SockAddr addr; int ret = addr.initFromLocalhost(port); if (ret < 0) { return ret; } return socketBindInternal(&addr, socketType); } int socketTcpLoopbackClient(int port, int socketType) { SockAddr addr; int ret = addr.initFromLocalhost(port); if (ret < 0) { return ret; } return socketConnectInternal(&addr, socketType); } int socketTcpClient(const char* hostname, int port, int socketType) { // TODO(digit): Implement this. return -ENOSYS; } int socketAccept(int serverSocket) { int ret; do { ret = ::accept(serverSocket, NULL, NULL); } while (ret < 0 && errno == EINTR); return ret; } } // namespace emugl anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/sockets.h000066400000000000000000000041131356361734700262700ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef EMUGL_COMMON_SOCKETS_H #define EMUGL_COMMON_SOCKETS_H // A set of helper functions used to deal with sockets in a portable way. namespace emugl { // Disable Nagle's algorithm for socket descriptor |s|. This assumes // that |s| is a TCP socket descriptor. void socketTcpDisableNagle(int s); // Return the port associated with a given IP or IPv6 socket, // or -errno code on failure. int socketGetPort(int s); // Bind to a local/Unix path, and return its socket descriptor on success, // or -errno code on failure. int socketLocalServer(const char* path, int socketType); // Connect to a Unix local path, and return a new socket descriptor // on success, or -errno code on failure. int socketLocalClient(const char* path, int socketType); // Bind to a localhost TCP socket, and return its socket descriptor on // success, or -errno code on failure. int socketTcpLoopbackServer(int port, int socketType); // Connect to a localhost TCP port, and return a new socket descriptor on // success, or -errno code on failure. int socketTcpLoopbackClient(int port, int socketType); // Connect to a TCP host, and return a new socket descriptor on // success, or -errno code on failure. int socketTcpClient(const char* hostname, int port, int socketType); // Accept a new connection. |serverSocket| must be a bound server socket // descriptor. Returns new socket descriptor on success, or -errno code // on failure. int socketAccept(int serverSocket); } // namespace emugl #endif // EMUGL_COMMON_SOCKETS_H anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/testing/000077500000000000000000000000001356361734700261225ustar00rootroot00000000000000anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/testing/test_shared_library.cpp000066400000000000000000000015201356361734700326550ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // This source file must be compiled into a simple shared library which // will be used by shared_library_unittest.cpp to verify that the // emugl::SharedLibrary class works properly. extern "C" int foo_function(void) { return 42; } anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/testing/test_thread.h000066400000000000000000000041001356361734700305740ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef EMUGL_COMMON_TESTING_TEST_THREAD_H #define EMUGL_COMMON_TESTING_TEST_THREAD_H #ifdef _WIN32 # define WIN32_LEAN_AND_MEAN 1 # include #else # include #endif namespace emugl { // Very basic platform thread wrapper that only uses a tiny stack. // This shall only be used during unit testing, and allows test code // to not depend on the implementation of emugl::Thread. class TestThread { public: // Main thread function type. typedef void* (ThreadFunction)(void* param); // Constructor actually launches a new platform thread. TestThread(ThreadFunction* func, void* funcParam) { #ifdef _WIN32 mThread = CreateThread(NULL, 16384, (DWORD WINAPI (*)(void*))func, funcParam, 0, NULL); #else pthread_attr_t attr; pthread_attr_init(&attr); pthread_attr_setstacksize(&attr, 16384); pthread_create(&mThread, &attr, func, funcParam); pthread_attr_destroy(&attr); #endif } ~TestThread() { #ifdef _WIN32 CloseHandle(mThread); #endif } void join() { #ifdef _WIN32 WaitForSingleObject(mThread, INFINITE); #else void* ret = NULL; pthread_join(mThread, &ret); #endif } private: #ifdef _WIN32 HANDLE mThread; #else pthread_t mThread; #endif }; } // namespace emugl #endif // EMUGL_COMMON_TESTING_TEST_THREAD_H anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/thread.h000066400000000000000000000052271356361734700260730ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef EMUGL_COMMON_THREAD_H #define EMUGL_COMMON_THREAD_H #ifdef _WIN32 #include #else #include #endif #include namespace emugl { // Wrapper class for platform-specific threads. // To create your own thread, define a sub-class of emugl::Thread // and override its main() method. // // For example: // // class MyThread : public emugl::Thread { // public: // MyThread() : Thread() {} // // virtual intptr_t main() { // ... main thread loop implementation // return 0; // } // }; // // ... // // // Create new instance, but does not start it. // MyThread* thread = new MyThread(); // // // Start the thread. // thread->start(); // // // Wait for thread completion, and gets result into |exitStatus|. // int exitStatus; // thread->wait(&exitStatus); // class Thread { public: // Public constructor. Thread(); // Virtual destructor. virtual ~Thread(); // Override this method in your own thread sub-classes. This will // be called when start() is invoked on the Thread instance. virtual intptr_t main() = 0; // Start a thread instance. Return true on success, false otherwise // (e.g. if the thread was already started or terminated). bool start(); // Wait for thread termination and retrieve exist status into // |*exitStatus|. Return true on success, false otherwise. // NOTE: |exitStatus| can be NULL. bool wait(intptr_t *exitStatus); // Check whether a thread has terminated. On success, return true // and sets |*exitStatus|. On failure, return false. // NOTE: |exitStatus| can be NULL. bool tryWait(intptr_t *exitStatus); private: #ifdef _WIN32 static DWORD WINAPI thread_main(void* arg); HANDLE mThread; DWORD mThreadId; CRITICAL_SECTION mLock; #else // !WIN32 static void* thread_main(void* arg); pthread_t mThread; pthread_mutex_t mLock; bool mJoined; #endif intptr_t mExitStatus; bool mIsRunning; }; } // namespace emugl #endif // EMUGL_COMMON_THREAD_H anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/thread_pthread.cpp000066400000000000000000000063341356361734700301350ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "emugl/common/thread.h" #include "emugl/common/thread_store.h" #include #include namespace emugl { namespace { class ScopedLocker { public: ScopedLocker(pthread_mutex_t* mutex) : mMutex(mutex) { pthread_mutex_lock(mMutex); } ~ScopedLocker() { pthread_mutex_unlock(mMutex); } private: pthread_mutex_t* mMutex; }; } // namespace Thread::Thread() : mThread((pthread_t)NULL), mLock(), mJoined(false), mExitStatus(0), mIsRunning(false) { pthread_mutex_init(&mLock, NULL); } Thread::~Thread() { assert(!mIsRunning); assert(mJoined); pthread_mutex_destroy(&mLock); } bool Thread::start() { bool ret = true; pthread_mutex_lock(&mLock); mIsRunning = true; if (pthread_create(&mThread, NULL, thread_main, this)) { ret = false; mIsRunning = false; } pthread_mutex_unlock(&mLock); return ret; } bool Thread::wait(intptr_t *exitStatus) { { ScopedLocker locker(&mLock); if (!mIsRunning) { // Thread already stopped. if (exitStatus) { *exitStatus = mExitStatus; } if (!mJoined) { // reclaim thread stack pthread_join(mThread, NULL); mJoined = true; } return true; } } // NOTE: Do not hold the lock when waiting for the thread to ensure // it can update mIsRunning and mExitStatus properly in thread_main // without blocking. void *retval; if (pthread_join(mThread, &retval)) { return false; } if (exitStatus) { *exitStatus = (intptr_t)retval; } // Note: Updating mJoined must be performed inside the lock to avoid // race conditions between two threads waiting for the same thread // that just completed its execution. { ScopedLocker locker(&mLock); mJoined = true; } return true; } bool Thread::tryWait(intptr_t *exitStatus) { ScopedLocker locker(&mLock); if (mIsRunning) { return false; } if (!mJoined) { // Reclaim stack. pthread_join(mThread, NULL); mJoined = true; } if (exitStatus) { *exitStatus = mExitStatus; } return true; } // static void* Thread::thread_main(void *arg) { Thread* self = reinterpret_cast(arg); intptr_t ret = self->main(); pthread_mutex_lock(&self->mLock); self->mIsRunning = false; self->mExitStatus = ret; pthread_mutex_unlock(&self->mLock); ::emugl::ThreadStore::OnThreadExit(); return (void*)ret; } } // namespace emugl anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/thread_store.cpp000066400000000000000000000161601356361734700276400ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "emugl/common/thread_store.h" #ifdef _WIN32 #include "emugl/common/lazy_instance.h" #endif #include #include #include #include // Set to 1 to print debug messages. #define DEBUG_THREAD_STORE 0 #if DEBUG_THREAD_STORE # define D(...) do { printf("%s:%d: ", __FUNCTION__, __LINE__); printf(__VA_ARGS__); fflush(stdout); } while (0) #else # define D(...) ((void)0) #endif namespace emugl { #ifdef _WIN32 namespace { // The ThreadStore implementation on Windows is very tricky, because // TlsAlloc() doesn't allow one to provide a destructor function. As // such threads are expected to destroy all TLS values explicitely. // // To solve this issue, this source file provides a static method called // ThreadStore::OnThreadExit() that must be called when a thread exits, // which will cleanup all values for the current thread. // // But this forces us to track thread-specific values ourselves. // Maximum amount of thread-specific slots supported by this implementation. enum { kMaxTlsSlots = 64 }; // TlsSlotArray is a thread-specific array of values. Instances will // be stored in a Win32 TLS value controlled by a single master TLS // key. // typedef void* TlsSlotArray[kMaxTlsSlots]; // Global state shared by all threads class GlobalState { public: GlobalState() { D("Entering\n"); mMasterTls = TlsAlloc(); D("Master TLS = %d\n", (int)mMasterTls); InitializeCriticalSection(&mSection); mLastIndex = 0; ::memset(mDestructors, 0, sizeof(mDestructors)); D("Exiting\n"); } // Register a new TLS key, or return -1 on error (too many keys). // |destroy| is the destructor function for the key. int registerKey(ThreadStore::Destructor* destroy) { D("Entering destroy=%p\n", destroy); int ret = -1; EnterCriticalSection(&mSection); if (mLastIndex < kMaxTlsSlots) { ret = mLastIndex++; mDestructors[ret] = destroy; } LeaveCriticalSection(&mSection); D("Exiting newKey=%d\n", ret); return ret; } void unregisterKey(int key) { D("key=%d\n", key); if (key < 0 || key >= kMaxTlsSlots) { D("Invalid key\n"); return; } // Note: keys are not reusable, but remove the destructor to avoid // crashes in leaveCurrentThread() when it points to a function that // is going to be unloaded from the process' address space. EnterCriticalSection(&mSection); mDestructors[key] = NULL; LeaveCriticalSection(&mSection); D("Exiting\n"); } // Get the current thread-local value for a given |key|. void* getValue(int key) const { D("Entering key=%d\n", key); if (key < 0 || key >= kMaxTlsSlots) { D("Invalid key, result=NULL\n"); return NULL; } TlsSlotArray* array = getArray(); void* ret = (*array)[key]; D("Exiting keyValue=%p\n", ret); return ret; } // Set the current thread-local |value| for a given |key|. void setValue(int key, void* value) { D("Entering key=%d\n",key); if (key < 0 || key >= kMaxTlsSlots) { D("Invalid key, returning\n"); return; } TlsSlotArray* array = getArray(); (*array)[key] = value; D("Exiting\n"); } // Call this when a thread exits to destroy all its thread-local values. void leaveCurrentThread() { D("Entering\n"); TlsSlotArray* array = reinterpret_cast(TlsGetValue(mMasterTls)); if (!array) { D("Exiting, no thread-local data in this thread\n"); return; } for (size_t n = 0; n < kMaxTlsSlots; ++n) { void* value = array[n]; if (value) { (*array)[n] = NULL; // NOTE: In theory, a destructor could reset the slot to // a new value, and we would have to loop in this function // in interesting ways. In practice, ignore the issue. EnterCriticalSection(&mSection); ThreadStore::Destructor* destroy = mDestructors[n]; LeaveCriticalSection(&mSection); if (destroy) { D("Calling destructor %p for key=%d, with value=%p\n", destroy, (int)n, value); (*destroy)(value); } } } TlsSetValue(mMasterTls, NULL); ::free(array); D("Exiting\n"); } private: // Return the thread-local array of TLS slots for the current thread. // Cannot return NULL. TlsSlotArray* getArray() const { D("Entering\n"); TlsSlotArray* array = reinterpret_cast(TlsGetValue(mMasterTls)); if (!array) { array = reinterpret_cast( ::calloc(sizeof(*array), 1)); TlsSetValue(mMasterTls, array); D("Allocated new array at %p\n", array); } else { D("Retrieved array at %p\n", array); } return array; } DWORD mMasterTls; CRITICAL_SECTION mSection; int mLastIndex; ThreadStore::Destructor* mDestructors[kMaxTlsSlots]; }; LazyInstance gGlobalState = LAZY_INSTANCE_INIT; } // namespace ThreadStore::ThreadStore(Destructor* destroy) { D("Entering this=%p destroy=%p\n", this, destroy); mKey = gGlobalState->registerKey(destroy); D("Exiting this=%p key=%d\n", this, mKey); } ThreadStore::~ThreadStore() { D("Entering this=%p\n", this); GlobalState* state = gGlobalState.ptr(); state->unregisterKey(mKey); D("Exiting this=%p\n", this); } void* ThreadStore::get() const { D("Entering this=%p\n", this); void* ret = gGlobalState->getValue(mKey); D("Exiting this=%p value=%p\n", this, ret); return ret; } void ThreadStore::set(void* value) { D("Entering this=%p value=%p\n", this, value); gGlobalState->setValue(mKey, value); D("Exiting this=%p\n", this); } // static void ThreadStore::OnThreadExit() { gGlobalState->leaveCurrentThread(); } #else // !_WIN32 ThreadStore::ThreadStore(Destructor* destroy) { int ret = pthread_key_create(&mKey, destroy); if (ret != 0) { fprintf(stderr, "Could not create thread store key: %s\n", strerror(ret)); exit(1); } } ThreadStore::~ThreadStore() { pthread_key_delete(mKey); } #endif // !_WIN32 } // namespace emugl anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/thread_store.h000066400000000000000000000066751356361734700273170ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef EMUGL_COMMON_THREAD_STORE_H #define EMUGL_COMMON_THREAD_STORE_H #ifdef _WIN32 # define WIN32_LEAN_AND_MEAN 1 # include #else # include #endif namespace emugl { // A class to model storage of thread-specific values, that can be // destroyed on thread exit. // // Note that on Windows, a thread must call OnThreadExit() explicitly // here to ensure that the values are probably discarded. This is an // unfortunate requirement of the Win32 API, which doesn't support // destructors at all. // // There are various hacks on the web to try to achieve this automatically // (e.g. [1]) but they rely on using the Microsoft build tools, // which doesn't work for us. // // Note another important issue with ThreadStore instances: if you create // one instance in a shared library, you need to make sure that it is // always destroyed before the library is unloaded. Otherwise, future // thread exit will likely crash, due to calling a destructor function // that is no longer in the process' address space. // // Finally, destroying an instance does _not_ free the corresponding values, // because doing so properly requires coordinating all participating threads, // which is impossible to achieve in the most general case. Thus, consider // that thread-local values are always leaked on library unload, or on // program exit. // // [1] http://stackoverflow.com/questions/14538159/about-tls-callback-in-windows class ThreadStore { public: // Type of a function used to destroy a thread-specific value that // was previously assigned by calling set(). typedef void (Destructor)(void* value); // Initialize instance so that is hold keys that must be destroyed // on thread exit by calling |destroy|. explicit ThreadStore(Destructor* destroy); // NOTE: Destructor don't free the thread-local values, but are required // to avoid crashes (see note above). ~ThreadStore(); // Retrieve current thread-specific value from store. #ifdef _WIN32 void* get() const; #else inline void* get() const { return pthread_getspecific(mKey); } #endif // Set the new thread-specific value. #ifdef _WIN32 void set(void* value); #else inline void set(void* value) { pthread_setspecific(mKey, value); } #endif #ifdef _WIN32 // Each thread should call this function on exit to ensure that // all corresponding TLS values are properly freed. static void OnThreadExit(); #else // Nothing to do on Posix. static inline void OnThreadExit() {} #endif private: // Ensure you can't create an empty ThreadStore instance, or simply // copy it in any way. ThreadStore(); ThreadStore(const ThreadStore&); ThreadStore& operator=(const ThreadStore&); #ifdef _WIN32 int mKey; #else pthread_key_t mKey; #endif }; } // namespace emugl #endif // EMUGL_COMMON_THREAD_STORE_H anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/thread_store_unittest.cpp000066400000000000000000000075351356361734700316050ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "emugl/common/thread_store.h" #include "emugl/common/mutex.h" #include "emugl/common/testing/test_thread.h" #include namespace emugl { namespace { // Helper class used to count instance creation and destruction. class StaticCounter { public: enum { kMaxInstances = 1000, }; StaticCounter() { Mutex::AutoLock lock(mMutex); if (mCreationCount < kMaxInstances) mInstances[mCreationCount] = this; mCreationCount++; } ~StaticCounter() { Mutex::AutoLock lock(mMutex); mDestructionCount++; } static void reset() { Mutex::AutoLock lock(mMutex); mCreationCount = 0; mDestructionCount = 0; } static size_t getCreationCount() { Mutex::AutoLock lock(mMutex); return mCreationCount; } static size_t getDestructionCount() { Mutex::AutoLock lock(mMutex); return mDestructionCount; } static void freeAll() { for (size_t n = 0; n < kMaxInstances; ++n) delete mInstances[n]; } private: static Mutex mMutex; static size_t mCreationCount; static size_t mDestructionCount; static StaticCounter* mInstances[kMaxInstances]; }; Mutex StaticCounter::mMutex; size_t StaticCounter::mCreationCount = 0; size_t StaticCounter::mDestructionCount = 0; StaticCounter* StaticCounter::mInstances[kMaxInstances]; } // namespace // Just check that we can create a new ThreadStore with an empty // destructor, and use it in the current thread. TEST(ThreadStore, MainThreadWithoutDestructor) { ThreadStore store(NULL); static int x = 42; store.set(&x); EXPECT_EQ(&x, store.get()); } // The following test checks that exiting a thread correctly deletes // any thread-local value stored in it. static void simplyDestroy(void* value) { delete (StaticCounter*) value; } static void* simpleThreadFunc(void* param) { ThreadStore* store = static_cast(param); store->set(new StaticCounter()); ThreadStore::OnThreadExit(); return NULL; } TEST(ThreadStore, ThreadsWithDestructor) { ThreadStore store(simplyDestroy); const size_t kNumThreads = 1000; TestThread* threads[kNumThreads]; StaticCounter::reset(); for (size_t n = 0; n < kNumThreads; ++n) { threads[n] = new TestThread(&simpleThreadFunc, &store); } for (size_t n = 0; n < kNumThreads; ++n) { threads[n]->join(); } EXPECT_EQ(kNumThreads, StaticCounter::getCreationCount()); EXPECT_EQ(kNumThreads, StaticCounter::getDestructionCount()); for (size_t n = 0; n < kNumThreads; ++n) { delete threads[n]; } } TEST(ThreadStore, ThreadsWithoutDestructor) { ThreadStore store(NULL); const size_t kNumThreads = 1000; TestThread* threads[kNumThreads]; StaticCounter::reset(); for (size_t n = 0; n < kNumThreads; ++n) { threads[n] = new TestThread(&simpleThreadFunc, &store); } for (size_t n = 0; n < kNumThreads; ++n) { threads[n]->join(); } EXPECT_EQ(kNumThreads, StaticCounter::getCreationCount()); EXPECT_EQ(0U, StaticCounter::getDestructionCount()); StaticCounter::freeAll(); for (size_t n = 0; n < kNumThreads; ++n) { delete threads[n]; } } } // namespace emugl anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/thread_unittest.cpp000066400000000000000000000076301356361734700303650ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "emugl/common/thread.h" #include "emugl/common/mutex.h" #include namespace emugl { namespace { // A simple thread instance that does nothing at all and exits immediately. class EmptyThread : public ::emugl::Thread { public: intptr_t main() { return 42; } }; class CountingThread : public ::emugl::Thread { public: class State { public: State() : mLock(), mCount(0) {} ~State() {} void increment() { mLock.lock(); mCount++; mLock.unlock(); } int count() const { int ret; mLock.lock(); ret = mCount; mLock.unlock(); return ret; } private: mutable Mutex mLock; int mCount; }; CountingThread(State* state) : mState(state) {} intptr_t main() { mState->increment(); return 0; } private: State* mState; }; class WaitingThread : public ::emugl::Thread { public: WaitingThread(Mutex* lock) : mLock(lock) {} intptr_t main() { // Try to acquire lock. mLock->lock(); // Then try to release it. mLock->unlock(); return 0; } private: Mutex* mLock; }; } // namespace TEST(ThreadTest, WaitForSimpleThread) { Thread* thread = new EmptyThread(); EXPECT_TRUE(thread); EXPECT_TRUE(thread->start()); intptr_t status; EXPECT_TRUE(thread->wait(&status)); EXPECT_EQ(42, status); } TEST(ThreadTest, WaitForMultipleThreads) { CountingThread::State state; const size_t kMaxThreads = 100; Thread* threads[kMaxThreads]; // Create all threads. for (size_t n = 0; n < kMaxThreads; ++n) { threads[n] = new CountingThread(&state); EXPECT_TRUE(threads[n]) << "thread " << n; } // Start them all. for (size_t n = 0; n < kMaxThreads; ++n) { EXPECT_TRUE(threads[n]->start()) << "thread " << n; } // Wait for them all. for (size_t n = 0; n < kMaxThreads; ++n) { EXPECT_TRUE(threads[n]->wait(NULL)) << "thread " << n; } // Check state. EXPECT_EQ((int)kMaxThreads, state.count()); // Delete them all. for (size_t n = 0; n < kMaxThreads; ++n) { delete threads[n]; } } TEST(ThreadTest, TryWaitForMultipleThreads) { Mutex lock; const size_t kMaxThreads = 100; Thread* threads[kMaxThreads]; // Create all threads. for (size_t n = 0; n < kMaxThreads; ++n) { threads[n] = new WaitingThread(&lock); EXPECT_TRUE(threads[n]) << "thread " << n; } // Acquire the lock, this will block all threads. lock.lock(); // Start them all. for (size_t n = 0; n < kMaxThreads; ++n) { EXPECT_TRUE(threads[n]->start()) << "thread " << n; } // Check that tryWait() fails for all threads. for (size_t n = 0; n < kMaxThreads; ++n) { EXPECT_FALSE(threads[n]->tryWait(NULL)) << "thread" << n; } // Release the lock, this will unblock all threads. lock.unlock(); // Wait for them all. for (size_t n = 0; n < kMaxThreads; ++n) { EXPECT_TRUE(threads[n]->wait(NULL)) << "thread " << n; EXPECT_TRUE(threads[n]->tryWait(NULL)) << "thread " << n; } // Delete them all. for (size_t n = 0; n < kMaxThreads; ++n) { delete threads[n]; } } } // namespace emugl anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/thread_win32.cpp000066400000000000000000000055241356361734700274500ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "emugl/common/thread.h" #include "emugl/common/thread_store.h" namespace emugl { namespace { class ScopedLocker { public: ScopedLocker(CRITICAL_SECTION* section) : mSection(section) { EnterCriticalSection(mSection); } ~ScopedLocker() { LeaveCriticalSection(mSection); } private: CRITICAL_SECTION* mSection; }; } // namespace Thread::Thread() : mThread(INVALID_HANDLE_VALUE), mThreadId(0), mExitStatus(0), mIsRunning(false) { InitializeCriticalSection(&mLock); } Thread::~Thread() { if(mThread != INVALID_HANDLE_VALUE) { CloseHandle(mThread); } DeleteCriticalSection(&mLock); } bool Thread::start() { ScopedLocker locker(&mLock); bool ret = true; mIsRunning = true; mThread = CreateThread(NULL, 0, &Thread::thread_main, this, 0, &mThreadId); if (!mThread) { ret = false; mIsRunning = false; } return ret; } bool Thread::wait(intptr_t* exitStatus) { { ScopedLocker locker(&mLock); if (!mIsRunning) { // Thread already stopped. if (exitStatus) { *exitStatus = mExitStatus; } return true; } } // NOTE: Do not hold lock during wait to aloow thread_main to // properly update mIsRunning and mExitStatus on thread exit. if (WaitForSingleObject(mThread, INFINITE) == WAIT_FAILED) { return false; } if (exitStatus) { ScopedLocker locker(&mLock); *exitStatus = mExitStatus; } return true; } bool Thread::tryWait(intptr_t* exitStatus) { ScopedLocker locker(&mLock); if (mIsRunning && WaitForSingleObject(mThread, 0) != WAIT_OBJECT_0) { return false; } if (exitStatus) { *exitStatus = mExitStatus; } return true; } // static DWORD WINAPI Thread::thread_main(void *arg) { Thread* self = reinterpret_cast(arg); intptr_t ret = self->main(); EnterCriticalSection(&self->mLock); self->mIsRunning = false; self->mExitStatus = ret; LeaveCriticalSection(&self->mLock); // Ensure all thread-local values are released for this thread. ::emugl::ThreadStore::OnThreadExit(); return static_cast(ret); } } // namespace emugl anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/unique_integer_map.h000066400000000000000000000143031356361734700304770ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef EMUGL_COMMON_UNIQUE_INTEGER_MAP_H #define EMUGL_COMMON_UNIQUE_INTEGER_MAP_H #include "emugl/common/pod_vector.h" #include namespace emugl { // Helper template class that implements a bi-directional mapping between // two integer types |A| and |B|. More specifically: // // - The map allocates values of type |B| when a key of type |A| is entered // in the map. // // - keys and values cannot be 0, which is reserved (i.e. means 'invalid'). // // This is used in EmuGL to map liberal 'void*' values (e.g. EGLimages ones) // to unique 32-bit IDs that can be written to / read from the wire protocol. template class UniqueIntegerMap { public: UniqueIntegerMap() : mForwardPairs(), mBackwardPairs() {} ~UniqueIntegerMap() {} // Return true iff the map is empty. const bool empty() const { return mForwardPairs.empty(); } // Return the number of (key,value) pairs in the map. size_t size() const { return mForwardPairs.size(); } // Find the value associated with |key| in the map. // Returns 0 in case of failure, or if |key| is 0. B find(const A key) const; // Find the key associated with a given |value| in the map. // Returns 0 if |value| is 0, or in case of failure. A findKeyFor(const B value) const; // Add |key| to the map and return an automatically-allocated // unique value for it. Return 0 if |key| is 0. B add(const A key); // Delete the entry associated with a given |key|. The // corresponding value may be recycled by future calls to add(). void del(const A key); private: typedef struct { A first; B second; } ForwardPair; typedef struct { B first; A second; } BackwardPair; size_t findKeyIndexPlusOne(const A key) const; size_t findValueIndexPlusOne(const B value) const; B allocValue(); void freeValue(B value); PodVector mForwardPairs; PodVector mBackwardPairs; B mLastValue; PodVector mFreeValues; }; template B UniqueIntegerMap::find(const A key) const { size_t keyIndex = findKeyIndexPlusOne(key); if (!keyIndex) { return 0; } return mForwardPairs[keyIndex - 1U].second; } template A UniqueIntegerMap::findKeyFor(const B value) const { size_t valueIndex = findValueIndexPlusOne(value); if (!valueIndex) { return 0; } return mBackwardPairs[valueIndex - 1U].second; } template B UniqueIntegerMap::add(const A key) { // Binary search to find the proper insertion point for the key. // Also checks that the key isn't already in the set. size_t min = 0; size_t max = mForwardPairs.size(); while (min < max) { size_t mid = min + ((max - min) >> 1); A midKey = mForwardPairs[mid].first; if (midKey < key) { min = mid + 1U; } else if (midKey > key) { max = mid; } else { // Already in the set. return 0; } } // Generate new unique value B value = allocValue(); ForwardPair* pair = mForwardPairs.emplace(min); pair->first = key; pair->second = value; // Binary search to find proper insertion point for the value. min = 0; max = mBackwardPairs.size(); while (min < max) { size_t mid = min + ((max - min) >> 1); B midValue = mBackwardPairs[mid].first; if (midValue < value) { min = mid + 1U; } else { max = mid; } } BackwardPair* backPair = mBackwardPairs.emplace(min); backPair->first = value; backPair->second = key; return value; } template void UniqueIntegerMap::del(const A key) { size_t keyIndex = findKeyIndexPlusOne(key); if (!keyIndex) { return; } B value = mForwardPairs[keyIndex - 1U].second; size_t valueIndex = findValueIndexPlusOne(value); mForwardPairs.remove(keyIndex - 1U); mBackwardPairs.remove(valueIndex - 1U); freeValue(value); } template size_t UniqueIntegerMap::findKeyIndexPlusOne(const A key) const { // Binary search in forward pair array. size_t min = 0; size_t max = mForwardPairs.size(); while (min < max) { size_t mid = min + ((max - min) >> 1); A midKey = mForwardPairs[mid].first; if (midKey < key) { min = mid + 1U; } else if (midKey > key) { max = mid; } else { return mid + 1U; } } return 0U; } template size_t UniqueIntegerMap::findValueIndexPlusOne(const B value) const { // Binary search in revere pair array. size_t min = 0; size_t max = mBackwardPairs.size(); while (min < max) { size_t mid = min + ((max - min) >> 1); B midValue = mBackwardPairs[mid].first; if (midValue < value) { min = mid + 1U; } else if (midValue > value) { max = mid; } else { return mid + 1U; } } return 0U; } template B UniqueIntegerMap::allocValue() { if (!mFreeValues.empty()) { B result = mFreeValues[0]; mFreeValues.pop(); return result; } return ++mLastValue; } template void UniqueIntegerMap::freeValue(B value) { if (!value) { return; } if (value == mLastValue) { mLastValue--; return; } mFreeValues.append(value); } } // namespace emugl #endif // EMUGL_COMMON_INTEGER_MAP_H anbox-0.0~git20191115/external/android-emugl/shared/emugl/common/unique_integer_map_unittest.cpp000066400000000000000000000053771356361734700330040ustar00rootroot00000000000000// Copyright (C) 2014 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "emugl/common/unique_integer_map.h" #include #include namespace emugl { typedef UniqueIntegerMap MyMap; TEST(UniqueIntegerMap, Empty) { MyMap map; EXPECT_TRUE(map.empty()); EXPECT_EQ(0U, map.size()); EXPECT_EQ(0U, map.find(0U)); EXPECT_EQ(0U, map.find(1U)); EXPECT_EQ(0U, map.find(2U)); EXPECT_EQ(0U, map.find(4U)); } TEST(UniqueIntegerMap, AddOne) { MyMap map; uintptr_t key1 = 1U; uint32_t val1 = map.add(key1); EXPECT_NE(0U, val1); EXPECT_EQ(val1, map.find(key1)); EXPECT_EQ(key1, map.findKeyFor(val1)); EXPECT_FALSE(map.empty()); EXPECT_EQ(1U, map.size()); EXPECT_EQ(0U, map.find(0)); EXPECT_EQ(0U, map.findKeyFor(0)); EXPECT_EQ(0U, map.find(key1 + 1)); EXPECT_EQ(0U, map.findKeyFor(val1 + 1)); } TEST(UniqueIntegerMap, AddMultiple) { MyMap map; const size_t kCount = 100; const size_t kKeyMultiplier = 3U; // must be >= 2. uint32_t values[kCount]; for (size_t n = 0; n < kCount; ++n) { uintptr_t key = 1U + n * kKeyMultiplier; values[n] = map.add(key); EXPECT_NE(0U, values[n]) << "key #" << n; } EXPECT_EQ(kCount, map.size()); for (size_t n = 0; n < kCount; ++n) { uintptr_t key = 1U + n * kKeyMultiplier; EXPECT_EQ(values[n], map.find(key)) << "key #" << n; EXPECT_EQ(0U, map.find(key + 1U)) << "key #" << n; } for (size_t n = 0; n < kCount; ++n) { uintptr_t key = 1U + n * kKeyMultiplier; EXPECT_EQ(key, map.findKeyFor(values[n])); } } TEST(UniqueIntegerMap, Del) { MyMap map; const size_t kCount = 100; const size_t kKeyMultiplier = 3U; // must be >= 2. uint32_t values[kCount]; for (size_t n = 0; n < kCount; ++n) { uintptr_t key = 1U + n * kKeyMultiplier; values[n] = map.add(key); } for (size_t n = 0; n < kCount; ++n) { uintptr_t key = 1U + n * kKeyMultiplier; map.del(key); EXPECT_EQ(kCount - 1U - n, map.size()); EXPECT_EQ(0U, map.find(key)); EXPECT_EQ(0U, map.findKeyFor(values[n])); } EXPECT_TRUE(map.empty()); } } // namespace emugl anbox-0.0~git20191115/external/backward-cpp/000077500000000000000000000000001356361734700204055ustar00rootroot00000000000000anbox-0.0~git20191115/external/backward-cpp/.gitignore000066400000000000000000000000161356361734700223720ustar00rootroot00000000000000build*/ *.pyc anbox-0.0~git20191115/external/backward-cpp/.travis.yml000066400000000000000000000013301356361734700225130ustar00rootroot00000000000000language: cpp compiler: - gcc - clang addons: apt: packages: - valgrind install: - DEPS_DIR="${TRAVIS_BUILD_DIR}/deps" - mkdir ${DEPS_DIR} && cd ${DEPS_DIR} - CMAKE_URL="http://www.cmake.org/files/v3.3/cmake-3.3.2-Linux-x86_64.tar.gz" - mkdir cmake && travis_retry wget --no-check-certificate --quiet -O - ${CMAKE_URL} | tar --strip-components=1 -xz -C cmake - export PATH=${DEPS_DIR}/cmake/bin:${PATH} - pip install --user conan && export PATH=$PATH:$HOME/.local/bin - cd ${TRAVIS_BUILD_DIR} - mkdir build && cd build - cmake .. -DBACKWARD_TESTS=ON - cmake --build . script: - valgrind ctest .. --verbose - cd ${TRAVIS_BUILD_DIR} && conan create . Manu343726/testing --build=outdated anbox-0.0~git20191115/external/backward-cpp/BackwardConfig.cmake000066400000000000000000000167561356361734700242720ustar00rootroot00000000000000# # BackwardMacros.cmake # Copyright 2013 Google Inc. All Rights Reserved. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. ############################################################################### # OPTIONS ############################################################################### set(STACK_WALKING_UNWIND TRUE CACHE BOOL "Use compiler's unwind API") set(STACK_WALKING_BACKTRACE FALSE CACHE BOOL "Use backtrace from (e)glibc for stack walking") set(STACK_DETAILS_AUTO_DETECT TRUE CACHE BOOL "Auto detect backward's stack details dependencies") set(STACK_DETAILS_BACKTRACE_SYMBOL FALSE CACHE BOOL "Use backtrace from (e)glibc for symbols resolution") set(STACK_DETAILS_DW FALSE CACHE BOOL "Use libdw to read debug info") set(STACK_DETAILS_BFD FALSE CACHE BOOL "Use libbfd to read debug info") set(STACK_DETAILS_DWARF FALSE CACHE BOOL "Use libdwarf/libelf to read debug info") set(BACKWARD_TESTS FALSE CACHE BOOL "Enable tests") ############################################################################### # CONFIGS ############################################################################### if (${STACK_DETAILS_AUTO_DETECT}) include(FindPackageHandleStandardArgs) # find libdw find_path(LIBDW_INCLUDE_DIR NAMES "elfutils/libdw.h" "elfutils/libdwfl.h") find_library(LIBDW_LIBRARY dw) set(LIBDW_INCLUDE_DIRS ${LIBDW_INCLUDE_DIR} ) set(LIBDW_LIBRARIES ${LIBDW_LIBRARY} ) find_package_handle_standard_args(libdw DEFAULT_MSG LIBDW_LIBRARY LIBDW_INCLUDE_DIR) mark_as_advanced(LIBDW_INCLUDE_DIR LIBDW_LIBRARY) # find libbfd find_path(LIBBFD_INCLUDE_DIR NAMES "bfd.h") find_path(LIBDL_INCLUDE_DIR NAMES "dlfcn.h") find_library(LIBBFD_LIBRARY bfd) find_library(LIBDL_LIBRARY dl) set(LIBBFD_INCLUDE_DIRS ${LIBBFD_INCLUDE_DIR} ${LIBDL_INCLUDE_DIR}) set(LIBBFD_LIBRARIES ${LIBBFD_LIBRARY} ${LIBDL_LIBRARY}) find_package_handle_standard_args(libbfd DEFAULT_MSG LIBBFD_LIBRARY LIBBFD_INCLUDE_DIR LIBDL_LIBRARY LIBDL_INCLUDE_DIR) mark_as_advanced(LIBBFD_INCLUDE_DIR LIBBFD_LIBRARY LIBDL_INCLUDE_DIR LIBDL_LIBRARY) # find libdwarf find_path(LIBDWARF_INCLUDE_DIR NAMES "libdwarf.h" PATH_SUFFIXES libdwarf) find_path(LIBELF_INCLUDE_DIR NAMES "libelf.h") find_path(LIBDL_INCLUDE_DIR NAMES "dlfcn.h") find_library(LIBDWARF_LIBRARY dwarf) find_library(LIBELF_LIBRARY elf) find_library(LIBDL_LIBRARY dl) set(LIBDWARF_INCLUDE_DIRS ${LIBDWARF_INCLUDE_DIR} ${LIBELF_INCLUDE_DIR} ${LIBDL_INCLUDE_DIR}) set(LIBDWARF_LIBRARIES ${LIBDWARF_LIBRARY} ${LIBELF_LIBRARY} ${LIBDL_LIBRARY}) find_package_handle_standard_args(libdwarf DEFAULT_MSG LIBDWARF_LIBRARY LIBDWARF_INCLUDE_DIR LIBELF_LIBRARY LIBELF_INCLUDE_DIR LIBDL_LIBRARY LIBDL_INCLUDE_DIR) mark_as_advanced(LIBDWARF_INCLUDE_DIR LIBDWARF_LIBRARY LIBELF_INCLUDE_DIR LIBELF_LIBRARY LIBDL_INCLUDE_DIR LIBDL_LIBRARY) if (LIBDW_FOUND) LIST(APPEND _BACKWARD_INCLUDE_DIRS ${LIBDW_INCLUDE_DIRS}) LIST(APPEND _BACKWARD_LIBRARIES ${LIBDW_LIBRARIES}) set(STACK_DETAILS_DW TRUE) set(STACK_DETAILS_BFD FALSE) set(STACK_DETAILS_DWARF FALSE) set(STACK_DETAILS_BACKTRACE_SYMBOL FALSE) elseif(LIBBFD_FOUND) LIST(APPEND _BACKWARD_INCLUDE_DIRS ${LIBBFD_INCLUDE_DIRS}) LIST(APPEND _BACKWARD_LIBRARIES ${LIBBFD_LIBRARIES}) # If we attempt to link against static bfd, make sure to link its dependencies, too get_filename_component(bfd_lib_ext "${LIBBFD_LIBRARY}" EXT) if (bfd_lib_ext STREQUAL "${CMAKE_STATIC_LIBRARY_SUFFIX}") list(APPEND _BACKWARD_LIBRARIES iberty z) endif() set(STACK_DETAILS_DW FALSE) set(STACK_DETAILS_BFD TRUE) set(STACK_DETAILS_DWARF FALSE) set(STACK_DETAILS_BACKTRACE_SYMBOL FALSE) elseif(LIBDWARF_FOUND) LIST(APPEND _BACKWARD_INCLUDE_DIRS ${LIBDWARF_INCLUDE_DIRS}) LIST(APPEND BACKWARD_LIBRARIES ${LIBDWARF_LIBRARIES}) set(STACK_DETAILS_DW FALSE) set(STACK_DETAILS_BFD FALSE) set(STACK_DETAILS_DWARF TRUE) set(STACK_DETAILS_BACKTRACE_SYMBOL FALSE) else() set(STACK_DETAILS_DW FALSE) set(STACK_DETAILS_BFD FALSE) set(STACK_DETAILS_DWARF FALSE) set(STACK_DETAILS_BACKTRACE_SYMBOL TRUE) endif() else() if (STACK_DETAILS_DW) LIST(APPEND _BACKWARD_LIBRARIES dw) endif() if (STACK_DETAILS_BFD) LIST(APPEND _BACKWARD_LIBRARIES bfd dl) endif() if (STACK_DETAILS_DWARF) LIST(APPEND _BACKWARD_LIBRARIES dwarf elf) endif() endif() macro(map_definitions var_prefix define_prefix) foreach(def ${ARGN}) if (${${var_prefix}${def}}) LIST(APPEND _BACKWARD_DEFINITIONS "${define_prefix}${def}=1") else() LIST(APPEND _BACKWARD_DEFINITIONS "${define_prefix}${def}=0") endif() endforeach() endmacro() if (NOT _BACKWARD_DEFINITIONS) map_definitions("STACK_WALKING_" "BACKWARD_HAS_" UNWIND BACKTRACE) map_definitions("STACK_DETAILS_" "BACKWARD_HAS_" BACKTRACE_SYMBOL DW BFD DWARF) endif() set(BACKWARD_INCLUDE_DIR "${CMAKE_CURRENT_LIST_DIR}") set(BACKWARD_HAS_EXTERNAL_LIBRARIES FALSE) set(FIND_PACKAGE_REQUIRED_VARS BACKWARD_INCLUDE_DIR) if(DEFINED _BACKWARD_LIBRARIES) set(BACKWARD_HAS_EXTERNAL_LIBRARIES TRUE) list(APPEND FIND_PACKAGE_REQUIRED_VARS _BACKWARD_LIBRARIES) endif() include(FindPackageHandleStandardArgs) find_package_handle_standard_args(Backward REQUIRED_VARS ${FIND_PACKAGE_REQUIRED_VARS} ) list(APPEND _BACKWARD_INCLUDE_DIRS ${BACKWARD_INCLUDE_DIR}) macro(add_backward target) target_include_directories(${target} PRIVATE ${BACKWARD_INCLUDE_DIRS}) set_property(TARGET ${target} APPEND PROPERTY COMPILE_DEFINITIONS ${BACKWARD_DEFINITIONS}) set_property(TARGET ${target} APPEND PROPERTY LINK_LIBRARIES ${BACKWARD_LIBRARIES}) endmacro() set(BACKWARD_INCLUDE_DIRS ${_BACKWARD_INCLUDE_DIRS} CACHE INTERNAL "_BACKWARD_INCLUDE_DIRS") set(BACKWARD_DEFINITIONS ${_BACKWARD_DEFINITIONS} CACHE INTERNAL "BACKWARD_DEFINITIONS") set(BACKWARD_LIBRARIES ${_BACKWARD_LIBRARIES} CACHE INTERNAL "BACKWARD_LIBRARIES") mark_as_advanced(BACKWARD_INCLUDE_DIRS BACKWARD_DEFINITIONS BACKWARD_LIBRARIES) # Expand each definition in BACKWARD_DEFINITIONS to its own cmake var and export # to outer scope foreach(var ${BACKWARD_DEFINITIONS}) string(REPLACE "=" ";" var_as_list ${var}) list(GET var_as_list 0 var_name) list(GET var_as_list 1 var_value) set(${var_name} ${var_value}) mark_as_advanced(${var_name}) endforeach() if (NOT TARGET Backward::Backward) add_library(Backward::Backward INTERFACE IMPORTED) set_target_properties(Backward::Backward PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${BACKWARD_INCLUDE_DIRS}" INTERFACE_COMPILE_DEFINITIONS "${BACKWARD_DEFINITIONS}" ) if(BACKWARD_HAS_EXTERNAL_LIBRARIES) set_target_properties(Backward::Backward PROPERTIES INTERFACE_LINK_LIBRARIES "${BACKWARD_LIBRARIES}" ) endif() endif() anbox-0.0~git20191115/external/backward-cpp/CMakeLists.txt000066400000000000000000000103601356361734700231450ustar00rootroot00000000000000# # CMakeLists.txt # Copyright 2013 Google Inc. All Rights Reserved. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. cmake_minimum_required(VERSION 2.8.12) project(backward CXX) include(BackwardConfig.cmake) # check if compiler is nvcc or nvcc_wrapper set(COMPILER_IS_NVCC false) get_filename_component(COMPILER_NAME ${CMAKE_CXX_COMPILER} NAME) if (COMPILER_NAME MATCHES "^nvcc") set(COMPILER_IS_NVCC true) endif() # set CXX standard set(CMAKE_CXX_STANDARD_REQUIRED True) set(CMAKE_CXX_STANDARD 11) if (${COMPILER_IS_NVCC}) # GNU CXX extensions are not supported by nvcc set(CMAKE_CXX_EXTENSIONS OFF) endif() ############################################################################### # COMPILER FLAGS ############################################################################### if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_COMPILER_IS_GNUCXX) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra") if (NOT ${COMPILER_IS_NVCC}) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic-errors") endif() set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g") endif() # Anbox: allow old-style cast, unknown pragmas set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=old-style-cast -Wno-error=unknown-pragmas -Wno-error=switch-default") ############################################################################### # BACKWARD OBJECT ############################################################################### add_library(backward_object OBJECT backward.cpp) target_compile_definitions(backward_object PRIVATE ${BACKWARD_DEFINITIONS}) target_include_directories(backward_object PRIVATE ${BACKWARD_INCLUDE_DIRS}) set(BACKWARD_ENABLE $ CACHE STRING "Link with this object to setup backward automatically") ############################################################################### # BACKWARD LIBRARY (Includes backward.cpp) ############################################################################### option(BACKWARD_SHARED "Build dynamic backward-cpp shared lib" OFF) if(BACKWARD_SHARED) set(libtype SHARED) endif() add_library(backward ${libtype} backward.cpp) target_compile_definitions(backward PUBLIC ${BACKWARD_DEFINITIONS}) target_include_directories(backward PUBLIC ${BACKWARD_INCLUDE_DIRS}) ############################################################################### # TESTS ############################################################################### if(BACKWARD_TESTS) enable_testing() add_library(test_main SHARED test/_test_main.cpp) macro(backward_add_test src) get_filename_component(name ${src} NAME_WE) set(test_name "test_${name}") add_executable(${test_name} ${src} ${ARGN}) target_link_libraries(${test_name} PRIVATE Backward::Backward test_main) add_test(NAME ${name} COMMAND ${test_name}) endmacro() # Tests without backward.cpp set(TESTS test stacktrace rectrace select_signals ) foreach(test ${TESTS}) backward_add_test(test/${test}.cpp) endforeach() # Tests with backward.cpp set(TESTS suicide ) foreach(test ${TESTS}) backward_add_test(test/${test}.cpp ${BACKWARD_ENABLE}) endforeach() endif() install( FILES "backward.hpp" DESTINATION ${CMAKE_INSTALL_PREFIX}/include ) install( FILES "BackwardConfig.cmake" DESTINATION ${CMAKE_INSTALL_PREFIX}/lib/backward ) anbox-0.0~git20191115/external/backward-cpp/LICENSE.txt000066400000000000000000000021071356361734700222300ustar00rootroot00000000000000Copyright 2013 Google Inc. All Rights Reserved. The MIT License (MIT) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. anbox-0.0~git20191115/external/backward-cpp/README.md000066400000000000000000000332561356361734700216750ustar00rootroot00000000000000Backward-cpp [![badge](https://img.shields.io/badge/conan.io-backward%2F1.3.0-green.svg?logo=data:image/png;base64%2CiVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAMAAAAolt3jAAAA1VBMVEUAAABhlctjlstkl8tlmMtlmMxlmcxmmcxnmsxpnMxpnM1qnc1sn85voM91oM11oc1xotB2oc56pNF6pNJ2ptJ8ptJ8ptN9ptN8p9N5qNJ9p9N9p9R8qtOBqdSAqtOAqtR%2BrNSCrNJ/rdWDrNWCsNWCsNaJs9eLs9iRvNuVvdyVv9yXwd2Zwt6axN6dxt%2Bfx%2BChyeGiyuGjyuCjyuGly%2BGlzOKmzOGozuKoz%2BKqz%2BOq0OOv1OWw1OWw1eWx1eWy1uay1%2Baz1%2Baz1%2Bez2Oe02Oe12ee22ujUGwH3AAAAAXRSTlMAQObYZgAAAAFiS0dEAIgFHUgAAAAJcEhZcwAACxMAAAsTAQCanBgAAAAHdElNRQfgBQkREyOxFIh/AAAAiklEQVQI12NgAAMbOwY4sLZ2NtQ1coVKWNvoc/Eq8XDr2wB5Ig62ekza9vaOqpK2TpoMzOxaFtwqZua2Bm4makIM7OzMAjoaCqYuxooSUqJALjs7o4yVpbowvzSUy87KqSwmxQfnsrPISyFzWeWAXCkpMaBVIC4bmCsOdgiUKwh3JojLgAQ4ZCE0AMm2D29tZwe6AAAAAElFTkSuQmCC)](http://www.conan.io/source/backward/1.3.0/Manu343726/testing) [![Build Status](https://travis-ci.org/bombela/backward-cpp.svg?branch=master)](https://travis-ci.org/bombela/backward-cpp) ============ Backward is a beautiful stack trace pretty printer for C++. If you are bored to see this: ![default trace](doc/rude.png) Backward will spice it up for you: ![pretty stackstrace](doc/pretty.png) There is not much to say. Of course it will be able to display the code snippets only if the source files are accessible (else see trace #4 in the example). All "Source" lines and code snippet prefixed by a pipe "|" are frames inline the next frame. You can see that for the trace #1 in the example, the function `you_shall_not_pass()` was inlined in the function `...read2::do_test()` by the compiler. ## Installation #### Install backward.hpp Backward is a header only library. So installing Backward is easy, simply drop a copy of `backward.hpp` along with your other source files in your C++ project. You can also use a git submodule or really any other way that best fits your environment, as long as you can include `backward.hpp`. #### Install backward.cpp If you want Backward to automatically print a stack trace on most common fatal errors (segfault, abort, un-handled exception...), simply add a copy of `backward.cpp` to your project, and don't forget to tell your build system. The code in `backward.cpp` is trivial anyway, you can simply copy what it's doing at your convenience. ## Configuration & Dependencies ### Integration with CMake If you are using CMake and want to use its configuration abilities to save you the trouble, you can easily integrate Backward, depending on how you obtained the library. #### As a subdirectory: In this case you have a subdirectory containing the whole repository of Backward (eg.: using git-submodules), in this case you can do: ``` add_subdirectory(/path/to/backward-cpp) # This will add backward.cpp to your target add_executable(mytarget mysource.cpp ${BACKWARD_ENABLE}) # This will add libraries, definitions and include directories needed by backward # by setting each property on the target. add_backward(mytarget) ``` #### Modifying CMAKE_MODULE_PATH In this case you can have Backward installed as a subdirectory: ``` list(APPEND CMAKE_MODULE_PATH /path/to/backward-cpp) find_package(Backward) # This will add libraries, definitions and include directories needed by backward # through an IMPORTED target. target_link_libraries(mytarget PUBLIC Backward::Backward) ``` Notice that this is equivalent to using the the approach that uses `add_subdirectory()`, however it uses cmake's [imported target](https://cmake.org/Wiki/CMake/Tutorials/Exporting_and_Importing_Targets) mechanism. #### Installation through a regular package manager In this case you have obtained Backward through a package manager. Packages currently available: - [conda-forge](https://anaconda.org/conda-forge/backward-cpp) ``` find_package(Backward) # This will add libraries, definitions and include directories needed by backward # through an IMPORTED target. target_link_libraries(mytarget PUBLIC Backward::Backward) ``` ### Compile with debug info You need to compile your project with generation of debug symbols enabled, usually `-g` with clang++ and g++. Note that you can use `-g` with any level of optimization, with modern debug information encoding like DWARF, it only takes space in the binary (it's not loaded in memory until your debugger or Backward makes use of it, don't worry), and it doesn't impact the code generation (at least on GNU/Linux x86\_64 for what I know). If you are missing debug information, the stack trace will lack details about your sources. ### Libraries to read the debug info Backward support pretty printed stack traces on GNU/Linux only, it will compile fine under other platforms but will not do anything. **Pull requests are welcome :)** Also, by default you will get a really basic stack trace, based on the `backtrace_symbols` API: ![default trace](doc/nice.png) You will need to install some dependencies to get the ultimate stack trace. Two libraries are currently supported, the only difference is which one is the easiest for you to install, so pick your poison: #### libbfd from the [GNU/binutils](http://www.gnu.org/software/binutils/) apt-get install binutils-dev (or equivalent) And do not forget to link with the lib: `g++/clang++ -lbfd -ldl ...` This library requires dynamic loading. Which is provided by the library `dl`. Hence why we also link with `-ldl`. Then define the following before every inclusion of `backward.hpp` (don't forget to update `backward.cpp` as well): #define BACKWARD_HAS_BFD 1 #### libdw from the [elfutils](https://fedorahosted.org/elfutils/) apt-get install libdw-dev (or equivalent) And do not forget to link with the lib and inform Backward to use it: #define BACKWARD_HAS_DW 1 Of course you can simply add the define (`-DBACKWARD_HAS_...=1`) and the linkage details in your build system and even auto-detect which library is installed, it's up to you. #### [libdwarf](https://sourceforge.net/projects/libdwarf/) and [libelf](http://www.mr511.de/software/english.html) apt-get install libdwarf-dev (or equivalent) And do not forget to link with the lib and inform Backward to use it: #define BACKWARD_HAS_DWARF 1 There are several alternative implementations of libdwarf and libelf that are API compatible so it's possible, although it hasn't been tested, to replace the ones used when developing backward (in bold, below): * **_libelf_** by [Michael "Tired" Riepe](http://www.mr511.de/software/english.html) * **_libdwarf_** by [David Anderson](https://www.prevanders.net/dwarf.html) * libelf from [elfutils](https://fedorahosted.org/elfutils/) * libelf and libdwarf from FreeBSD's [ELF Tool Chain](https://sourceforge.net/p/elftoolchain/wiki/Home/) project Of course you can simply add the define (`-DBACKWARD_HAS_...=1`) and the linkage details in your build system and even auto-detect which library is installed, it's up to you. That's it, you are all set, you should be getting nice stack traces like the one at the beginning of this document. ## API If you don't want to limit yourself to the defaults offered by `backward.cpp`, and you want to take some random stack traces for whatever reason and pretty print them the way you love or you decide to send them all to your buddies over the Internet, you will appreciate the simplicity of Backward's API. ### Stacktrace The StackTrace class lets you take a "snapshot" of the current stack. You can use it like this: ```c++ using namespace backward; StackTrace st; st.load_here(32); Printer p; p.print(st); ``` The public methods are: ```c++ class StackTrace { public: // Take a snapshot of the current stack, with at most "trace_cnt_max" // traces in it. The first trace is the most recent (ie the current // frame). You can also provide a trace address to load_from() assuming // the address is a valid stack frame (useful for signal handling traces). // Both function return size(). size_t load_here(size_t trace_cnt_max) size_t load_from(void* address, size_t trace_cnt_max) // The number of traces loaded. This can be less than "trace_cnt_max". size_t size() const // A unique id for the thread in which the trace was taken. The value // 0 means the stack trace comes from the main thread. size_t thread_id() const // Retrieve a trace by index. 0 is the most recent trace, size()-1 is // the oldest one. Trace operator[](size_t trace_idx) }; ``` ### TraceResolver The `TraceResolver` does the heavy lifting, and intends to transform a simple `Trace` from its address into a fully detailed `ResolvedTrace` with the filename of the source, line numbers, inlined functions and so on. You can use it like this: ```c++ using namespace backward; StackTrace st; st.load_here(32); TraceResolver tr; tr.load_stacktrace(st); for (size_t i = 0; i < st.size(); ++i) { ResolvedTrace trace = tr.resolve(st[i]); std::cout << "#" << i << " " << trace.object_filename << " " << trace.object_function << " [" << trace.addr << "]" << std::endl; } ``` The public methods are: ```c++ class TraceResolver { public: // Pre-load whatever is necessary from the stack trace. template void load_stacktrace(ST&) // Resolve a trace. It takes a ResolvedTrace, because a `Trace` is // implicitly convertible to it. ResolvedTrace resolve(ResolvedTrace t) }; ``` ### SnippetFactory The SnippetFactory is a simple helper class to automatically load and cache source files in order to extract code snippets. ```c++ class SnippetFactory { public: // A snippet is a list of line numbers and line contents. typedef std::vector > lines_t; // Return a snippet starting at line_start with up to context_size lines. lines_t get_snippet(const std::string& filename, size_t line_start, size_t context_size) // Return a combined snippet from two different locations and combine them. // context_size / 2 lines will be extracted from each location. lines_t get_combined_snippet( const std::string& filename_a, size_t line_a, const std::string& filename_b, size_t line_b, size_t context_size) // Tries to return a unified snippet if the two locations from the same // file are close enough to fit inside one context_size, else returns // the equivalent of get_combined_snippet(). lines_t get_coalesced_snippet(const std::string& filename, size_t line_a, size_t line_b, size_t context_size) ``` ### Printer A simpler way to pretty print a stack trace to the terminal. It will automatically resolve the traces for you: ```c++ using namespace backward; StackTrace st; st.load_here(32); Printer p; p.object = true; p.color_mode = ColorMode::always; p.address = true; p.print(st, stderr); ``` You can set a few options: ```c++ class Printer { public: // Print a little snippet of code if possible. bool snippet = true; // Colorize the trace // - ColorMode::automatic: Activate colors if possible. For example, when using a TTY on linux. // - ColorMode::always: Always use colors. // - ColorMode::never: Never use colors. bool color_mode = ColorMode::automatic; // Add the addresses of every source location to the trace. bool address = false; // Even if there is a source location, also prints the object // from where the trace came from. bool object = false; // Resolve and print a stack trace to the given C FILE* object. // On linux, if the FILE* object is attached to a TTY, // color will be used if color_mode is set to automatic. template FILE* print(StackTrace& st, FILE* fp = stderr); // Resolve and print a stack trace to the given std::ostream object. // Color will only be used if color_mode is set to always. template std::ostream& print(ST& st, std::ostream& os); ``` ### SignalHandling A simple helper class that registers for you the most common signals and other callbacks to segfault, hardware exception, un-handled exception etc. `backward.cpp` simply uses it like that: ```c++ backward::SignalHandling sh; ``` Creating the object registers all the different signals and hooks. Destroying this object doesn't do anything. It exposes only one method: ```c++ bool loaded() const // true if loaded with success ``` ### Trace object To keep the memory footprint of a loaded `StackTrace` on the low-side, there a hierarchy of trace object, from a minimal `Trace `to a `ResolvedTrace`. #### Simple trace ```c++ struct Trace { void* addr; // address of the trace size_t idx; // its index (0 == most recent) }; ``` #### Resolved trace A `ResolvedTrace` should contains a maximum of details about the location of the trace in the source code. Note that not all fields might be set. ```c++ struct ResolvedTrace: public Trace { struct SourceLoc { std::string function; std::string filename; size_t line; size_t col; }; // In which binary object this trace is located. std::string object_filename; // The function in the object that contains the trace. This is not the same // as source.function which can be an function inlined in object_function. std::string object_function; // The source location of this trace. It is possible for filename to be // empty and for line/col to be invalid (value 0) if this information // couldn't be deduced, for example if there is no debug information in the // binary object. SourceLoc source; // An optional list of "inliners". All of these sources locations where // inlined in the source location of the trace (the attribute right above). // This is especially useful when you compile with optimizations turned on. typedef std::vector source_locs_t; source_locs_t inliners; }; ``` ## Contact and copyright François-Xavier Bourlet Copyright 2013-2017 Google Inc. All Rights Reserved. MIT License. ### Disclaimer Although this project is owned by Google Inc. this is not a Google supported or affiliated project. anbox-0.0~git20191115/external/backward-cpp/backward.cpp000066400000000000000000000013651356361734700226740ustar00rootroot00000000000000// Pick your poison. // // On GNU/Linux, you have few choices to get the most out of your stack trace. // // By default you get: // - object filename // - function name // // In order to add: // - source filename // - line and column numbers // - source code snippet (assuming the file is accessible) // Install one of the following library then uncomment one of the macro (or // better, add the detection of the lib and the macro definition in your build // system) // - apt-get install libdw-dev ... // - g++/clang++ -ldw ... // #define BACKWARD_HAS_DW 1 // - apt-get install binutils-dev ... // - g++/clang++ -lbfd ... // #define BACKWARD_HAS_BFD 1 #include "backward.hpp" namespace backward { backward::SignalHandling sh; } // namespace backward anbox-0.0~git20191115/external/backward-cpp/backward.hpp000066400000000000000000003206031356361734700227000ustar00rootroot00000000000000/* * backward.hpp * Copyright 2013 Google Inc. All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #ifndef H_6B9572DA_A64B_49E6_B234_051480991C89 #define H_6B9572DA_A64B_49E6_B234_051480991C89 #ifndef __cplusplus # error "It's not going to compile without a C++ compiler..." #endif #if defined(BACKWARD_CXX11) #elif defined(BACKWARD_CXX98) #else # if __cplusplus >= 201103L # define BACKWARD_CXX11 # define BACKWARD_ATLEAST_CXX11 # define BACKWARD_ATLEAST_CXX98 # else # define BACKWARD_CXX98 # define BACKWARD_ATLEAST_CXX98 # endif #endif // You can define one of the following (or leave it to the auto-detection): // // #define BACKWARD_SYSTEM_LINUX // - specialization for linux // // #define BACKWARD_SYSTEM_DARWIN // - specialization for Mac OS X 10.5 and later. // // #define BACKWARD_SYSTEM_UNKNOWN // - placebo implementation, does nothing. // #if defined(BACKWARD_SYSTEM_LINUX) #elif defined(BACKWARD_SYSTEM_DARWIN) #elif defined(BACKWARD_SYSTEM_UNKNOWN) #else # if defined(__linux) || defined(__linux__) # define BACKWARD_SYSTEM_LINUX # elif defined(__APPLE__) # define BACKWARD_SYSTEM_DARWIN # else # define BACKWARD_SYSTEM_UNKNOWN # endif #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if defined(BACKWARD_SYSTEM_LINUX) // On linux, backtrace can back-trace or "walk" the stack using the following // libraries: // // #define BACKWARD_HAS_UNWIND 1 // - unwind comes from libgcc, but I saw an equivalent inside clang itself. // - with unwind, the stacktrace is as accurate as it can possibly be, since // this is used by the C++ runtine in gcc/clang for stack unwinding on // exception. // - normally libgcc is already linked to your program by default. // // #define BACKWARD_HAS_BACKTRACE == 1 // - backtrace seems to be a little bit more portable than libunwind, but on // linux, it uses unwind anyway, but abstract away a tiny information that is // sadly really important in order to get perfectly accurate stack traces. // - backtrace is part of the (e)glib library. // // The default is: // #define BACKWARD_HAS_UNWIND == 1 // // Note that only one of the define should be set to 1 at a time. // # if BACKWARD_HAS_UNWIND == 1 # elif BACKWARD_HAS_BACKTRACE == 1 # else # undef BACKWARD_HAS_UNWIND # define BACKWARD_HAS_UNWIND 1 # undef BACKWARD_HAS_BACKTRACE # define BACKWARD_HAS_BACKTRACE 0 # endif // On linux, backward can extract detailed information about a stack trace // using one of the following libraries: // // #define BACKWARD_HAS_DW 1 // - libdw gives you the most juicy details out of your stack traces: // - object filename // - function name // - source filename // - line and column numbers // - source code snippet (assuming the file is accessible) // - variables name and values (if not optimized out) // - You need to link with the lib "dw": // - apt-get install libdw-dev // - g++/clang++ -ldw ... // // #define BACKWARD_HAS_BFD 1 // - With libbfd, you get a fair amount of details: // - object filename // - function name // - source filename // - line numbers // - source code snippet (assuming the file is accessible) // - You need to link with the lib "bfd": // - apt-get install binutils-dev // - g++/clang++ -lbfd ... // // #define BACKWARD_HAS_DWARF 1 // - libdwarf gives you the most juicy details out of your stack traces: // - object filename // - function name // - source filename // - line and column numbers // - source code snippet (assuming the file is accessible) // - variables name and values (if not optimized out) // - You need to link with the lib "dwarf": // - apt-get install libdwarf-dev // - g++/clang++ -ldwarf ... // // #define BACKWARD_HAS_BACKTRACE_SYMBOL 1 // - backtrace provides minimal details for a stack trace: // - object filename // - function name // - backtrace is part of the (e)glib library. // // The default is: // #define BACKWARD_HAS_BACKTRACE_SYMBOL == 1 // // Note that only one of the define should be set to 1 at a time. // # if BACKWARD_HAS_DW == 1 # elif BACKWARD_HAS_BFD == 1 # elif BACKWARD_HAS_DWARF == 1 # elif BACKWARD_HAS_BACKTRACE_SYMBOL == 1 # else # undef BACKWARD_HAS_DW # define BACKWARD_HAS_DW 0 # undef BACKWARD_HAS_BFD # define BACKWARD_HAS_BFD 0 # undef BACKWARD_HAS_DWARF # define BACKWARD_HAS_DWARF 0 # undef BACKWARD_HAS_BACKTRACE_SYMBOL # define BACKWARD_HAS_BACKTRACE_SYMBOL 1 # endif # include # include # ifdef __ANDROID__ // Old Android API levels define _Unwind_Ptr in both link.h and unwind.h // Rename the one in link.h as we are not going to be using it # define _Unwind_Ptr _Unwind_Ptr_Custom # include # undef _Unwind_Ptr # else # include # endif # include # include # include # include # if BACKWARD_HAS_BFD == 1 // NOTE: defining PACKAGE{,_VERSION} is required before including // bfd.h on some platforms, see also: // https://sourceware.org/bugzilla/show_bug.cgi?id=14243 # ifndef PACKAGE # define PACKAGE # endif # ifndef PACKAGE_VERSION # define PACKAGE_VERSION # endif # include # ifndef _GNU_SOURCE # define _GNU_SOURCE # include # undef _GNU_SOURCE # else # include # endif # endif # if BACKWARD_HAS_DW == 1 # include # include # include # endif # if BACKWARD_HAS_DWARF == 1 # include # include # include # include # include # ifndef _GNU_SOURCE # define _GNU_SOURCE # include # undef _GNU_SOURCE # else # include # endif # endif # if (BACKWARD_HAS_BACKTRACE == 1) || (BACKWARD_HAS_BACKTRACE_SYMBOL == 1) // then we shall rely on backtrace # include # endif #endif // defined(BACKWARD_SYSTEM_LINUX) #if defined(BACKWARD_SYSTEM_DARWIN) // On Darwin, backtrace can back-trace or "walk" the stack using the following // libraries: // // #define BACKWARD_HAS_UNWIND 1 // - unwind comes from libgcc, but I saw an equivalent inside clang itself. // - with unwind, the stacktrace is as accurate as it can possibly be, since // this is used by the C++ runtine in gcc/clang for stack unwinding on // exception. // - normally libgcc is already linked to your program by default. // // #define BACKWARD_HAS_BACKTRACE == 1 // - backtrace is available by default, though it does not produce as much information // as another library might. // // The default is: // #define BACKWARD_HAS_UNWIND == 1 // // Note that only one of the define should be set to 1 at a time. // # if BACKWARD_HAS_UNWIND == 1 # elif BACKWARD_HAS_BACKTRACE == 1 # else # undef BACKWARD_HAS_UNWIND # define BACKWARD_HAS_UNWIND 1 # undef BACKWARD_HAS_BACKTRACE # define BACKWARD_HAS_BACKTRACE 0 # endif // On Darwin, backward can extract detailed information about a stack trace // using one of the following libraries: // // #define BACKWARD_HAS_BACKTRACE_SYMBOL 1 // - backtrace provides minimal details for a stack trace: // - object filename // - function name // // The default is: // #define BACKWARD_HAS_BACKTRACE_SYMBOL == 1 // # if BACKWARD_HAS_BACKTRACE_SYMBOL == 1 # else # undef BACKWARD_HAS_BACKTRACE_SYMBOL # define BACKWARD_HAS_BACKTRACE_SYMBOL 1 # endif # include # include # include # include # include # include # if (BACKWARD_HAS_BACKTRACE == 1) || (BACKWARD_HAS_BACKTRACE_SYMBOL == 1) # include # endif #endif // defined(BACKWARD_SYSTEM_DARWIN) #if BACKWARD_HAS_UNWIND == 1 # include // while gcc's unwind.h defines something like that: // extern _Unwind_Ptr _Unwind_GetIP (struct _Unwind_Context *); // extern _Unwind_Ptr _Unwind_GetIPInfo (struct _Unwind_Context *, int *); // // clang's unwind.h defines something like this: // uintptr_t _Unwind_GetIP(struct _Unwind_Context* __context); // // Even if the _Unwind_GetIPInfo can be linked to, it is not declared, worse we // cannot just redeclare it because clang's unwind.h doesn't define _Unwind_Ptr // anyway. // // Luckily we can play on the fact that the guard macros have a different name: #ifdef __CLANG_UNWIND_H // In fact, this function still comes from libgcc (on my different linux boxes, // clang links against libgcc). # include extern "C" uintptr_t _Unwind_GetIPInfo(_Unwind_Context*, int*); #endif #endif // BACKWARD_HAS_UNWIND == 1 #ifdef BACKWARD_ATLEAST_CXX11 # include # include // for std::swap namespace backward { namespace details { template struct hashtable { typedef std::unordered_map type; }; using std::move; } // namespace details } // namespace backward #else // NOT BACKWARD_ATLEAST_CXX11 # define nullptr NULL # define override # include namespace backward { namespace details { template struct hashtable { typedef std::map type; }; template const T& move(const T& v) { return v; } template T& move(T& v) { return v; } } // namespace details } // namespace backward #endif // BACKWARD_ATLEAST_CXX11 namespace backward { namespace system_tag { struct linux_tag; // seems that I cannot call that "linux" because the name // is already defined... so I am adding _tag everywhere. struct darwin_tag; struct unknown_tag; #if defined(BACKWARD_SYSTEM_LINUX) typedef linux_tag current_tag; #elif defined(BACKWARD_SYSTEM_DARWIN) typedef darwin_tag current_tag; #elif defined(BACKWARD_SYSTEM_UNKNOWN) typedef unknown_tag current_tag; #else # error "May I please get my system defines?" #endif } // namespace system_tag namespace trace_resolver_tag { #if defined(BACKWARD_SYSTEM_LINUX) struct libdw; struct libbfd; struct libdwarf; struct backtrace_symbol; # if BACKWARD_HAS_DW == 1 typedef libdw current; # elif BACKWARD_HAS_BFD == 1 typedef libbfd current; # elif BACKWARD_HAS_DWARF == 1 typedef libdwarf current; # elif BACKWARD_HAS_BACKTRACE_SYMBOL == 1 typedef backtrace_symbol current; # else # error "You shall not pass, until you know what you want." # endif #elif defined(BACKWARD_SYSTEM_DARWIN) struct backtrace_symbol; # if BACKWARD_HAS_BACKTRACE_SYMBOL == 1 typedef backtrace_symbol current; # else # error "You shall not pass, until you know what you want." # endif #endif } // namespace trace_resolver_tag namespace details { template struct rm_ptr { typedef T type; }; template struct rm_ptr { typedef T type; }; template struct rm_ptr { typedef const T type; }; template struct deleter { template void operator()(U& ptr) const { (*F)(ptr); } }; template struct default_delete { void operator()(T& ptr) const { delete ptr; } }; template > class handle { struct dummy; T _val; bool _empty; #ifdef BACKWARD_ATLEAST_CXX11 handle(const handle&) = delete; handle& operator=(const handle&) = delete; #endif public: ~handle() { if (!_empty) { Deleter()(_val); } } explicit handle(): _val(), _empty(true) {} explicit handle(T val): _val(val), _empty(false) { if(!_val) _empty = true; } #ifdef BACKWARD_ATLEAST_CXX11 handle(handle&& from): _empty(true) { swap(from); } handle& operator=(handle&& from) { swap(from); return *this; } #else explicit handle(const handle& from): _empty(true) { // some sort of poor man's move semantic. swap(const_cast(from)); } handle& operator=(const handle& from) { // some sort of poor man's move semantic. swap(const_cast(from)); return *this; } #endif void reset(T new_val) { handle tmp(new_val); swap(tmp); } operator const dummy*() const { if (_empty) { return nullptr; } return reinterpret_cast(_val); } T get() { return _val; } T release() { _empty = true; return _val; } void swap(handle& b) { using std::swap; swap(b._val, _val); // can throw, we are safe here. swap(b._empty, _empty); // should not throw: if you cannot swap two // bools without throwing... It's a lost cause anyway! } T operator->() { return _val; } const T operator->() const { return _val; } typedef typename rm_ptr::type& ref_t; typedef const typename rm_ptr::type& const_ref_t; ref_t operator*() { return *_val; } const_ref_t operator*() const { return *_val; } ref_t operator[](size_t idx) { return _val[idx]; } // Watch out, we've got a badass over here T* operator&() { _empty = false; return &_val; } }; // Default demangler implementation (do nothing). template struct demangler_impl { static std::string demangle(const char* funcname) { return funcname; } }; #if defined(BACKWARD_SYSTEM_LINUX) || defined(BACKWARD_SYSTEM_DARWIN) template <> struct demangler_impl { demangler_impl(): _demangle_buffer_length(0) {} std::string demangle(const char* funcname) { using namespace details; char* result = abi::__cxa_demangle(funcname, _demangle_buffer.release(), &_demangle_buffer_length, nullptr); if(result) { _demangle_buffer.reset(result); return result; } return funcname; } private: details::handle _demangle_buffer; size_t _demangle_buffer_length; }; #endif // BACKWARD_SYSTEM_LINUX || BACKWARD_SYSTEM_DARWIN struct demangler: public demangler_impl {}; } // namespace details /*************** A TRACE ***************/ struct Trace { void* addr; size_t idx; Trace(): addr(nullptr), idx(0) {} explicit Trace(void* _addr, size_t _idx): addr(_addr), idx(_idx) {} }; struct ResolvedTrace: public Trace { struct SourceLoc { std::string function; std::string filename; unsigned line; unsigned col; SourceLoc(): line(0), col(0) {} bool operator==(const SourceLoc& b) const { return function == b.function && filename == b.filename && line == b.line && col == b.col; } bool operator!=(const SourceLoc& b) const { return !(*this == b); } }; // In which binary object this trace is located. std::string object_filename; // The function in the object that contain the trace. This is not the same // as source.function which can be an function inlined in object_function. std::string object_function; // The source location of this trace. It is possible for filename to be // empty and for line/col to be invalid (value 0) if this information // couldn't be deduced, for example if there is no debug information in the // binary object. SourceLoc source; // An optionals list of "inliners". All the successive sources location // from where the source location of the trace (the attribute right above) // is inlined. It is especially useful when you compiled with optimization. typedef std::vector source_locs_t; source_locs_t inliners; ResolvedTrace(): Trace() {} ResolvedTrace(const Trace& mini_trace): Trace(mini_trace) {} }; /*************** STACK TRACE ***************/ // default implemention. template class StackTraceImpl { public: size_t size() const { return 0; } Trace operator[](size_t) { return Trace(); } size_t load_here(size_t=0) { return 0; } size_t load_from(void*, size_t=0) { return 0; } size_t thread_id() const { return 0; } void skip_n_firsts(size_t) { } }; class StackTraceImplBase { public: StackTraceImplBase(): _thread_id(0), _skip(0) {} size_t thread_id() const { return _thread_id; } void skip_n_firsts(size_t n) { _skip = n; } protected: void load_thread_info() { #ifdef BACKWARD_SYSTEM_LINUX #ifndef __ANDROID__ _thread_id = static_cast(syscall(SYS_gettid)); #else _thread_id = static_cast(gettid()); #endif if (_thread_id == static_cast(getpid())) { // If the thread is the main one, let's hide that. // I like to keep little secret sometimes. _thread_id = 0; } #elif defined(BACKWARD_SYSTEM_DARWIN) _thread_id = reinterpret_cast(pthread_self()); if (pthread_main_np() == 1) { // If the thread is the main one, let's hide that. _thread_id = 0; } #endif } size_t skip_n_firsts() const { return _skip; } private: size_t _thread_id; size_t _skip; }; class StackTraceImplHolder: public StackTraceImplBase { public: size_t size() const { return _stacktrace.size() ? _stacktrace.size() - skip_n_firsts() : 0; } Trace operator[](size_t idx) const { if (idx >= size()) { return Trace(); } return Trace(_stacktrace[idx + skip_n_firsts()], idx); } void* const* begin() const { if (size()) { return &_stacktrace[skip_n_firsts()]; } return nullptr; } protected: std::vector _stacktrace; }; #if BACKWARD_HAS_UNWIND == 1 namespace details { template class Unwinder { public: size_t operator()(F& f, size_t depth) { _f = &f; _index = -1; _depth = depth; _Unwind_Backtrace(&this->backtrace_trampoline, this); return static_cast(_index); } private: F* _f; ssize_t _index; size_t _depth; static _Unwind_Reason_Code backtrace_trampoline( _Unwind_Context* ctx, void *self) { return (static_cast(self))->backtrace(ctx); } _Unwind_Reason_Code backtrace(_Unwind_Context* ctx) { if (_index >= 0 && static_cast(_index) >= _depth) return _URC_END_OF_STACK; int ip_before_instruction = 0; uintptr_t ip = _Unwind_GetIPInfo(ctx, &ip_before_instruction); if (!ip_before_instruction) { // calculating 0-1 for unsigned, looks like a possible bug to sanitiziers, so let's do it explicitly: if (ip==0) { ip = std::numeric_limits::max(); // set it to 0xffff... (as from casting 0-1) } else { ip -= 1; // else just normally decrement it (no overflow/underflow will happen) } } if (_index >= 0) { // ignore first frame. (*_f)(static_cast(_index), reinterpret_cast(ip)); } _index += 1; return _URC_NO_REASON; } }; template size_t unwind(F f, size_t depth) { Unwinder unwinder; return unwinder(f, depth); } } // namespace details template <> class StackTraceImpl: public StackTraceImplHolder { public: __attribute__ ((noinline)) // TODO use some macro size_t load_here(size_t depth=32) { load_thread_info(); if (depth == 0) { return 0; } _stacktrace.resize(depth); size_t trace_cnt = details::unwind(callback(*this), depth); _stacktrace.resize(trace_cnt); skip_n_firsts(0); return size(); } size_t load_from(void* addr, size_t depth=32) { load_here(depth + 8); for (size_t i = 0; i < _stacktrace.size(); ++i) { if (_stacktrace[i] == addr) { skip_n_firsts(i); break; } } _stacktrace.resize(std::min(_stacktrace.size(), skip_n_firsts() + depth)); return size(); } private: struct callback { StackTraceImpl& self; callback(StackTraceImpl& _self): self(_self) {} void operator()(size_t idx, void* addr) { self._stacktrace[idx] = addr; } }; }; #else // BACKWARD_HAS_UNWIND == 0 template <> class StackTraceImpl: public StackTraceImplHolder { public: __attribute__ ((noinline)) // TODO use some macro size_t load_here(size_t depth=32) { load_thread_info(); if (depth == 0) { return 0; } _stacktrace.resize(depth + 1); size_t trace_cnt = backtrace(&_stacktrace[0], _stacktrace.size()); _stacktrace.resize(trace_cnt); skip_n_firsts(1); return size(); } size_t load_from(void* addr, size_t depth=32) { load_here(depth + 8); for (size_t i = 0; i < _stacktrace.size(); ++i) { if (_stacktrace[i] == addr) { skip_n_firsts(i); _stacktrace[i] = (void*)( (uintptr_t)_stacktrace[i] + 1); break; } } _stacktrace.resize(std::min(_stacktrace.size(), skip_n_firsts() + depth)); return size(); } }; #endif // BACKWARD_HAS_UNWIND class StackTrace: public StackTraceImpl {}; /*************** TRACE RESOLVER ***************/ template class TraceResolverImpl; #ifdef BACKWARD_SYSTEM_UNKNOWN template <> class TraceResolverImpl { public: template void load_stacktrace(ST&) {} ResolvedTrace resolve(ResolvedTrace t) { return t; } }; #endif class TraceResolverImplBase { protected: std::string demangle(const char* funcname) { return _demangler.demangle(funcname); } private: details::demangler _demangler; }; #ifdef BACKWARD_SYSTEM_LINUX template class TraceResolverLinuxImpl; #if BACKWARD_HAS_BACKTRACE_SYMBOL == 1 template <> class TraceResolverLinuxImpl: public TraceResolverImplBase { public: template void load_stacktrace(ST& st) { using namespace details; if (st.size() == 0) { return; } _symbols.reset( backtrace_symbols(st.begin(), (int)st.size()) ); } ResolvedTrace resolve(ResolvedTrace trace) { char* filename = _symbols[trace.idx]; char* funcname = filename; while (*funcname && *funcname != '(') { funcname += 1; } trace.object_filename.assign(filename, funcname); // ok even if funcname is the ending \0 (then we assign entire string) if (*funcname) { // if it's not end of string (e.g. from last frame ip==0) funcname += 1; char* funcname_end = funcname; while (*funcname_end && *funcname_end != ')' && *funcname_end != '+') { funcname_end += 1; } *funcname_end = '\0'; trace.object_function = this->demangle(funcname); trace.source.function = trace.object_function; // we cannot do better. } return trace; } private: details::handle _symbols; }; #endif // BACKWARD_HAS_BACKTRACE_SYMBOL == 1 #if BACKWARD_HAS_BFD == 1 template <> class TraceResolverLinuxImpl: public TraceResolverImplBase { static std::string read_symlink(std::string const & symlink_path) { std::string path; path.resize(100); while(true) { ssize_t len = ::readlink(symlink_path.c_str(), &*path.begin(), path.size()); if(len < 0) { return ""; } if (static_cast(len) == path.size()) { path.resize(path.size() * 2); } else { path.resize(static_cast(len)); break; } } return path; } public: TraceResolverLinuxImpl(): _bfd_loaded(false) {} template void load_stacktrace(ST&) {} ResolvedTrace resolve(ResolvedTrace trace) { Dl_info symbol_info; // trace.addr is a virtual address in memory pointing to some code. // Let's try to find from which loaded object it comes from. // The loaded object can be yourself btw. if (!dladdr(trace.addr, &symbol_info)) { return trace; // dat broken trace... } std::string argv0; { std::ifstream ifs("/proc/self/cmdline"); std::getline(ifs, argv0, '\0'); } std::string tmp; if(symbol_info.dli_fname == argv0) { tmp = read_symlink("/proc/self/exe"); symbol_info.dli_fname = tmp.c_str(); } // Now we get in symbol_info: // .dli_fname: // pathname of the shared object that contains the address. // .dli_fbase: // where the object is loaded in memory. // .dli_sname: // the name of the nearest symbol to trace.addr, we expect a // function name. // .dli_saddr: // the exact address corresponding to .dli_sname. if (symbol_info.dli_sname) { trace.object_function = demangle(symbol_info.dli_sname); } if (!symbol_info.dli_fname) { return trace; } trace.object_filename = symbol_info.dli_fname; bfd_fileobject& fobj = load_object_with_bfd(symbol_info.dli_fname); if (!fobj.handle) { return trace; // sad, we couldn't load the object :( } find_sym_result* details_selected; // to be filled. // trace.addr is the next instruction to be executed after returning // from the nested stack frame. In C++ this usually relate to the next // statement right after the function call that leaded to a new stack // frame. This is not usually what you want to see when printing out a // stacktrace... find_sym_result details_call_site = find_symbol_details(fobj, trace.addr, symbol_info.dli_fbase); details_selected = &details_call_site; #if BACKWARD_HAS_UNWIND == 0 // ...this is why we also try to resolve the symbol that is right // before the return address. If we are lucky enough, we will get the // line of the function that was called. But if the code is optimized, // we might get something absolutely not related since the compiler // can reschedule the return address with inline functions and // tail-call optimisation (among other things that I don't even know // or cannot even dream about with my tiny limited brain). find_sym_result details_adjusted_call_site = find_symbol_details(fobj, (void*) (uintptr_t(trace.addr) - 1), symbol_info.dli_fbase); // In debug mode, we should always get the right thing(TM). if (details_call_site.found && details_adjusted_call_site.found) { // Ok, we assume that details_adjusted_call_site is a better estimation. details_selected = &details_adjusted_call_site; trace.addr = (void*) (uintptr_t(trace.addr) - 1); } if (details_selected == &details_call_site && details_call_site.found) { // we have to re-resolve the symbol in order to reset some // internal state in BFD... so we can call backtrace_inliners // thereafter... details_call_site = find_symbol_details(fobj, trace.addr, symbol_info.dli_fbase); } #endif // BACKWARD_HAS_UNWIND if (details_selected->found) { if (details_selected->filename) { trace.source.filename = details_selected->filename; } trace.source.line = details_selected->line; if (details_selected->funcname) { // this time we get the name of the function where the code is // located, instead of the function were the address is // located. In short, if the code was inlined, we get the // function correspoding to the code. Else we already got in // trace.function. trace.source.function = demangle(details_selected->funcname); if (!symbol_info.dli_sname) { // for the case dladdr failed to find the symbol name of // the function, we might as well try to put something // here. trace.object_function = trace.source.function; } } // Maybe the source of the trace got inlined inside the function // (trace.source.function). Let's see if we can get all the inlined // calls along the way up to the initial call site. trace.inliners = backtrace_inliners(fobj, *details_selected); #if 0 if (trace.inliners.size() == 0) { // Maybe the trace was not inlined... or maybe it was and we // are lacking the debug information. Let's try to make the // world better and see if we can get the line number of the // function (trace.source.function) now. // // We will get the location of where the function start (to be // exact: the first instruction that really start the // function), not where the name of the function is defined. // This can be quite far away from the name of the function // btw. // // If the source of the function is the same as the source of // the trace, we cannot say if the trace was really inlined or // not. However, if the filename of the source is different // between the function and the trace... we can declare it as // an inliner. This is not 100% accurate, but better than // nothing. if (symbol_info.dli_saddr) { find_sym_result details = find_symbol_details(fobj, symbol_info.dli_saddr, symbol_info.dli_fbase); if (details.found) { ResolvedTrace::SourceLoc diy_inliner; diy_inliner.line = details.line; if (details.filename) { diy_inliner.filename = details.filename; } if (details.funcname) { diy_inliner.function = demangle(details.funcname); } else { diy_inliner.function = trace.source.function; } if (diy_inliner != trace.source) { trace.inliners.push_back(diy_inliner); } } } } #endif } return trace; } private: bool _bfd_loaded; typedef details::handle > bfd_handle_t; typedef details::handle bfd_symtab_t; struct bfd_fileobject { bfd_handle_t handle; bfd_vma base_addr; bfd_symtab_t symtab; bfd_symtab_t dynamic_symtab; }; typedef details::hashtable::type fobj_bfd_map_t; fobj_bfd_map_t _fobj_bfd_map; bfd_fileobject& load_object_with_bfd(const std::string& filename_object) { using namespace details; if (!_bfd_loaded) { using namespace details; bfd_init(); _bfd_loaded = true; } fobj_bfd_map_t::iterator it = _fobj_bfd_map.find(filename_object); if (it != _fobj_bfd_map.end()) { return it->second; } // this new object is empty for now. bfd_fileobject& r = _fobj_bfd_map[filename_object]; // we do the work temporary in this one; bfd_handle_t bfd_handle; int fd = open(filename_object.c_str(), O_RDONLY); bfd_handle.reset( bfd_fdopenr(filename_object.c_str(), "default", fd) ); if (!bfd_handle) { close(fd); return r; } if (!bfd_check_format(bfd_handle.get(), bfd_object)) { return r; // not an object? You lose. } if ((bfd_get_file_flags(bfd_handle.get()) & HAS_SYMS) == 0) { return r; // that's what happen when you forget to compile in debug. } ssize_t symtab_storage_size = bfd_get_symtab_upper_bound(bfd_handle.get()); ssize_t dyn_symtab_storage_size = bfd_get_dynamic_symtab_upper_bound(bfd_handle.get()); if (symtab_storage_size <= 0 && dyn_symtab_storage_size <= 0) { return r; // weird, is the file is corrupted? } bfd_symtab_t symtab, dynamic_symtab; ssize_t symcount = 0, dyn_symcount = 0; if (symtab_storage_size > 0) { symtab.reset( static_cast(malloc(static_cast(symtab_storage_size))) ); symcount = bfd_canonicalize_symtab( bfd_handle.get(), symtab.get() ); } if (dyn_symtab_storage_size > 0) { dynamic_symtab.reset( static_cast(malloc(static_cast(dyn_symtab_storage_size))) ); dyn_symcount = bfd_canonicalize_dynamic_symtab( bfd_handle.get(), dynamic_symtab.get() ); } if (symcount <= 0 && dyn_symcount <= 0) { return r; // damned, that's a stripped file that you got there! } r.handle = move(bfd_handle); r.symtab = move(symtab); r.dynamic_symtab = move(dynamic_symtab); return r; } struct find_sym_result { bool found; const char* filename; const char* funcname; unsigned int line; }; struct find_sym_context { TraceResolverLinuxImpl* self; bfd_fileobject* fobj; void* addr; void* base_addr; find_sym_result result; }; find_sym_result find_symbol_details(bfd_fileobject& fobj, void* addr, void* base_addr) { find_sym_context context; context.self = this; context.fobj = &fobj; context.addr = addr; context.base_addr = base_addr; context.result.found = false; bfd_map_over_sections(fobj.handle.get(), &find_in_section_trampoline, static_cast(&context)); return context.result; } static void find_in_section_trampoline(bfd*, asection* section, void* data) { find_sym_context* context = static_cast(data); context->self->find_in_section( reinterpret_cast(context->addr), reinterpret_cast(context->base_addr), *context->fobj, section, context->result ); } void find_in_section(bfd_vma addr, bfd_vma base_addr, bfd_fileobject& fobj, asection* section, find_sym_result& result) { if (result.found) return; if ((bfd_get_section_flags(fobj.handle.get(), section) & SEC_ALLOC) == 0) return; // a debug section is never loaded automatically. bfd_vma sec_addr = bfd_get_section_vma(fobj.handle.get(), section); bfd_size_type size = bfd_get_section_size(section); // are we in the boundaries of the section? if (addr < sec_addr || addr >= sec_addr + size) { addr -= base_addr; // oups, a relocated object, lets try again... if (addr < sec_addr || addr >= sec_addr + size) { return; } } #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" if (!result.found && fobj.symtab) { result.found = bfd_find_nearest_line(fobj.handle.get(), section, fobj.symtab.get(), addr - sec_addr, &result.filename, &result.funcname, &result.line); } if (!result.found && fobj.dynamic_symtab) { result.found = bfd_find_nearest_line(fobj.handle.get(), section, fobj.dynamic_symtab.get(), addr - sec_addr, &result.filename, &result.funcname, &result.line); } #pragma clang diagnostic pop } ResolvedTrace::source_locs_t backtrace_inliners(bfd_fileobject& fobj, find_sym_result previous_result) { // This function can be called ONLY after a SUCCESSFUL call to // find_symbol_details. The state is global to the bfd_handle. ResolvedTrace::source_locs_t results; while (previous_result.found) { find_sym_result result; result.found = bfd_find_inliner_info(fobj.handle.get(), &result.filename, &result.funcname, &result.line); if (result.found) /* and not ( cstrings_eq(previous_result.filename, result.filename) and cstrings_eq(previous_result.funcname, result.funcname) and result.line == previous_result.line )) */ { ResolvedTrace::SourceLoc src_loc; src_loc.line = result.line; if (result.filename) { src_loc.filename = result.filename; } if (result.funcname) { src_loc.function = demangle(result.funcname); } results.push_back(src_loc); } previous_result = result; } return results; } bool cstrings_eq(const char* a, const char* b) { if (!a || !b) { return false; } return strcmp(a, b) == 0; } }; #endif // BACKWARD_HAS_BFD == 1 #if BACKWARD_HAS_DW == 1 template <> class TraceResolverLinuxImpl: public TraceResolverImplBase { public: TraceResolverLinuxImpl(): _dwfl_handle_initialized(false) {} template void load_stacktrace(ST&) {} ResolvedTrace resolve(ResolvedTrace trace) { using namespace details; Dwarf_Addr trace_addr = (Dwarf_Addr) trace.addr; if (!_dwfl_handle_initialized) { // initialize dwfl... _dwfl_cb.reset(new Dwfl_Callbacks); _dwfl_cb->find_elf = &dwfl_linux_proc_find_elf; _dwfl_cb->find_debuginfo = &dwfl_standard_find_debuginfo; _dwfl_cb->debuginfo_path = 0; _dwfl_handle.reset(dwfl_begin(_dwfl_cb.get())); _dwfl_handle_initialized = true; if (!_dwfl_handle) { return trace; } // ...from the current process. dwfl_report_begin(_dwfl_handle.get()); int r = dwfl_linux_proc_report (_dwfl_handle.get(), getpid()); dwfl_report_end(_dwfl_handle.get(), NULL, NULL); if (r < 0) { return trace; } } if (!_dwfl_handle) { return trace; } // find the module (binary object) that contains the trace's address. // This is not using any debug information, but the addresses ranges of // all the currently loaded binary object. Dwfl_Module* mod = dwfl_addrmodule(_dwfl_handle.get(), trace_addr); if (mod) { // now that we found it, lets get the name of it, this will be the // full path to the running binary or one of the loaded library. const char* module_name = dwfl_module_info (mod, 0, 0, 0, 0, 0, 0, 0); if (module_name) { trace.object_filename = module_name; } // We also look after the name of the symbol, equal or before this // address. This is found by walking the symtab. We should get the // symbol corresponding to the function (mangled) containing the // address. If the code corresponding to the address was inlined, // this is the name of the out-most inliner function. const char* sym_name = dwfl_module_addrname(mod, trace_addr); if (sym_name) { trace.object_function = demangle(sym_name); } } // now let's get serious, and find out the source location (file and // line number) of the address. // This function will look in .debug_aranges for the address and map it // to the location of the compilation unit DIE in .debug_info and // return it. Dwarf_Addr mod_bias = 0; Dwarf_Die* cudie = dwfl_module_addrdie(mod, trace_addr, &mod_bias); #if 1 if (!cudie) { // Sadly clang does not generate the section .debug_aranges, thus // dwfl_module_addrdie will fail early. Clang doesn't either set // the lowpc/highpc/range info for every compilation unit. // // So in order to save the world: // for every compilation unit, we will iterate over every single // DIEs. Normally functions should have a lowpc/highpc/range, which // we will use to infer the compilation unit. // note that this is probably badly inefficient. while ((cudie = dwfl_module_nextcu(mod, cudie, &mod_bias))) { Dwarf_Die die_mem; Dwarf_Die* fundie = find_fundie_by_pc(cudie, trace_addr - mod_bias, &die_mem); if (fundie) { break; } } } #endif //#define BACKWARD_I_DO_NOT_RECOMMEND_TO_ENABLE_THIS_HORRIBLE_PIECE_OF_CODE #ifdef BACKWARD_I_DO_NOT_RECOMMEND_TO_ENABLE_THIS_HORRIBLE_PIECE_OF_CODE if (!cudie) { // If it's still not enough, lets dive deeper in the shit, and try // to save the world again: for every compilation unit, we will // load the corresponding .debug_line section, and see if we can // find our address in it. Dwarf_Addr cfi_bias; Dwarf_CFI* cfi_cache = dwfl_module_eh_cfi(mod, &cfi_bias); Dwarf_Addr bias; while ((cudie = dwfl_module_nextcu(mod, cudie, &bias))) { if (dwarf_getsrc_die(cudie, trace_addr - bias)) { // ...but if we get a match, it might be a false positive // because our (address - bias) might as well be valid in a // different compilation unit. So we throw our last card on // the table and lookup for the address into the .eh_frame // section. handle frame; dwarf_cfi_addrframe(cfi_cache, trace_addr - cfi_bias, &frame); if (frame) { break; } } } } #endif if (!cudie) { return trace; // this time we lost the game :/ } // Now that we have a compilation unit DIE, this function will be able // to load the corresponding section in .debug_line (if not already // loaded) and hopefully find the source location mapped to our // address. Dwarf_Line* srcloc = dwarf_getsrc_die(cudie, trace_addr - mod_bias); if (srcloc) { const char* srcfile = dwarf_linesrc(srcloc, 0, 0); if (srcfile) { trace.source.filename = srcfile; } int line = 0, col = 0; dwarf_lineno(srcloc, &line); dwarf_linecol(srcloc, &col); trace.source.line = line; trace.source.col = col; } deep_first_search_by_pc(cudie, trace_addr - mod_bias, inliners_search_cb(trace)); if (trace.source.function.size() == 0) { // fallback. trace.source.function = trace.object_function; } return trace; } private: typedef details::handle > dwfl_handle_t; details::handle > _dwfl_cb; dwfl_handle_t _dwfl_handle; bool _dwfl_handle_initialized; // defined here because in C++98, template function cannot take locally // defined types... grrr. struct inliners_search_cb { void operator()(Dwarf_Die* die) { switch (dwarf_tag(die)) { const char* name; case DW_TAG_subprogram: if ((name = dwarf_diename(die))) { trace.source.function = name; } break; case DW_TAG_inlined_subroutine: ResolvedTrace::SourceLoc sloc; Dwarf_Attribute attr_mem; if ((name = dwarf_diename(die))) { sloc.function = name; } if ((name = die_call_file(die))) { sloc.filename = name; } Dwarf_Word line = 0, col = 0; dwarf_formudata(dwarf_attr(die, DW_AT_call_line, &attr_mem), &line); dwarf_formudata(dwarf_attr(die, DW_AT_call_column, &attr_mem), &col); sloc.line = (unsigned)line; sloc.col = (unsigned)col; trace.inliners.push_back(sloc); break; }; } ResolvedTrace& trace; inliners_search_cb(ResolvedTrace& t): trace(t) {} }; static bool die_has_pc(Dwarf_Die* die, Dwarf_Addr pc) { Dwarf_Addr low, high; // continuous range if (dwarf_hasattr(die, DW_AT_low_pc) && dwarf_hasattr(die, DW_AT_high_pc)) { if (dwarf_lowpc(die, &low) != 0) { return false; } if (dwarf_highpc(die, &high) != 0) { Dwarf_Attribute attr_mem; Dwarf_Attribute* attr = dwarf_attr(die, DW_AT_high_pc, &attr_mem); Dwarf_Word value; if (dwarf_formudata(attr, &value) != 0) { return false; } high = low + value; } return pc >= low && pc < high; } // non-continuous range. Dwarf_Addr base; ptrdiff_t offset = 0; while ((offset = dwarf_ranges(die, offset, &base, &low, &high)) > 0) { if (pc >= low && pc < high) { return true; } } return false; } static Dwarf_Die* find_fundie_by_pc(Dwarf_Die* parent_die, Dwarf_Addr pc, Dwarf_Die* result) { if (dwarf_child(parent_die, result) != 0) { return 0; } Dwarf_Die* die = result; do { switch (dwarf_tag(die)) { case DW_TAG_subprogram: case DW_TAG_inlined_subroutine: if (die_has_pc(die, pc)) { return result; } }; bool declaration = false; Dwarf_Attribute attr_mem; dwarf_formflag(dwarf_attr(die, DW_AT_declaration, &attr_mem), &declaration); if (!declaration) { // let's be curious and look deeper in the tree, // function are not necessarily at the first level, but // might be nested inside a namespace, structure etc. Dwarf_Die die_mem; Dwarf_Die* indie = find_fundie_by_pc(die, pc, &die_mem); if (indie) { *result = die_mem; return result; } } } while (dwarf_siblingof(die, result) == 0); return 0; } template static bool deep_first_search_by_pc(Dwarf_Die* parent_die, Dwarf_Addr pc, CB cb) { Dwarf_Die die_mem; if (dwarf_child(parent_die, &die_mem) != 0) { return false; } bool branch_has_pc = false; Dwarf_Die* die = &die_mem; do { bool declaration = false; Dwarf_Attribute attr_mem; dwarf_formflag(dwarf_attr(die, DW_AT_declaration, &attr_mem), &declaration); if (!declaration) { // let's be curious and look deeper in the tree, function are // not necessarily at the first level, but might be nested // inside a namespace, structure, a function, an inlined // function etc. branch_has_pc = deep_first_search_by_pc(die, pc, cb); } if (!branch_has_pc) { branch_has_pc = die_has_pc(die, pc); } if (branch_has_pc) { cb(die); } } while (dwarf_siblingof(die, &die_mem) == 0); return branch_has_pc; } static const char* die_call_file(Dwarf_Die *die) { Dwarf_Attribute attr_mem; Dwarf_Sword file_idx = 0; dwarf_formsdata(dwarf_attr(die, DW_AT_call_file, &attr_mem), &file_idx); if (file_idx == 0) { return 0; } Dwarf_Die die_mem; Dwarf_Die* cudie = dwarf_diecu(die, &die_mem, 0, 0); if (!cudie) { return 0; } Dwarf_Files* files = 0; size_t nfiles; dwarf_getsrcfiles(cudie, &files, &nfiles); if (!files) { return 0; } return dwarf_filesrc(files, file_idx, 0, 0); } }; #endif // BACKWARD_HAS_DW == 1 #if BACKWARD_HAS_DWARF == 1 template <> class TraceResolverLinuxImpl: public TraceResolverImplBase { static std::string read_symlink(std::string const & symlink_path) { std::string path; path.resize(100); while(true) { ssize_t len = ::readlink(symlink_path.c_str(), &*path.begin(), path.size()); if(len < 0) { return ""; } if ((size_t)len == path.size()) { path.resize(path.size() * 2); } else { path.resize(len); break; } } return path; } public: TraceResolverLinuxImpl(): _dwarf_loaded(false) {} template void load_stacktrace(ST&) {} ResolvedTrace resolve(ResolvedTrace trace) { // trace.addr is a virtual address in memory pointing to some code. // Let's try to find from which loaded object it comes from. // The loaded object can be yourself btw. Dl_info symbol_info; int dladdr_result = 0; #ifndef __ANDROID__ link_map *link_map; // We request the link map so we can get information about offsets dladdr_result = dladdr1(trace.addr, &symbol_info, reinterpret_cast(&link_map), RTLD_DL_LINKMAP); #else // Android doesn't have dladdr1. Don't use the linker map. dladdr_result = dladdr(trace.addr, &symbol_info); #endif if (!dladdr_result) { return trace; // dat broken trace... } std::string argv0; { std::ifstream ifs("/proc/self/cmdline"); std::getline(ifs, argv0, '\0'); } std::string tmp; if(symbol_info.dli_fname == argv0) { tmp = read_symlink("/proc/self/exe"); symbol_info.dli_fname = tmp.c_str(); } // Now we get in symbol_info: // .dli_fname: // pathname of the shared object that contains the address. // .dli_fbase: // where the object is loaded in memory. // .dli_sname: // the name of the nearest symbol to trace.addr, we expect a // function name. // .dli_saddr: // the exact address corresponding to .dli_sname. // // And in link_map: // .l_addr: // difference between the address in the ELF file and the address // in memory // l_name: // absolute pathname where the object was found if (symbol_info.dli_sname) { trace.object_function = demangle(symbol_info.dli_sname); } if (!symbol_info.dli_fname) { return trace; } trace.object_filename = symbol_info.dli_fname; dwarf_fileobject& fobj = load_object_with_dwarf(symbol_info.dli_fname); if (!fobj.dwarf_handle) { return trace; // sad, we couldn't load the object :( } #ifndef __ANDROID__ // Convert the address to a module relative one by looking at // the module's loading address in the link map Dwarf_Addr address = reinterpret_cast(trace.addr) - reinterpret_cast(link_map->l_addr); #else Dwarf_Addr address = reinterpret_cast(trace.addr); #endif if (trace.object_function.empty()) { symbol_cache_t::iterator it = fobj.symbol_cache.lower_bound(address); if (it != fobj.symbol_cache.end()) { if (it->first != address) { if (it != fobj.symbol_cache.begin()) { --it; } } trace.object_function = demangle(it->second.c_str()); } } // Get the Compilation Unit DIE for the address Dwarf_Die die = find_die(fobj, address); if (!die) { return trace; // this time we lost the game :/ } // libdwarf doesn't give us direct access to its objects, it always // allocates a copy for the caller. We keep that copy alive in a cache // and we deallocate it later when it's no longer required. die_cache_entry& die_object = get_die_cache(fobj, die); if (die_object.isEmpty()) return trace; // We have no line section for this DIE die_linemap_t::iterator it = die_object.line_section.lower_bound(address); if (it != die_object.line_section.end()) { if (it->first != address) { if (it == die_object.line_section.begin()) { // If we are on the first item of the line section // but the address does not match it means that // the address is below the range of the DIE. Give up. return trace; } else { --it; } } } else { return trace; // We didn't find the address. } // Get the Dwarf_Line that the address points to and call libdwarf // to get source file, line and column info. Dwarf_Line line = die_object.line_buffer[it->second]; Dwarf_Error error = DW_DLE_NE; char* filename; if (dwarf_linesrc(line, &filename, &error) == DW_DLV_OK) { trace.source.filename = std::string(filename); dwarf_dealloc(fobj.dwarf_handle.get(), filename, DW_DLA_STRING); } Dwarf_Unsigned number = 0; if (dwarf_lineno(line, &number, &error) == DW_DLV_OK) { trace.source.line = number; } else { trace.source.line = 0; } if (dwarf_lineoff_b(line, &number, &error) == DW_DLV_OK) { trace.source.col = number; } else { trace.source.col = 0; } std::vector namespace_stack; deep_first_search_by_pc(fobj, die, address, namespace_stack, inliners_search_cb(trace, fobj, die)); dwarf_dealloc(fobj.dwarf_handle.get(), die, DW_DLA_DIE); return trace; } public: static int close_dwarf(Dwarf_Debug dwarf) { return dwarf_finish(dwarf, NULL); } private: bool _dwarf_loaded; typedef details::handle > dwarf_file_t; typedef details::handle > dwarf_elf_t; typedef details::handle > dwarf_handle_t; typedef std::map die_linemap_t; typedef std::map die_specmap_t; struct die_cache_entry { die_specmap_t spec_section; die_linemap_t line_section; Dwarf_Line* line_buffer; Dwarf_Signed line_count; Dwarf_Line_Context line_context; inline bool isEmpty() { return line_buffer == NULL || line_count == 0 || line_context == NULL || line_section.empty(); } die_cache_entry() : line_buffer(0), line_count(0), line_context(0) {} ~die_cache_entry() { if (line_context) { dwarf_srclines_dealloc_b(line_context); } } }; typedef std::map die_cache_t; typedef std::map symbol_cache_t; struct dwarf_fileobject { dwarf_file_t file_handle; dwarf_elf_t elf_handle; dwarf_handle_t dwarf_handle; symbol_cache_t symbol_cache; // Die cache die_cache_t die_cache; die_cache_entry* current_cu; }; typedef details::hashtable::type fobj_dwarf_map_t; fobj_dwarf_map_t _fobj_dwarf_map; static bool cstrings_eq(const char* a, const char* b) { if (!a || !b) { return false; } return strcmp(a, b) == 0; } dwarf_fileobject& load_object_with_dwarf( const std::string& filename_object) { if (!_dwarf_loaded) { // Set the ELF library operating version // If that fails there's nothing we can do _dwarf_loaded = elf_version(EV_CURRENT) != EV_NONE; } fobj_dwarf_map_t::iterator it = _fobj_dwarf_map.find(filename_object); if (it != _fobj_dwarf_map.end()) { return it->second; } // this new object is empty for now dwarf_fileobject& r = _fobj_dwarf_map[filename_object]; dwarf_file_t file_handle; file_handle.reset(open(filename_object.c_str(), O_RDONLY)); if (file_handle < 0) { return r; } // Try to get an ELF handle. We need to read the ELF sections // because we want to see if there is a .gnu_debuglink section // that points to a split debug file dwarf_elf_t elf_handle; elf_handle.reset(elf_begin(file_handle.get(), ELF_C_READ, NULL)); if (!elf_handle) { return r; } const char* e_ident = elf_getident(elf_handle.get(), 0); if (!e_ident) { return r; } // Get the number of sections // We use the new APIs as elf_getshnum is deprecated size_t shdrnum = 0; if (elf_getshdrnum(elf_handle.get(), &shdrnum) == -1) { return r; } // Get the index to the string section size_t shdrstrndx = 0; if (elf_getshdrstrndx (elf_handle.get(), &shdrstrndx) == -1) { return r; } std::string debuglink; // Iterate through the ELF sections to try to get a gnu_debuglink // note and also to cache the symbol table. // We go the preprocessor way to avoid having to create templated // classes or using gelf (which might throw a compiler error if 64 bit // is not supported #define ELF_GET_DATA(ARCH) \ Elf_Scn *elf_section = 0; \ Elf_Data *elf_data = 0; \ Elf##ARCH##_Shdr* section_header = 0; \ Elf_Scn *symbol_section = 0; \ size_t symbol_count = 0; \ size_t symbol_strings = 0; \ Elf##ARCH##_Sym *symbol = 0; \ const char* section_name = 0; \ \ while ((elf_section = elf_nextscn(elf_handle.get(), elf_section)) \ != NULL) { \ section_header = elf##ARCH##_getshdr(elf_section); \ if (section_header == NULL) { \ return r; \ } \ \ if ((section_name = elf_strptr( \ elf_handle.get(), shdrstrndx, \ section_header->sh_name)) == NULL) { \ return r; \ } \ \ if (cstrings_eq(section_name, ".gnu_debuglink")) { \ elf_data = elf_getdata(elf_section, NULL); \ if (elf_data && elf_data->d_size > 0) { \ debuglink = std::string( \ reinterpret_cast(elf_data->d_buf)); \ } \ } \ \ switch(section_header->sh_type) { \ case SHT_SYMTAB: \ symbol_section = elf_section; \ symbol_count = section_header->sh_size / \ section_header->sh_entsize; \ symbol_strings = section_header->sh_link; \ break; \ \ /* We use .dynsyms as a last resort, we prefer .symtab */ \ case SHT_DYNSYM: \ if (!symbol_section) { \ symbol_section = elf_section; \ symbol_count = section_header->sh_size / \ section_header->sh_entsize; \ symbol_strings = section_header->sh_link; \ } \ break; \ } \ } \ \ if (symbol_section && symbol_count && symbol_strings) { \ elf_data = elf_getdata(symbol_section, NULL); \ symbol = reinterpret_cast(elf_data->d_buf); \ for (size_t i = 0; i < symbol_count; ++i) { \ int type = ELF##ARCH##_ST_TYPE(symbol->st_info); \ if (type == STT_FUNC && symbol->st_value > 0) { \ r.symbol_cache[symbol->st_value] = std::string( \ elf_strptr(elf_handle.get(), \ symbol_strings, symbol->st_name)); \ } \ ++symbol; \ } \ } \ if (e_ident[EI_CLASS] == ELFCLASS32) { ELF_GET_DATA(32) } else if (e_ident[EI_CLASS] == ELFCLASS64) { // libelf might have been built without 64 bit support #if __LIBELF64 ELF_GET_DATA(64) #endif } if (!debuglink.empty()) { // We have a debuglink section! Open an elf instance on that // file instead. If we can't open the file, then return // the elf handle we had already opened. dwarf_file_t debuglink_file; debuglink_file.reset(open(debuglink.c_str(), O_RDONLY)); if (debuglink_file.get() > 0) { dwarf_elf_t debuglink_elf; debuglink_elf.reset( elf_begin(debuglink_file.get(),ELF_C_READ, NULL) ); // If we have a valid elf handle, return the new elf handle // and file handle and discard the original ones if (debuglink_elf) { elf_handle = move(debuglink_elf); file_handle = move(debuglink_file); } } } // Ok, we have a valid ELF handle, let's try to get debug symbols Dwarf_Debug dwarf_debug; Dwarf_Error error = DW_DLE_NE; dwarf_handle_t dwarf_handle; int dwarf_result = dwarf_elf_init(elf_handle.get(), DW_DLC_READ, NULL, NULL, &dwarf_debug, &error); // We don't do any special handling for DW_DLV_NO_ENTRY specially. // If we get an error, or the file doesn't have debug information // we just return. if (dwarf_result != DW_DLV_OK) { return r; } dwarf_handle.reset(dwarf_debug); r.file_handle = move(file_handle); r.elf_handle = move(elf_handle); r.dwarf_handle = move(dwarf_handle); return r; } die_cache_entry& get_die_cache(dwarf_fileobject& fobj, Dwarf_Die die) { Dwarf_Error error = DW_DLE_NE; // Get the die offset, we use it as the cache key Dwarf_Off die_offset; if (dwarf_dieoffset(die, &die_offset, &error) != DW_DLV_OK) { die_offset = 0; } die_cache_t::iterator it = fobj.die_cache.find(die_offset); if (it != fobj.die_cache.end()) { fobj.current_cu = &it->second; return it->second; } die_cache_entry& de = fobj.die_cache[die_offset]; fobj.current_cu = &de; Dwarf_Addr line_addr; Dwarf_Small table_count; // The addresses in the line section are not fully sorted (they might // be sorted by block of code belonging to the same file), which makes // it necessary to do so before searching is possible. // // As libdwarf allocates a copy of everything, let's get the contents // of the line section and keep it around. We also create a map of // program counter to line table indices so we can search by address // and get the line buffer index. // // To make things more difficult, the same address can span more than // one line, so we need to keep the index pointing to the first line // by using insert instead of the map's [ operator. // Get the line context for the DIE if (dwarf_srclines_b(die, 0, &table_count, &de.line_context, &error) == DW_DLV_OK) { // Get the source lines for this line context, to be deallocated // later if (dwarf_srclines_from_linecontext( de.line_context, &de.line_buffer, &de.line_count, &error) == DW_DLV_OK) { // Add all the addresses to our map for (int i = 0; i < de.line_count; i++) { if (dwarf_lineaddr(de.line_buffer[i], &line_addr, &error) != DW_DLV_OK) { line_addr = 0; } de.line_section.insert( std::pair(line_addr, i)); } } } // For each CU, cache the function DIEs that contain the // DW_AT_specification attribute. When building with -g3 the function // DIEs are separated in declaration and specification, with the // declaration containing only the name and parameters and the // specification the low/high pc and other compiler attributes. // // We cache those specifications so we don't skip over the declarations, // because they have no pc, and we can do namespace resolution for // DWARF function names. Dwarf_Debug dwarf = fobj.dwarf_handle.get(); Dwarf_Die current_die = 0; if (dwarf_child(die, ¤t_die, &error) == DW_DLV_OK) { for(;;) { Dwarf_Die sibling_die = 0; Dwarf_Half tag_value; dwarf_tag(current_die, &tag_value, &error); if (tag_value == DW_TAG_subprogram || tag_value == DW_TAG_inlined_subroutine) { Dwarf_Bool has_attr = 0; if (dwarf_hasattr(current_die, DW_AT_specification, &has_attr, &error) == DW_DLV_OK) { if (has_attr) { Dwarf_Attribute attr_mem; if (dwarf_attr(current_die, DW_AT_specification, &attr_mem, &error) == DW_DLV_OK) { Dwarf_Off spec_offset = 0; if (dwarf_formref(attr_mem, &spec_offset, &error) == DW_DLV_OK) { Dwarf_Off spec_die_offset; if (dwarf_dieoffset(current_die, &spec_die_offset, &error) == DW_DLV_OK) { de.spec_section[spec_offset] = spec_die_offset; } } } dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); } } } int result = dwarf_siblingof( dwarf, current_die, &sibling_die, &error); if (result == DW_DLV_ERROR) { break; } else if (result == DW_DLV_NO_ENTRY) { break; } if (current_die != die) { dwarf_dealloc(dwarf, current_die, DW_DLA_DIE); current_die = 0; } current_die = sibling_die; } } return de; } static Dwarf_Die get_referenced_die( Dwarf_Debug dwarf, Dwarf_Die die, Dwarf_Half attr, bool global) { Dwarf_Error error = DW_DLE_NE; Dwarf_Attribute attr_mem; Dwarf_Die found_die = NULL; if (dwarf_attr(die, attr, &attr_mem, &error) == DW_DLV_OK) { Dwarf_Off offset; int result = 0; if (global) { result = dwarf_global_formref(attr_mem, &offset, &error); } else { result = dwarf_formref(attr_mem, &offset, &error); } if (result == DW_DLV_OK) { if (dwarf_offdie(dwarf, offset, &found_die, &error) != DW_DLV_OK) { found_die = NULL; } } dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); } return found_die; } static std::string get_referenced_die_name( Dwarf_Debug dwarf, Dwarf_Die die, Dwarf_Half attr, bool global) { Dwarf_Error error = DW_DLE_NE; std::string value; Dwarf_Die found_die = get_referenced_die(dwarf, die, attr, global); if (found_die) { char *name; if (dwarf_diename(found_die, &name, &error) == DW_DLV_OK) { if (name) { value = std::string(name); } dwarf_dealloc(dwarf, name, DW_DLA_STRING); } dwarf_dealloc(dwarf, found_die, DW_DLA_DIE); } return value; } // Returns a spec DIE linked to the passed one. The caller should // deallocate the DIE static Dwarf_Die get_spec_die(dwarf_fileobject& fobj, Dwarf_Die die) { Dwarf_Debug dwarf = fobj.dwarf_handle.get(); Dwarf_Error error = DW_DLE_NE; Dwarf_Off die_offset; if (fobj.current_cu && dwarf_die_CU_offset(die, &die_offset, &error) == DW_DLV_OK) { die_specmap_t::iterator it = fobj.current_cu->spec_section.find(die_offset); // If we have a DIE that completes the current one, check if // that one has the pc we are looking for if (it != fobj.current_cu->spec_section.end()) { Dwarf_Die spec_die = 0; if (dwarf_offdie(dwarf, it->second, &spec_die, &error) == DW_DLV_OK) { return spec_die; } } } // Maybe we have an abstract origin DIE with the function information? return get_referenced_die( fobj.dwarf_handle.get(), die, DW_AT_abstract_origin, true); } static bool die_has_pc(dwarf_fileobject& fobj, Dwarf_Die die, Dwarf_Addr pc) { Dwarf_Addr low_pc = 0, high_pc = 0; Dwarf_Half high_pc_form = 0; Dwarf_Form_Class return_class; Dwarf_Error error = DW_DLE_NE; Dwarf_Debug dwarf = fobj.dwarf_handle.get(); bool has_lowpc = false; bool has_highpc = false; bool has_ranges = false; if (dwarf_lowpc(die, &low_pc, &error) == DW_DLV_OK) { // If we have a low_pc check if there is a high pc. // If we don't have a high pc this might mean we have a base // address for the ranges list or just an address. has_lowpc = true; if (dwarf_highpc_b( die, &high_pc, &high_pc_form, &return_class, &error) == DW_DLV_OK) { // We do have a high pc. In DWARF 4+ this is an offset from the // low pc, but in earlier versions it's an absolute address. has_highpc = true; // In DWARF 2/3 this would be a DW_FORM_CLASS_ADDRESS if (return_class == DW_FORM_CLASS_CONSTANT) { high_pc = low_pc + high_pc; } // We have low and high pc, check if our address // is in that range return pc >= low_pc && pc < high_pc; } } else { // Reset the low_pc, in case dwarf_lowpc failing set it to some // undefined value. low_pc = 0; } // Check if DW_AT_ranges is present and search for the PC in the // returned ranges list. We always add the low_pc, as it not set it will // be 0, in case we had a DW_AT_low_pc and DW_AT_ranges pair bool result = false; Dwarf_Attribute attr; if (dwarf_attr(die, DW_AT_ranges, &attr, &error) == DW_DLV_OK) { Dwarf_Off offset; if (dwarf_global_formref(attr, &offset, &error) == DW_DLV_OK) { Dwarf_Ranges *ranges; Dwarf_Signed ranges_count = 0; Dwarf_Unsigned byte_count = 0; if (dwarf_get_ranges_a(dwarf, offset, die, &ranges, &ranges_count, &byte_count, &error) == DW_DLV_OK) { has_ranges = ranges_count != 0; for (int i = 0; i < ranges_count; i++) { if (ranges[i].dwr_addr1 != 0 && pc >= ranges[i].dwr_addr1 + low_pc && pc < ranges[i].dwr_addr2 + low_pc) { result = true; break; } } dwarf_ranges_dealloc(dwarf, ranges, ranges_count); } } } // Last attempt. We might have a single address set as low_pc. if (!result && low_pc != 0 && pc == low_pc) { result = true; } // If we don't have lowpc, highpc and ranges maybe this DIE is a // declaration that relies on a DW_AT_specification DIE that happens // later. Use the specification cache we filled when we loaded this CU. if (!result && (!has_lowpc && !has_highpc && !has_ranges)) { Dwarf_Die spec_die = get_spec_die(fobj, die); if (spec_die) { result = die_has_pc(fobj, spec_die, pc); dwarf_dealloc(dwarf, spec_die, DW_DLA_DIE); } } return result; } static void get_type(Dwarf_Debug dwarf, Dwarf_Die die, std::string& type) { Dwarf_Error error = DW_DLE_NE; Dwarf_Die child = 0; if (dwarf_child(die, &child, &error) == DW_DLV_OK) { get_type(dwarf, child, type); } if (child) { type.insert(0, "::"); dwarf_dealloc(dwarf, child, DW_DLA_DIE); } char *name; if (dwarf_diename(die, &name, &error) == DW_DLV_OK) { type.insert(0, std::string(name)); dwarf_dealloc(dwarf, name, DW_DLA_STRING); } else { type.insert(0,""); } } static std::string get_type_by_signature(Dwarf_Debug dwarf, Dwarf_Die die) { Dwarf_Error error = DW_DLE_NE; Dwarf_Sig8 signature; Dwarf_Bool has_attr = 0; if (dwarf_hasattr(die, DW_AT_signature, &has_attr, &error) == DW_DLV_OK) { if (has_attr) { Dwarf_Attribute attr_mem; if (dwarf_attr(die, DW_AT_signature, &attr_mem, &error) == DW_DLV_OK) { if (dwarf_formsig8(attr_mem, &signature, &error) != DW_DLV_OK) { return std::string(""); } } dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); } } Dwarf_Unsigned next_cu_header; Dwarf_Sig8 tu_signature; std::string result; bool found = false; while (dwarf_next_cu_header_d(dwarf, 0, 0, 0, 0, 0, 0, 0, &tu_signature, 0, &next_cu_header, 0, &error) == DW_DLV_OK) { if (strncmp(signature.signature, tu_signature.signature, 8) == 0) { Dwarf_Die type_cu_die = 0; if (dwarf_siblingof_b(dwarf, 0, 0, &type_cu_die, &error) == DW_DLV_OK) { Dwarf_Die child_die = 0; if (dwarf_child(type_cu_die, &child_die, &error) == DW_DLV_OK) { get_type(dwarf, child_die, result); found = !result.empty(); dwarf_dealloc(dwarf, child_die, DW_DLA_DIE); } dwarf_dealloc(dwarf, type_cu_die, DW_DLA_DIE); } } } if (found) { while (dwarf_next_cu_header_d(dwarf, 0, 0, 0, 0, 0, 0, 0, 0, 0, &next_cu_header, 0, &error) == DW_DLV_OK) { // Reset the cu header state. Unfortunately, libdwarf's // next_cu_header API keeps its own iterator per Dwarf_Debug // that can't be reset. We need to keep fetching elements until // the end. } } else { // If we couldn't resolve the type just print out the signature std::ostringstream string_stream; string_stream << "<0x" << std::hex << std::setfill('0'); for (int i = 0; i < 8; ++i) { string_stream << std::setw(2) << std::hex << (int)(unsigned char)(signature.signature[i]); } string_stream << ">"; result = string_stream.str(); } return result; } struct type_context_t { bool is_const; bool is_typedef; bool has_type; bool has_name; std::string text; type_context_t() : is_const(false), is_typedef(false), has_type(false), has_name(false) {} }; // Types are resolved from right to left: we get the variable name first // and then all specifiers (like const or pointer) in a chain of DW_AT_type // DIEs. Call this function recursively until we get a complete type // string. static void set_parameter_string( dwarf_fileobject& fobj, Dwarf_Die die, type_context_t &context) { char *name; Dwarf_Error error = DW_DLE_NE; // typedefs contain also the base type, so we skip it and only // print the typedef name if (!context.is_typedef) { if (dwarf_diename(die, &name, &error) == DW_DLV_OK) { if (!context.text.empty()) { context.text.insert(0, " "); } context.text.insert(0, std::string(name)); dwarf_dealloc(fobj.dwarf_handle.get(), name, DW_DLA_STRING); } } else { context.is_typedef = false; context.has_type = true; if (context.is_const) { context.text.insert(0, "const "); context.is_const = false; } } bool next_type_is_const = false; bool is_keyword = true; Dwarf_Half tag = 0; Dwarf_Bool has_attr = 0; if (dwarf_tag(die, &tag, &error) == DW_DLV_OK) { switch(tag) { case DW_TAG_structure_type: case DW_TAG_union_type: case DW_TAG_class_type: case DW_TAG_enumeration_type: context.has_type = true; if (dwarf_hasattr(die, DW_AT_signature, &has_attr, &error) == DW_DLV_OK) { // If we have a signature it means the type is defined // in .debug_types, so we need to load the DIE pointed // at by the signature and resolve it if (has_attr) { std::string type = get_type_by_signature(fobj.dwarf_handle.get(), die); if (context.is_const) type.insert(0, "const "); if (!context.text.empty()) context.text.insert(0, " "); context.text.insert(0, type); } // Treat enums like typedefs, and skip printing its // base type context.is_typedef = (tag == DW_TAG_enumeration_type); } break; case DW_TAG_const_type: next_type_is_const = true; break; case DW_TAG_pointer_type: context.text.insert(0, "*"); break; case DW_TAG_reference_type: context.text.insert(0, "&"); break; case DW_TAG_restrict_type: context.text.insert(0, "restrict "); break; case DW_TAG_rvalue_reference_type: context.text.insert(0, "&&"); break; case DW_TAG_volatile_type: context.text.insert(0, "volatile "); break; case DW_TAG_typedef: // Propagate the const-ness to the next type // as typedefs are linked to its base type next_type_is_const = context.is_const; context.is_typedef = true; context.has_type = true; break; case DW_TAG_base_type: context.has_type = true; break; case DW_TAG_formal_parameter: context.has_name = true; break; default: is_keyword = false; break; } } if (!is_keyword && context.is_const) { context.text.insert(0, "const "); } context.is_const = next_type_is_const; Dwarf_Die ref = get_referenced_die( fobj.dwarf_handle.get(), die, DW_AT_type, true); if (ref) { set_parameter_string(fobj, ref, context); dwarf_dealloc(fobj.dwarf_handle.get(), ref, DW_DLA_DIE); } if (!context.has_type && context.has_name) { context.text.insert(0, "void "); context.has_type = true; } } // Resolve the function return type and parameters static void set_function_parameters(std::string& function_name, std::vector& ns, dwarf_fileobject& fobj, Dwarf_Die die) { Dwarf_Debug dwarf = fobj.dwarf_handle.get(); Dwarf_Error error = DW_DLE_NE; Dwarf_Die current_die = 0; std::string parameters; bool has_spec = true; // Check if we have a spec DIE. If we do we use it as it contains // more information, like parameter names. Dwarf_Die spec_die = get_spec_die(fobj, die); if (!spec_die) { has_spec = false; spec_die = die; } std::vector::const_iterator it = ns.begin(); std::string ns_name; for (it = ns.begin(); it < ns.end(); ++it) { ns_name.append(*it).append("::"); } if (!ns_name.empty()) { function_name.insert(0, ns_name); } // See if we have a function return type. It can be either on the // current die or in its spec one (usually true for inlined functions) std::string return_type = get_referenced_die_name(dwarf, die, DW_AT_type, true); if (return_type.empty()) { return_type = get_referenced_die_name(dwarf, spec_die, DW_AT_type, true); } if (!return_type.empty()) { return_type.append(" "); function_name.insert(0, return_type); } if (dwarf_child(spec_die, ¤t_die, &error) == DW_DLV_OK) { for(;;) { Dwarf_Die sibling_die = 0; Dwarf_Half tag_value; dwarf_tag(current_die, &tag_value, &error); if (tag_value == DW_TAG_formal_parameter) { // Ignore artificial (ie, compiler generated) parameters bool is_artificial = false; Dwarf_Attribute attr_mem; if (dwarf_attr( current_die, DW_AT_artificial, &attr_mem, &error) == DW_DLV_OK) { Dwarf_Bool flag = 0; if (dwarf_formflag(attr_mem, &flag, &error) == DW_DLV_OK) { is_artificial = flag != 0; } dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); } if (!is_artificial) { type_context_t context; set_parameter_string(fobj, current_die, context); if (parameters.empty()) { parameters.append("("); } else { parameters.append(", "); } parameters.append(context.text); } } int result = dwarf_siblingof( dwarf, current_die, &sibling_die, &error); if (result == DW_DLV_ERROR) { break; } else if (result == DW_DLV_NO_ENTRY) { break; } if (current_die != die) { dwarf_dealloc(dwarf, current_die, DW_DLA_DIE); current_die = 0; } current_die = sibling_die; } } if (parameters.empty()) parameters = "("; parameters.append(")"); // If we got a spec DIE we need to deallocate it if (has_spec) dwarf_dealloc(dwarf, spec_die, DW_DLA_DIE); function_name.append(parameters); } // defined here because in C++98, template function cannot take locally // defined types... grrr. struct inliners_search_cb { void operator()(Dwarf_Die die, std::vector& ns) { Dwarf_Error error = DW_DLE_NE; Dwarf_Half tag_value; Dwarf_Attribute attr_mem; Dwarf_Debug dwarf = fobj.dwarf_handle.get(); dwarf_tag(die, &tag_value, &error); switch (tag_value) { char* name; case DW_TAG_subprogram: if (!trace.source.function.empty()) break; if (dwarf_diename(die, &name, &error) == DW_DLV_OK) { trace.source.function = std::string(name); dwarf_dealloc(dwarf, name, DW_DLA_STRING); } else { // We don't have a function name in this DIE. // Check if there is a referenced non-defining // declaration. trace.source.function = get_referenced_die_name( dwarf, die, DW_AT_abstract_origin, true); if (trace.source.function.empty()) { trace.source.function = get_referenced_die_name( dwarf, die, DW_AT_specification, true); } } // Append the function parameters, if available set_function_parameters( trace.source.function, ns, fobj, die); // If the object function name is empty, it's possible that // there is no dynamic symbol table (maybe the executable // was stripped or not built with -rdynamic). See if we have // a DWARF linkage name to use instead. We try both // linkage_name and MIPS_linkage_name because the MIPS tag // was the unofficial one until it was adopted in DWARF4. // Old gcc versions generate MIPS_linkage_name if (trace.object_function.empty()) { details::demangler demangler; if (dwarf_attr(die, DW_AT_linkage_name, &attr_mem, &error) != DW_DLV_OK) { if (dwarf_attr(die, DW_AT_MIPS_linkage_name, &attr_mem, &error) != DW_DLV_OK) { break; } } char* linkage; if (dwarf_formstring(attr_mem, &linkage, &error) == DW_DLV_OK) { trace.object_function = demangler.demangle(linkage); dwarf_dealloc(dwarf, linkage, DW_DLA_STRING); } dwarf_dealloc(dwarf, name, DW_DLA_ATTR); } break; case DW_TAG_inlined_subroutine: ResolvedTrace::SourceLoc sloc; if (dwarf_diename(die, &name, &error) == DW_DLV_OK) { sloc.function = std::string(name); dwarf_dealloc(dwarf, name, DW_DLA_STRING); } else { // We don't have a name for this inlined DIE, it could // be that there is an abstract origin instead. // Get the DW_AT_abstract_origin value, which is a // reference to the source DIE and try to get its name sloc.function = get_referenced_die_name( dwarf, die, DW_AT_abstract_origin, true); } set_function_parameters(sloc.function, ns, fobj, die); std::string file = die_call_file(dwarf, die, cu_die); if (!file.empty()) sloc.filename = file; Dwarf_Unsigned number = 0; if (dwarf_attr(die, DW_AT_call_line, &attr_mem, &error) == DW_DLV_OK) { if (dwarf_formudata(attr_mem, &number, &error) == DW_DLV_OK) { sloc.line = number; } dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); } if (dwarf_attr(die, DW_AT_call_column, &attr_mem, &error) == DW_DLV_OK) { if (dwarf_formudata(attr_mem, &number, &error) == DW_DLV_OK) { sloc.col = number; } dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); } trace.inliners.push_back(sloc); break; }; } ResolvedTrace& trace; dwarf_fileobject& fobj; Dwarf_Die cu_die; inliners_search_cb(ResolvedTrace& t, dwarf_fileobject& f, Dwarf_Die c) : trace(t), fobj(f), cu_die(c) {} }; static Dwarf_Die find_fundie_by_pc(dwarf_fileobject& fobj, Dwarf_Die parent_die, Dwarf_Addr pc, Dwarf_Die result) { Dwarf_Die current_die = 0; Dwarf_Error error = DW_DLE_NE; Dwarf_Debug dwarf = fobj.dwarf_handle.get(); if (dwarf_child(parent_die, ¤t_die, &error) != DW_DLV_OK) { return NULL; } for(;;) { Dwarf_Die sibling_die = 0; Dwarf_Half tag_value; dwarf_tag(current_die, &tag_value, &error); switch (tag_value) { case DW_TAG_subprogram: case DW_TAG_inlined_subroutine: if (die_has_pc(fobj, current_die, pc)) { return current_die; } }; bool declaration = false; Dwarf_Attribute attr_mem; if (dwarf_attr(current_die, DW_AT_declaration, &attr_mem, &error) == DW_DLV_OK) { Dwarf_Bool flag = 0; if (dwarf_formflag(attr_mem, &flag, &error) == DW_DLV_OK) { declaration = flag != 0; } dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); } if (!declaration) { // let's be curious and look deeper in the tree, functions are // not necessarily at the first level, but might be nested // inside a namespace, structure, a function, an inlined // function etc. Dwarf_Die die_mem = 0; Dwarf_Die indie = find_fundie_by_pc( fobj, current_die, pc, die_mem); if (indie) { result = die_mem; return result; } } int res = dwarf_siblingof( dwarf, current_die, &sibling_die, &error); if (res == DW_DLV_ERROR) { return NULL; } else if (res == DW_DLV_NO_ENTRY) { break; } if (current_die != parent_die) { dwarf_dealloc(dwarf, current_die, DW_DLA_DIE); current_die = 0; } current_die = sibling_die; } return NULL; } template static bool deep_first_search_by_pc(dwarf_fileobject& fobj, Dwarf_Die parent_die, Dwarf_Addr pc, std::vector& ns, CB cb) { Dwarf_Die current_die = 0; Dwarf_Debug dwarf = fobj.dwarf_handle.get(); Dwarf_Error error = DW_DLE_NE; if (dwarf_child(parent_die, ¤t_die, &error) != DW_DLV_OK) { return false; } bool branch_has_pc = false; bool has_namespace = false; for(;;) { Dwarf_Die sibling_die = 0; Dwarf_Half tag; if (dwarf_tag(current_die, &tag, &error) == DW_DLV_OK) { if (tag == DW_TAG_namespace || tag == DW_TAG_class_type) { char* ns_name = NULL; if (dwarf_diename(current_die, &ns_name, &error) == DW_DLV_OK) { if (ns_name) { ns.push_back(std::string(ns_name)); } else { ns.push_back(""); } dwarf_dealloc(dwarf, ns_name, DW_DLA_STRING); } else { ns.push_back(""); } has_namespace = true; } } bool declaration = false; Dwarf_Attribute attr_mem; if (tag != DW_TAG_class_type && dwarf_attr(current_die, DW_AT_declaration, &attr_mem, &error) == DW_DLV_OK) { Dwarf_Bool flag = 0; if (dwarf_formflag(attr_mem, &flag, &error) == DW_DLV_OK) { declaration = flag != 0; } dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); } if (!declaration) { // let's be curious and look deeper in the tree, function are // not necessarily at the first level, but might be nested // inside a namespace, structure, a function, an inlined // function etc. branch_has_pc = deep_first_search_by_pc( fobj, current_die, pc, ns, cb); } if (!branch_has_pc) { branch_has_pc = die_has_pc(fobj, current_die, pc); } if (branch_has_pc) { cb(current_die, ns); } int result = dwarf_siblingof( dwarf, current_die, &sibling_die, &error); if (result == DW_DLV_ERROR) { return false; } else if (result == DW_DLV_NO_ENTRY) { break; } if (current_die != parent_die) { dwarf_dealloc(dwarf, current_die, DW_DLA_DIE); current_die = 0; } if (has_namespace) { has_namespace = false; ns.pop_back(); } current_die = sibling_die; } if (has_namespace) { ns.pop_back(); } return branch_has_pc; } static std::string die_call_file( Dwarf_Debug dwarf, Dwarf_Die die, Dwarf_Die cu_die) { Dwarf_Attribute attr_mem; Dwarf_Error error = DW_DLE_NE; Dwarf_Signed file_index; std::string file; if (dwarf_attr(die, DW_AT_call_file, &attr_mem, &error) == DW_DLV_OK) { if (dwarf_formsdata(attr_mem, &file_index, &error) != DW_DLV_OK) { file_index = 0; } dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); if (file_index == 0) { return file; } char **srcfiles = 0; Dwarf_Signed file_count = 0; if (dwarf_srcfiles(cu_die, &srcfiles, &file_count, &error) == DW_DLV_OK) { if (file_index <= file_count) file = std::string(srcfiles[file_index - 1]); // Deallocate all strings! for (int i = 0; i < file_count; ++i) { dwarf_dealloc(dwarf, srcfiles[i], DW_DLA_STRING); } dwarf_dealloc(dwarf, srcfiles, DW_DLA_LIST); } } return file; } Dwarf_Die find_die(dwarf_fileobject& fobj, Dwarf_Addr addr) { // Let's get to work! First see if we have a debug_aranges section so // we can speed up the search Dwarf_Debug dwarf = fobj.dwarf_handle.get(); Dwarf_Error error = DW_DLE_NE; Dwarf_Arange *aranges; Dwarf_Signed arange_count; Dwarf_Die returnDie; bool found = false; if (dwarf_get_aranges( dwarf, &aranges, &arange_count, &error) != DW_DLV_OK) { aranges = NULL; } if (aranges) { // We have aranges. Get the one where our address is. Dwarf_Arange arange; if (dwarf_get_arange( aranges, arange_count, addr, &arange, &error) == DW_DLV_OK) { // We found our address. Get the compilation-unit DIE offset // represented by the given address range. Dwarf_Off cu_die_offset; if (dwarf_get_cu_die_offset(arange, &cu_die_offset, &error) == DW_DLV_OK) { // Get the DIE at the offset returned by the aranges search. // We set is_info to 1 to specify that the offset is from // the .debug_info section (and not .debug_types) int dwarf_result = dwarf_offdie_b( dwarf, cu_die_offset, 1, &returnDie, &error); found = dwarf_result == DW_DLV_OK; } dwarf_dealloc(dwarf, arange, DW_DLA_ARANGE); } } if (found) return returnDie; // The caller is responsible for freeing the die // The search for aranges failed. Try to find our address by scanning // all compilation units. Dwarf_Unsigned next_cu_header; Dwarf_Half tag = 0; returnDie = 0; while (!found && dwarf_next_cu_header_d(dwarf, 1, 0, 0, 0, 0, 0, 0, 0, 0, &next_cu_header, 0, &error) == DW_DLV_OK) { if (returnDie) dwarf_dealloc(dwarf, returnDie, DW_DLA_DIE); if (dwarf_siblingof(dwarf, 0, &returnDie, &error) == DW_DLV_OK) { if ((dwarf_tag(returnDie, &tag, &error) == DW_DLV_OK) && tag == DW_TAG_compile_unit) { if (die_has_pc(fobj, returnDie, addr)) { found = true; } } } } if (found) { while (dwarf_next_cu_header_d(dwarf, 1, 0, 0, 0, 0, 0, 0, 0, 0, &next_cu_header, 0, &error) == DW_DLV_OK) { // Reset the cu header state. Libdwarf's next_cu_header API // keeps its own iterator per Dwarf_Debug that can't be reset. // We need to keep fetching elements until the end. } } if (found) return returnDie; // We couldn't find any compilation units with ranges or a high/low pc. // Try again by looking at all DIEs in all compilation units. Dwarf_Die cudie; while (dwarf_next_cu_header_d(dwarf, 1, 0, 0, 0, 0, 0, 0, 0, 0, &next_cu_header, 0, &error) == DW_DLV_OK) { if (dwarf_siblingof(dwarf, 0, &cudie, &error) == DW_DLV_OK) { Dwarf_Die die_mem = 0; Dwarf_Die resultDie = find_fundie_by_pc( fobj, cudie, addr, die_mem); if (resultDie) { found = true; break; } } } if (found) { while (dwarf_next_cu_header_d(dwarf, 1, 0, 0, 0, 0, 0, 0, 0, 0, &next_cu_header, 0, &error) == DW_DLV_OK) { // Reset the cu header state. Libdwarf's next_cu_header API // keeps its own iterator per Dwarf_Debug that can't be reset. // We need to keep fetching elements until the end. } } if (found) return cudie; // We failed. return NULL; } }; #endif // BACKWARD_HAS_DWARF == 1 template<> class TraceResolverImpl: public TraceResolverLinuxImpl {}; #endif // BACKWARD_SYSTEM_LINUX #ifdef BACKWARD_SYSTEM_DARWIN template class TraceResolverDarwinImpl; template <> class TraceResolverDarwinImpl: public TraceResolverImplBase { public: template void load_stacktrace(ST& st) { using namespace details; if (st.size() == 0) { return; } _symbols.reset( backtrace_symbols(st.begin(), st.size()) ); } ResolvedTrace resolve(ResolvedTrace trace) { // parse: // + char* filename = _symbols[trace.idx]; // skip " " while(*filename && *filename != ' ') filename++; while(*filename == ' ') filename++; // find start of from end ( may contain a space) char* p = filename + strlen(filename) - 1; // skip to start of " + " while(p > filename && *p != ' ') p--; while(p > filename && *p == ' ') p--; while(p > filename && *p != ' ') p--; while(p > filename && *p == ' ') p--; char *funcname_end = p + 1; // skip to start of "" while(p > filename && *p != ' ') p--; char *funcname = p + 1; // skip to start of " " while(p > filename && *p == ' ') p--; while(p > filename && *p != ' ') p--; while(p > filename && *p == ' ') p--; // skip "", handling the case where it contains a char* filename_end = p + 1; if (p == filename) { // something went wrong, give up filename_end = filename + strlen(filename); funcname = filename_end; } trace.object_filename.assign(filename, filename_end); // ok even if filename_end is the ending \0 (then we assign entire string) if (*funcname) { // if it's not end of string *funcname_end = '\0'; trace.object_function = this->demangle(funcname); trace.object_function += " "; trace.object_function += (funcname_end + 1); trace.source.function = trace.object_function; // we cannot do better. } return trace; } private: details::handle _symbols; }; template<> class TraceResolverImpl: public TraceResolverDarwinImpl {}; #endif // BACKWARD_SYSTEM_DARWIN class TraceResolver: public TraceResolverImpl {}; /*************** CODE SNIPPET ***************/ class SourceFile { public: typedef std::vector > lines_t; SourceFile() {} SourceFile(const std::string& path): _file(new std::ifstream(path.c_str())) {} bool is_open() const { return _file->is_open(); } lines_t& get_lines(unsigned line_start, unsigned line_count, lines_t& lines) { using namespace std; // This function make uses of the dumbest algo ever: // 1) seek(0) // 2) read lines one by one and discard until line_start // 3) read line one by one until line_start + line_count // // If you are getting snippets many time from the same file, it is // somewhat a waste of CPU, feel free to benchmark and propose a // better solution ;) _file->clear(); _file->seekg(0); string line; unsigned line_idx; for (line_idx = 1; line_idx < line_start; ++line_idx) { std::getline(*_file, line); if (!*_file) { return lines; } } // think of it like a lambda in C++98 ;) // but look, I will reuse it two times! // What a good boy am I. struct isspace { bool operator()(char c) { return std::isspace(c); } }; bool started = false; for (; line_idx < line_start + line_count; ++line_idx) { getline(*_file, line); if (!*_file) { return lines; } if (!started) { if (std::find_if(line.begin(), line.end(), not_isspace()) == line.end()) continue; started = true; } lines.push_back(make_pair(line_idx, line)); } lines.erase( std::find_if(lines.rbegin(), lines.rend(), not_isempty()).base(), lines.end() ); return lines; } lines_t get_lines(unsigned line_start, unsigned line_count) { lines_t lines; return get_lines(line_start, line_count, lines); } // there is no find_if_not in C++98, lets do something crappy to // workaround. struct not_isspace { bool operator()(char c) { return !std::isspace(c); } }; // and define this one here because C++98 is not happy with local defined // struct passed to template functions, fuuuu. struct not_isempty { bool operator()(const lines_t::value_type& p) { return !(std::find_if(p.second.begin(), p.second.end(), not_isspace()) == p.second.end()); } }; void swap(SourceFile& b) { _file.swap(b._file); } #ifdef BACKWARD_ATLEAST_CXX11 SourceFile(SourceFile&& from): _file(nullptr) { swap(from); } SourceFile& operator=(SourceFile&& from) { swap(from); return *this; } #else explicit SourceFile(const SourceFile& from) { // some sort of poor man's move semantic. swap(const_cast(from)); } SourceFile& operator=(const SourceFile& from) { // some sort of poor man's move semantic. swap(const_cast(from)); return *this; } #endif private: details::handle > _file; #ifdef BACKWARD_ATLEAST_CXX11 SourceFile(const SourceFile&) = delete; SourceFile& operator=(const SourceFile&) = delete; #endif }; class SnippetFactory { public: typedef SourceFile::lines_t lines_t; lines_t get_snippet(const std::string& filename, unsigned line_start, unsigned context_size) { SourceFile& src_file = get_src_file(filename); unsigned start = line_start - context_size / 2; return src_file.get_lines(start, context_size); } lines_t get_combined_snippet( const std::string& filename_a, unsigned line_a, const std::string& filename_b, unsigned line_b, unsigned context_size) { SourceFile& src_file_a = get_src_file(filename_a); SourceFile& src_file_b = get_src_file(filename_b); lines_t lines = src_file_a.get_lines(line_a - context_size / 4, context_size / 2); src_file_b.get_lines(line_b - context_size / 4, context_size / 2, lines); return lines; } lines_t get_coalesced_snippet(const std::string& filename, unsigned line_a, unsigned line_b, unsigned context_size) { SourceFile& src_file = get_src_file(filename); using std::min; using std::max; unsigned a = min(line_a, line_b); unsigned b = max(line_a, line_b); if ((b - a) < (context_size / 3)) { return src_file.get_lines((a + b - context_size + 1) / 2, context_size); } lines_t lines = src_file.get_lines(a - context_size / 4, context_size / 2); src_file.get_lines(b - context_size / 4, context_size / 2, lines); return lines; } private: typedef details::hashtable::type src_files_t; src_files_t _src_files; SourceFile& get_src_file(const std::string& filename) { src_files_t::iterator it = _src_files.find(filename); if (it != _src_files.end()) { return it->second; } SourceFile& new_src_file = _src_files[filename]; new_src_file = SourceFile(filename); return new_src_file; } }; /*************** PRINTER ***************/ namespace ColorMode { enum type { automatic, never, always }; } class cfile_streambuf: public std::streambuf { public: cfile_streambuf(FILE *_sink): sink(_sink) {} int_type underflow() override { return traits_type::eof(); } int_type overflow(int_type ch) override { if (traits_type::not_eof(ch) && fwrite(&ch, sizeof ch, 1, sink) == 1) { return ch; } return traits_type::eof(); } std::streamsize xsputn(const char_type* s, std::streamsize count) override { return static_cast(fwrite(s, sizeof *s, static_cast(count), sink)); } #ifdef BACKWARD_ATLEAST_CXX11 public: cfile_streambuf(const cfile_streambuf&) = delete; cfile_streambuf& operator=(const cfile_streambuf&) = delete; #else private: cfile_streambuf(const cfile_streambuf &); cfile_streambuf &operator= (const cfile_streambuf &); #endif private: FILE *sink; std::vector buffer; }; #ifdef BACKWARD_SYSTEM_LINUX namespace Color { enum type { yellow = 33, purple = 35, reset = 39 }; } // namespace Color class Colorize { public: Colorize(std::ostream& os): _os(os), _reset(false), _enabled(false) {} void activate(ColorMode::type mode) { _enabled = mode == ColorMode::always; } void activate(ColorMode::type mode, FILE* fp) { activate(mode, fileno(fp)); } void set_color(Color::type ccode) { if (!_enabled) return; // I assume that the terminal can handle basic colors. Seriously I // don't want to deal with all the termcap shit. _os << "\033[" << static_cast(ccode) << "m"; _reset = (ccode != Color::reset); } ~Colorize() { if (_reset) { set_color(Color::reset); } } private: void activate(ColorMode::type mode, int fd) { activate(mode == ColorMode::automatic && isatty(fd) ? ColorMode::always : mode); } std::ostream& _os; bool _reset; bool _enabled; }; #else // ndef BACKWARD_SYSTEM_LINUX namespace Color { enum type { yellow = 0, purple = 0, reset = 0 }; } // namespace Color class Colorize { public: Colorize(std::ostream&) {} void activate(ColorMode::type) {} void activate(ColorMode::type, FILE*) {} void set_color(Color::type) {} }; #endif // BACKWARD_SYSTEM_LINUX class Printer { public: bool snippet; ColorMode::type color_mode; bool address; bool object; int inliner_context_size; int trace_context_size; Printer(): snippet(true), color_mode(ColorMode::automatic), address(false), object(false), inliner_context_size(5), trace_context_size(7) {} template FILE* print(ST& st, FILE* fp = stderr) { cfile_streambuf obuf(fp); std::ostream os(&obuf); Colorize colorize(os); colorize.activate(color_mode, fp); print_stacktrace(st, os, colorize); return fp; } template std::ostream& print(ST& st, std::ostream& os) { Colorize colorize(os); colorize.activate(color_mode); print_stacktrace(st, os, colorize); return os; } template FILE* print(IT begin, IT end, FILE* fp = stderr, size_t thread_id = 0) { cfile_streambuf obuf(fp); std::ostream os(&obuf); Colorize colorize(os); colorize.activate(color_mode, fp); print_stacktrace(begin, end, os, thread_id, colorize); return fp; } template std::ostream& print(IT begin, IT end, std::ostream& os, size_t thread_id = 0) { Colorize colorize(os); colorize.activate(color_mode); print_stacktrace(begin, end, os, thread_id, colorize); return os; } private: TraceResolver _resolver; SnippetFactory _snippets; template void print_stacktrace(ST& st, std::ostream& os, Colorize& colorize) { print_header(os, st.thread_id()); _resolver.load_stacktrace(st); for (size_t trace_idx = st.size(); trace_idx > 0; --trace_idx) { print_trace(os, _resolver.resolve(st[trace_idx-1]), colorize); } } template void print_stacktrace(IT begin, IT end, std::ostream& os, size_t thread_id, Colorize& colorize) { print_header(os, thread_id); for (; begin != end; ++begin) { print_trace(os, *begin, colorize); } } void print_header(std::ostream& os, size_t thread_id) { os << "Stack trace (most recent call last)"; if (thread_id) { os << " in thread " << thread_id; } os << ":\n"; } void print_trace(std::ostream& os, const ResolvedTrace& trace, Colorize& colorize) { os << "#" << std::left << std::setw(2) << trace.idx << std::right; bool already_indented = true; if (!trace.source.filename.size() || object) { os << " Object \"" << trace.object_filename << "\", at " << trace.addr << ", in " << trace.object_function << "\n"; already_indented = false; } for (size_t inliner_idx = trace.inliners.size(); inliner_idx > 0; --inliner_idx) { if (!already_indented) { os << " "; } const ResolvedTrace::SourceLoc& inliner_loc = trace.inliners[inliner_idx-1]; print_source_loc(os, " | ", inliner_loc); if (snippet) { print_snippet(os, " | ", inliner_loc, colorize, Color::purple, inliner_context_size); } already_indented = false; } if (trace.source.filename.size()) { if (!already_indented) { os << " "; } print_source_loc(os, " ", trace.source, trace.addr); if (snippet) { print_snippet(os, " ", trace.source, colorize, Color::yellow, trace_context_size); } } } void print_snippet(std::ostream& os, const char* indent, const ResolvedTrace::SourceLoc& source_loc, Colorize& colorize, Color::type color_code, int context_size) { using namespace std; typedef SnippetFactory::lines_t lines_t; lines_t lines = _snippets.get_snippet(source_loc.filename, source_loc.line, static_cast(context_size)); for (lines_t::const_iterator it = lines.begin(); it != lines.end(); ++it) { if (it-> first == source_loc.line) { colorize.set_color(color_code); os << indent << ">"; } else { os << indent << " "; } os << std::setw(4) << it->first << ": " << it->second << "\n"; if (it-> first == source_loc.line) { colorize.set_color(Color::reset); } } } void print_source_loc(std::ostream& os, const char* indent, const ResolvedTrace::SourceLoc& source_loc, void* addr=nullptr) { os << indent << "Source \"" << source_loc.filename << "\", line " << source_loc.line << ", in " << source_loc.function; if (address && addr != nullptr) { os << " [" << addr << "]"; } os << "\n"; } }; /*************** SIGNALS HANDLING ***************/ #if defined(BACKWARD_SYSTEM_LINUX) || defined(BACKWARD_SYSTEM_DARWIN) class SignalHandling { public: static std::vector make_default_signals() { const int posix_signals[] = { // Signals for which the default action is "Core". SIGABRT, // Abort signal from abort(3) SIGBUS, // Bus error (bad memory access) SIGFPE, // Floating point exception SIGILL, // Illegal Instruction SIGIOT, // IOT trap. A synonym for SIGABRT SIGQUIT, // Quit from keyboard SIGSEGV, // Invalid memory reference SIGSYS, // Bad argument to routine (SVr4) SIGTRAP, // Trace/breakpoint trap SIGXCPU, // CPU time limit exceeded (4.2BSD) SIGXFSZ, // File size limit exceeded (4.2BSD) #if defined(BACKWARD_SYSTEM_DARWIN) SIGEMT, // emulation instruction executed #endif }; return std::vector(posix_signals, posix_signals + sizeof posix_signals / sizeof posix_signals[0] ); } SignalHandling(const std::vector& posix_signals = make_default_signals()): _loaded(false) { bool success = true; const size_t stack_size = 1024 * 1024 * 8; _stack_content.reset(static_cast(malloc(stack_size))); if (_stack_content) { stack_t ss; ss.ss_sp = _stack_content.get(); ss.ss_size = stack_size; ss.ss_flags = 0; if (sigaltstack(&ss, nullptr) < 0) { success = false; } } else { success = false; } for (size_t i = 0; i < posix_signals.size(); ++i) { struct sigaction action; memset(&action, 0, sizeof action); action.sa_flags = static_cast(SA_SIGINFO | SA_ONSTACK | SA_NODEFER | SA_RESETHAND); sigfillset(&action.sa_mask); sigdelset(&action.sa_mask, posix_signals[i]); #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdisabled-macro-expansion" action.sa_sigaction = &sig_handler; #pragma clang diagnostic pop int r = sigaction(posix_signals[i], &action, nullptr); if (r < 0) success = false; } _loaded = success; } bool loaded() const { return _loaded; } static void handleSignal(int, siginfo_t* info, void* _ctx) { ucontext_t *uctx = static_cast(_ctx); StackTrace st; void* error_addr = nullptr; #ifdef REG_RIP // x86_64 error_addr = reinterpret_cast(uctx->uc_mcontext.gregs[REG_RIP]); #elif defined(REG_EIP) // x86_32 error_addr = reinterpret_cast(uctx->uc_mcontext.gregs[REG_EIP]); #elif defined(__arm__) error_addr = reinterpret_cast(uctx->uc_mcontext.arm_pc); #elif defined(__aarch64__) error_addr = reinterpret_cast(uctx->uc_mcontext.pc); #elif defined(__ppc__) || defined(__powerpc) || defined(__powerpc__) || defined(__POWERPC__) error_addr = reinterpret_cast(uctx->uc_mcontext.regs->nip); #elif defined(__s390x__) error_addr = reinterpret_cast(uctx->uc_mcontext.psw.addr); #elif defined(__APPLE__) && defined(__x86_64__) error_addr = reinterpret_cast(uctx->uc_mcontext->__ss.__rip); #elif defined(__APPLE__) error_addr = reinterpret_cast(uctx->uc_mcontext->__ss.__eip); #else # warning ":/ sorry, ain't know no nothing none not of your architecture!" #endif if (error_addr) { st.load_from(error_addr, 32); } else { st.load_here(32); } Printer printer; printer.address = true; printer.print(st, stderr); #if _XOPEN_SOURCE >= 700 || _POSIX_C_SOURCE >= 200809L psiginfo(info, nullptr); #else (void)info; #endif } private: details::handle _stack_content; bool _loaded; #ifdef __GNUC__ __attribute__((noreturn)) #endif static void sig_handler(int signo, siginfo_t* info, void* _ctx) { handleSignal(signo, info, _ctx); // try to forward the signal. raise(info->si_signo); // terminate the process immediately. puts("watf? exit"); _exit(EXIT_FAILURE); } }; #endif // BACKWARD_SYSTEM_LINUX || BACKWARD_SYSTEM_DARWIN #ifdef BACKWARD_SYSTEM_UNKNOWN class SignalHandling { public: SignalHandling(const std::vector& = std::vector()) {} bool init() { return false; } bool loaded() { return false; } }; #endif // BACKWARD_SYSTEM_UNKNOWN } // namespace backward #endif /* H_GUARD */ anbox-0.0~git20191115/external/backward-cpp/builds.sh000077500000000000000000000025171356361734700222330ustar00rootroot00000000000000#!/bin/bash COMPILERS_CXX98=`cat</dev/null ( cd "$builddir" cmake -DCMAKE_BUILD_TYPE=$buildtype -DBACKWARD_TESTS=ON .. ) } function build() { local builddir=$1 shift make -C "$builddir" $@ } function dotest() { local builddir=$1 shift make -C "$builddir" test $@ return 0 } function do_action() { local lang=$1 local action=$2 shift 2 for compiler in $COMPILERS; do local builddir="build_${lang}_${compiler}" if [[ $action == "cmake" ]]; then buildtype=$1 mkbuild $compiler $lang "$buildtype" "$builddir" [[ $? != 0 ]] && exit elif [[ $action == "make" ]]; then build "$builddir" $@ [[ $? != 0 ]] && exit elif [[ $action == "test" ]]; then dotest "$builddir" $@ [[ $? != 0 ]] && exit elif [[ $action == "clean" ]]; then rm -r "$builddir" else echo "usage: $0 cmake [debug|release|relwithdbg]|make|test|clean" exit 255 fi done } COMPILERS=$COMPILERS_CXX98 do_action c++98 $@ COMPILERS=$COMPILERS_CXX11 do_action c++11 $@ anbox-0.0~git20191115/external/backward-cpp/conanfile.py000066400000000000000000000027451356361734700227250ustar00rootroot00000000000000from conans import ConanFile, CMake import os class BackwardCpp(ConanFile): settings = 'os', 'compiler', 'build_type', 'arch' name = 'backward' url = 'https://github.com/bombela/backward-cpp' license = 'MIT' version = '1.3.0' options = { 'stack_walking_unwind': [True, False], 'stack_walking_backtrace': [True, False], 'stack_details_auto_detect': [True, False], 'stack_details_backtrace_symbol': [True, False], 'stack_details_dw': [True, False], 'stack_details_bfd': [True, False], 'shared': [True, False] } default_options = ( 'stack_walking_unwind=True', 'stack_walking_backtrace=False', 'stack_details_auto_detect=True', 'stack_details_backtrace_symbol=False', 'stack_details_dw=False', 'stack_details_bfd=False', 'shared=False' ) exports = 'backward.cpp', 'backward.hpp', 'test/*', 'CMakeLists.txt', 'BackwardConfig.cmake' generators = 'cmake' def build(self): cmake = CMake(self) cmake.configure(defs={'BACKWARD_' + name.upper(): value for name, value in self.options.values.as_list()}) cmake.build() def package(self): self.copy('backward.hpp', os.path.join('include', 'backward')) self.copy('*.a', dst='lib') self.copy('*.so', dst='lib') self.copy('*.lib', dst='lib') self.copy('*.dll', dst='lib') def package_info(self): self.cpp_info.libs = ['backward'] anbox-0.0~git20191115/external/backward-cpp/doc/000077500000000000000000000000001356361734700211525ustar00rootroot00000000000000anbox-0.0~git20191115/external/backward-cpp/doc/nice.png000066400000000000000000001177101356361734700226050ustar00rootroot00000000000000PNG  IHDRe)sRGBbKGD pHYs  tIME4 j IDATxyXU?.D@P L},4M,KnYf▦),4RT,Ͳ\s4LE\p}_+"yd;3{=3gFj׶_@ :ڶD% @ {\,"xvpYoykĠBBB YLZ2ʧ9"깢'@ !}Gɗ}fC:x:-+g}C /(G;%YBL'p@ ͓We,/WWnhiȂ VSTv >Wta@ "`TFG)+y Ng; 4K^g~CD3Y $P.Mv=gŬf}|7$K+9u7bLH1x{ b~v&n!ޠhט7:{I-ndn N, PbєZwHz2cOu6G"^2'mآMԞ@&٠ F ZC:6ͪm\Ȗ+ *J_jtXCZZ.RXWYW1E4GOgoJQ"ɮ3'& /|jcIφcbkѿţ/Q[|yYp(")j͌qX8p@ "`4 6-G+xX8V4rC6iu66  1~NLip3/2ɖO{Y0i; /X4 Zc~s(XV7`:cϰzR,yןQӉXnf(MCx^q15Sه)cg9KΐfFVNX!٠Bgc bb֟'̃3eX,#,r7AMz̜LB/SHF7:=S}"#aӠ}t>`P2ʧYe &⚋cj+J+sCFh@ *+RdnVxBrȩTgdlb<G]4%Fȡ8@'ܴ"Y7·_dשG'h=jtPclK$_?3ޭYz?gIt_" u B\"W#Xx5I|{`EN ɚz<Mߦ]9f#G'gIG:dE&m#aUeE:v$ Z)ׯ6{IGыNOslv&տoWȾۗG$ Υ %֯46a$_T[?euX"^@ _2EL\ +4i)I |W c}eʖ,(VOf5=hܴ eԞ]9;W0x <.bPb3 l>#b %gJ>%o~͛B'/kWxQy&ֿnh0>@u]C"dUS}z1DTW @PqcnHnRw-ce\Hn!h,o57}J4Iru0+9u^>و,ܑP|8C k[ӣ8g3}Ĭm΄4PK,նxbb2 b_d|X;`o>??թ1:6x.單, #$mqxcf[n+_~'YxkOo!U|(@_ #r.qgӰo֒Zjg8*Z.M{9]qJnn쌕x~.$d4^-3l\x oS5<Ѿ5n;~+S@\p|qovīNMw30f]! a֙/9ݒdW&>3tfO\~yDq@5rI Mpfm3lXg) lFBU~T?E45:aod1XתMڵp$@ AeX+?Vʮ?"w, \9T,[?!$*8|?S'[vQYCfYY?{˙NQg 1xF*Leϸ&ۘ 1dft0Y/d͐l2ؾ%gPP)1o1 #TwFn1|M`^nV/!_-}_8|{!SgT)6!gp܌ߙ6k"@ HڶD#<.dG ~|)@ vm[V%?ƲN'o⎝:њ{#@ @ *(EhAw\,=QF @ IF&wL}; EƋ^> سq;yBU@ 0 O1 \% @ xjЂ@ @ nCVWQKE'=t4xk L]c&BHbҖ~Y$hq;>8{Q 0|! !C;޶ns(_OeŬTEϤqHV=3*qrO0g}ID/kDĦX @_5&˰3gW3:VAM"zG)bUA˜//aPZPD ҢQ\al=ߧ EZ]_c|?ꐢ\X%U~#|P!Cf6.8Pګ;CM[ԹȒ$NeOl8 >^ſ%Oh2eV"otVl5*ց}f`gq27rf'kq(fmMZ'2o9QG[I˳l|otzp!OFy{*R6ndيm\)Hy҈wy;U$='غh Lԟ%7~ʠ_U5W#7ڕ^sW|c}Y+[6$.WŒr1?,@PaQhԚl26<Hrc`yeq+ "N'*QG}ճ'b3N̔MĚ8E+Uͳ39yjK_plH_Ƨ.Ϊi0x*i 8-wH0e Q,:,5Rj)qJ)~Z#zXV&TG3. #W*EI賤7d]/Dz̜Lh1)@PqF y|WHnvH.V }H>1f3;F=zWmy佑2CU;nј~(Yǖ$0xWX7 604A|{ba'tNqj0+PIc=gUe}>zYF*SG@cAe팓Y:q95LN%4޸TQs<=H9s,EeQ~}y 5m]Ar;5 4ZP.KkcOJQݳ>b\@WS~~~ )ύ 1 wW {U.%k*VV7@ *Sk4St[qL>Ω[8R%7Z7vLV#,WH(t~54HufKNW@\p|qovīNMwՌװPU^}ϗČO9*rI6ɢ;iA '7ZtgظxB~9/Y: .H  s]gjxvdFŹ\31>T fohMzz|P)KQ?F^Sb9lOV*fJOze>2;&>3tfO\ @ T7W9iFFѻ\ şyˈј|[?jss[Y/d͐l2ؾ%g2،!C0[Uԅɜ}-MN9`<a&-M| +j/r&p:sYBaz n"4u>Mq)xSلߍx.ŠboOP4n),s&%*9kmOY>e< ~%g~]&0 pi#fJ_zE>ym5v$@ hj+Vڨ@HVyo0RfOpeRPyкc·NXLY(D 3ba<.pĶ3fB.Xߎ3@ *={*v E*m_B@ Q@ @ @S@ @ xRQQ @ 5OHv,x`ч9x+\,"xvaL !$$-|j^C^8?3{ O?@ g7-f6UShn`Iiׯ5}ƢTHpY! 2%$65Nڇe~ _ !d7|:39Wz@H|զ寲,\w-%`XG\%7gG !$$ߤCy7P%o@ hT5w)9zt7d^z2+H,S7ԣϘL'.͐(# ۭoQ>N K2 n 54BrELF\ض08cq|dʄKT@5Șιlb"G ޼9IiC + W"]#B14;l$Ǧ6bs+W ix^ѝng ۷@ B}ơO/+Y©s-D-ŒX.]"F4/#j4~=H _ pHh3rNw:[or$Z?'b/ T^@o3۳8H95K8x}(a՝!{Ҧ-DN dIaҝ_c|?9quH?.,HKT}ΗvA>Mh\MO΃Fkmܩ"Ɍ=E ]`Z X6&=pi#&X|SU.Mv=gŬf@1E4GOgoJQ"ɮ3'& 86wAkH'fY ٦5N;v$=ڣZn?d Fe 8Eꅭ*ٶx%_(fe離536a%K/h՝kMd˱h ۟;3y 3b2ƣG }p4<OZ'yłnxȧ S#pNݚ*CqrFٶ=^R]S>cY@ 0rØЍ+;3:wvA`W-qլ`<]Kc$3kpo6b9gLrBgOKy|Qm=m,+Gw#LUMN>:[|N'*Y~ou Ideʍzf7ώg2Z;yB?[ߩyqx+w^rT;^|S{UKrI˽9cM#K,oPx,#ɒ5x! v{ؕd,yiZ]EA鸤-~&6N{x&nd32z+iRƇ?X6ux=WLn7qEN DRdHͩGj2YG6rF9?=b # BxSlE:I޿!DoȖF8iˆ,,dM#6shFDd练Rvc$聜3R /Y(+S/u_<|qt|<\tvXå|[:LY`U O!O-Ր'T0KaA8;|8I">r>'g5ft1cmy%/erl,L `ڡG0sA(rjٻ@ hna 3INI]t@MrbW߀G|s@q$/ٵ#.~Otae  ] Բ@Rɯ5XI ]nA$ jֱ%+4Iyp$Է M5n,J=H9s,p:QAt>fG/2CU;nl~m9Eu)ۙG$ w!'2d}io(Q~U& j맬4͘FONjȾeÙuKؿ ^oVYŕ׸̻=ÿH6䏁~Dja"mP}W#&wԢ|K0 IDATn<Eq?@ %5yZX?zucw8V|]Cn焍x!7tn.:[t䐚SR`dpX*v$JN6Ha-x^@nD Gq&4jҖS{vxfʣY,,ܰ7N^ք;R8sot }^Wҿ/YգԱx^G!&--dcE? h KI1? Z²lsצxVuuKz8aZ\κ Qˆ[p2O~aKe׌Wh;`=Ѭ!^eٖhxO A% 5jTjNc1eLOW29}Fu5fgu2*7 \γN甩T] .qcO}m',0fT#)A}y 5m}!˕iX{51YRTce=knq8=WO=Y=#fͥnt% ԘF`<f'rBdvD+ݩB hЖn O&hu`f Wߔ% zM?m ըfg*2Uj?rv <бxRCzuL=ѯcsfm3ojO%X̸_|M^7ӧ ; 3w߿xe4b̰M>@ ЀQFVk@. ZUH8t,k<\&&Y(#U}AoRϫ!{ǸnUc?qa9j9S~Ci\F/1䍺dL=ן3tfO\8Mmo[CBjɧ\31>T fohMzێdx/<8{ A 7fYYWH(t~54HufKN:9lOV*f&͡f=rf4G+BdOY2{f \;f}z7͜_YMIs989y?s,0=?7ݘocvĐ!ѭ*d÷oL>ͭyjhٗ); Q/Re \`J$Zn փ>0eGpD+\Sb߅z3eղ5CHc~wM7y]yZAT~1o3['k]Oy?@  Z ^*SI\ŗW^r7^+*zHT<}]3>%.q_^*%U¼ f<չ=5aNmeEoH*F؂s ag}@ Tc5x4tdj9ٶd#;3$󏢙SykЃh@ Q#86cģGƋ^~pıg6@ F0 *1 \% @ T n!@ mՓS[}̂^(ͩ}倄{w&- .4(Cq^C^8 + #G (tGm\s>?[~u'_2ߛo Q.ޥ_E_!|"sKwȡ1/fCYʷ'<6sX>Ư#^&m".s!ٴc沾%"}xT;7NM{gݞuœ|MW [zGU7Ðɞ?c?ihjGJ1gEuTP&uѼ ;)W嚿jjGf/7 'b^>I4ЏQ_3ã3ѿ5PuTua2gvU3қr)SWZȀo4NF`CqolDtPXj"7p*o5"h 3f(S1vIK2ذ+eq11sDys?.3žfH9Ig1`SDž[*+U$8M|z@HɿzڧxmH1k$4߸|?PRzETWo@EphSƋJp\?v3E;I&yQD Dmjֆs4@B؞s݂m|0#E8C$~I6=3;Y4C^2'mآMԞ@&5ùW2p/LsyY6&=pi#&x{%鯤%ƌ>nLbƯ3/z_e%ͯNݚ*CqrFٶ=^R]Dה|3tMK0De֗0׮ 7$&*mg9>H~3 LU~cF3>&LB\6" +}޿&0nt4]^kNIOf .Z_>vOQE,[9r|86wAkH'fY 22/sl9M!q|sgwyZ?ᒙfr%*f[XySWa2F.X?w䔬_ژcGҳ=ؿ-E@]Y9$gvN@.l|%;%HBQHl @E?]<ɔZAp [U'WOcɶ|^壭Y6oF7:Q=GBVۏ@P_k_0 yZ|?#hd| ˬX4v2x)"`$3oK_IYa-ѭM|ÁZͿ2qD-j!!Ь3Ya-ʃ8ӆV}*|Gc[Ӿ1)CoejqlSoq|ٚbii(WQA|}zU!/FYR4%ro6ک1rtɒ2a,OØ5Ca%}Q1e1ǽ+9ҟ)a)IVnԫOӓ|"9^ԲJi6^ q: ~1B"I???ɩ<h;}zV9Ȃc,ZuyH* *hCuqL+$c׏)Uxߣ"Yrش7ry0cI.i7%3䦑%v7.<$5~ v_OK֍eW+u* Zϥhpč,Xq$\:ʯFtA9Up3DZ(,𥌟= dzls}9ݻ|S,oK10~ŚE>9c+fE? dȠr܁ ?\M/v;`+-ud.a,˒OnD Gq&4jҖS{vxfZ heF׀ypgYei!Q-cn*XbgE,’lRn K_-5;vV,7|%-Y~dو75̴a?`cgJ,{9lbf?W7v͹~+"MMo\Np!>s8vޥH6Y߅ss_=WXfNzį,\i[˹ Μ9~PCH-N!C0[Uԅɜ}-oߘ|[?jSjhٗ); "āۯ7Quj.W_E)ƿ?Ysl\3yEDXݏѳ{aF!u\/ #< v7-g11<~_ryJ?Ϭ>DHMonɫ4/cGɖqz`@%ӴY(,s&%*9kRрM&n; tVsh-}{e)'̱6,E:9_V-; Y3$0owm"{LK?)#L_ _n@vBVT~1o3['kknzAy,_hB \dے/XZ> !`j4{O;3(+j D'@ x"qCnEy@A{6n'2OJ ( ʈXA%@ @*@ @ ܋''`T;`rV<\ÜyRCjjt̢>.h*y=t,G?J{w&- . ih0o(_ dK j/0k[*;UERu\0,:sVm!d÷ ]3z ?s(_O |q3K,]{s9ťbF\ic IDAT;=~%*ldoXBH j#8O#ߣ n 1-֑6C?u!ODՎ> Bk݇4ubM5wl}bCB d7ihKvO.~v-#`HWUY{(bS's0s!8y$aL;͎o!&)ɱ)&zV(fO!P>c2upc$4]2# *wZԥg%)ߓ6mpgگ3}z/o.gM۸bB'>ʭ} g^kIL/Lfkɯ_+hF[[7SG]Yy~'wlŘxJ~I޷m$l21_vgոAY0{/&~<-lȏçK7q"Bxm,^l nVLC_ftЃxX9 +7s,Zh0qcнLĊ|EC*qy5/ u:[$иS0=|y}Y*v<; 1 Wcn{q"!=A(&vVClmtLjD|m.cUٗ&e ~>O/]|v%^cܝ6?O?;.2B.~&۟cEqKj akb*)r3oٷ#Yot}+^e[& ůjWqZ^+ZKDc3g4L;0|DsrZjY`K$kdW l}x|«<ӽ”^:y[$Zҿ,SOKz@Aߥ\/FbڶZo hݩD~,(wm Ϊ14 h4e,(JB .'rfUY//%'TE=LD6{~ghi,D6Jwe/8?Hl,3:H eŰx}x,5C}׽ HZgŖm|Y\)z16A'[fى~sbMG b+N4Qp\4\Ss.o.`jap'meRH#__Oc[Z?7Z&= M}59g-b#:_w )_s~$WdžBȬj E%9YDD]Y9ƓٻZVBV>!Wu4rLyIq(fo Cd۶lX]˼14uv.QJ^)icilw##ӟ`xғOsïO~MQ{i9j?M&#-w_oVz,Y ǝ/ QWGJ3qER7"^6~o\l9|ړ?ƏnݼH+7[ISV4g∎ɡ4/.&^ *g+ȓlV>#Бz˩d绝 h?J]\ fag_ɴOdFt>cFKHƹ6ye7Zlhօ rUA~}s=Wsl.& ho؆HL#V6EVg#SQ,u^+ƻ_ (;` 䭕3yQe-/,)P2E$e@B,ɴfh{ geFci.%d{ûԶNRBn⬌Jc`*ϾaUtV"LwtwK"- r%|R˔,l2v.cHR u -7$r nPQz*ߖ0-Z-|=="d,g]O:/=39ׇg8ʁ+Qd=O<>S[4Jc&W"2}^-&Dݾ}%R$FutRBV] r lbtܑ{0zz{y20)Uħ:/Dl|%E֖+\٦5ӉlvÎbrn k\Zj% -M<+OTw or -_WS<;{ߢfGFEZz`>Y&L ~Kmzm ȈSCtdlO8z5SyS+bRػlՙTZ8c$9ҷq偂*YD%5.Td#$hȾD>}Ub)WbhЖ&&DA^N]Wi*J#Cfv zdJtG|ۧIo%?&=F4ho?d~ hqu֯Yп,/*lPx8IӡO|=zrK'qw69IyQgalq8ʊ{<{9 L2࿹dr>we~4!<R=hltQW5g?꯭JWmO_)ſw!~kji 7*mÜu+eƮ:ۣn#'m+Ww4n]Em+jΓqcͰaZVu AR񢰠ZuɄI/ IQ~g* ;|}+P*J+寙}w(Qԑ[_ҏ!>W8v&, "j8 }Mtg^b,ȏG?uŧOp)nVF1^  ?WXtJ(Ow>o)Бw7ݟe}hG 5V7wȩ <{+-:jSg{6j+e߉=7~ׇѣS~'YWH#O>SK#?ivu'#MEWH׻ xq#Gn[w/$ه9~gfB cy`ZZL%jxsRN%Wu.,zyZςhph={C5ؓUь}ޝ6Vs&_U^+KIKin#v~AU~ٌ}OV1SmW*J?1{+n>]ծWQXK mS]yC) (rլ^4LhOOǓӼ` $u$Ӎb˟޶VC}?I?Vw@1'>]6Oq=f/ Cһ#mZw﨩LǶFQ_)kh_7+PPȓ@blG4fy\x]O2액ڪ@å_0oQrM @sի {)&"w g51߳t!yR4^dkbd \`ܸ> ?oMqG7B_[ m^`3XLńW2)!F>4"β׈9YjZ'Yt^K,_-mɢ8޺O>[})/.eøb ң,}.EJ7z$o93ުCMlPIH̕גI {r||[IJNyH*\$8dQ-g]a/xKg_}仈~~:ˊY7rLTޣh'i:~| O16Payɵ&z>Ȝ}K'3_-!Uy||o1FLY7;Tb! G7p{-ߒ-~OBA5t0)k>Rw2P\KwwZF0[~~o+JDD.}> ٓS(8nnxu2'ؼ=|„ z؈6wH.l{)PG (eQpٷ3(P@U@P@ (P@ FAEdejA|'S?jiW/`r5o߶S7oc۶ml۶͵X44{z[ƣAx(RTCĂjcOvfwW`[ fڊ _XJ;o5O)bli ַ$>PSaN_D=SxbW!v~etvUYg-7lZE$ƪO_ZKLe)D$Ts^`y7^ 珒V3./45UwC1Mwdm KOs!=zxoql7jJZ e^<ڛŎγ`z3R{eo람OƔf.q ۴#tz]|nPҗcQFuf״[=v8tcsh݌@<$`[_$ZO:ؙѳ'_; w`ϨY% fmla/0kl*ל:! DVc< 4-ܮ?`,s Ŵs>42 G5u?`GD}nPݳP.͞JXR4@3iyIryKs%.`soLƨ~͉{ϑ_|uv{XęZ4-&OI't^^vAwb<35%.R.%~1i?w;2b$&3?5eq:-#G6Bױ`Gbߢ´rſnD ;`Ms |M444bK=Ceߔ.!26Szt0^ [8s*)O~ǘٻ)}pkX~ל ;3s ?wg<pWB7¶{:u6ߟH<ٝUzc4'+g4`z!?f.ĉ슑/ g Aam$>6̱k 4 ̸C ui&glb{>â!xV~smu>;sSq`z G0TxwcA; +>kdW l}x|«<ӽ”^:y[$Zҿ,SOKz@Aߥ\/ƀ?mЂ?LSI]XQ@U&,| Mci9h. `+8YPȕ\2O̪(k _xq[_J~#O8+6m{8l14% YOm7Կ Y}tѲ[6șTĆ폲bX_D^0+>+?WG4)$ř,ߵD}WÉOjlRr ULh' IDAT$ݺSW\\!%%dSZV V'?⛼&!Rmiڦ<݅ԝ1V".I);ͶƓPVYe_.z/׾o࣡x gNbm5 (6CG bya%rDs=hzNιír^I!!|}h[Z?7Z&= M}59g-b#:_w )_s~$WdžBȬj E%9YDD]Y9Ɠٻ>xݡL_TyaT;;ڎv)|9;70Y_זּS<̶ {o/& ŏ|ڧI_ ͸3gL3F1s|{۴VZEv}SM%*{ڌ].jy53)-8`v+rUп]-/boRʙ,ƻ_-iO[7/ʘ1\(_뎳JnymG%o|VEßYk+y%㫤k z&qL4;_O"~[O-͏It2?7/ e ,/'jԶ}{oZ6[c)q Xp:AMhđnj=9!~ *˙?#aDt"#BB g]*OpglftyēdVBg'ujLι  * *L7Qg@ݤN˩q?M۶mtY]w`⓶)O[#8wB4u gKoeT vWz&cilw'=;7Jq:K'4jOp?-W㧳dp`VAO%r!5|$r1MaYT)+ycή*Wvm3ť#rɱ'ص'k5A9y.vW6o>bƓwſWÏO _~Vu6ڴ)]RXxrUq R`FCqƻ{{s|erudoߚԑӂQ~QE Fc)Xw2t,ŏf6H M[:Qss{DG?$2tGPKΩ|DYa9+T<':=EJAM 1"΀̀(AcJkE̷J|Rkt2 CJY*c>sn>R=6=ZԈ7H2a]ZEP!d-'ʲL u)yv}!m6GUMS# ?d/FJc6ܾ9M,~ϨsKY=ϠJg 7)܆$rU]*+(?ȩ2}7>o"KTt N:;r|kߖ)(L>Dted*muF$7oY% RGQTmݻ1ȯcjL 3f3$oƴG*BeO99bh!ǎ'lhsGrj,O锩z ?v檗PG$^o%>aހ>4KM?5/F|'=45-7Fqy-F¾-?_#75U'ue-t }A-6nE&m[+gP Elmb^}kϚL弳-2Z4R-N7z[b8j_ `LZE}MAٗ9~J鎎Ix o~dg}j%T27 ۶1˘1?B=v]gvpo*"\{#T޶h$%LAo1j mO@HyvY&KY12 α}LaǙ}+Qd=O<>S[4Jc&W"2}^-&TǓ]*MjTH'U^;*d u/g$~1:0:w}5`޾ ucNKQ4ߥ~kI54bp)"rt"ݰV9/h*}i be *.<][9|HdΞli23eT $Ӛ㟢%\f4Q_(]PV'&G_G5vs7׽ØxEMCv+go_5l\~"K۟2id3 6Y1*;ǧ'3g{ ѫ+ZeKDCg r9I*soU8.Kj\|=WIȑ/j@FU+y4 hKK+ QPS)mb nMa5Ʒ]~82R(z)~dg}j+TYhcDs?d~ hqu֯Yп,/*lPx8IӡO|=zrK'qw69IyQgalq8ʊ{<{9 L2࿹dr>we~4!<R=hltQW5g?꯭JWmO_)ſw!~kji 7*mÜu+eƮ:ۣn#'m+W'4n]Em+jΓqcͰaZVu AR񢰠Zud$Xaw]I $~ JkS\S9h^]Of_tn쮓̾ޘO_q=Wd jӢi/W⯮oCNFgZl.b ˜@ԑ[_ҏ!>W8v&, "hcst'Ө/xb"?3n?GMˠVF1^  ?WH[,:ÎEt~%p7 fQXHܻ2>4uãEGL 6\G:xboE[QMpLpcFR`e;QBߓ0zt{O$ i~g}j)Tr䯘L| #ޮ89Ti*Bލ6hs{o1?"v}ǿCo~i$6w>#<6SVkSgr.QKǛr*/ v)gע}D ݇?%>hOvhN7ԓ?gh(O7:-rzJZ !i[ z:'HZ5fGg<þxteؘ>4>$S?kOc?&t\3u Cһ#mZw﨩LǶFFӬ1Z&޾4V@h܉1/_=Hv<2u5&v[jh_wmaOf_fy󿺐_ʥ)^^޴=@m20HϗuqOƯM3j\Z`zOܨʓ@blG4fy|6ӣ-bҼ{~Ĕ͞(pn|>zo/`4$_Ds?3,&?{.?$TJqًzCB@Lo^_i5aAq171j}6~7een/Bk544LۜLf0? 0eSB|iEn?r>O~X|[LyEqv|0S^\ʆqGw1<0X~]2nHrD%9fUÛؠN7+%ɳ7x=3ē8TNIqQɔ[8s9j -^f(ϾW1T@OG{zxY~7KWF{-?$^Ǐ2 r#P<>:2F/'f?['pA[?\j ʋ㫔u4b*Ϻ١ I8ocⷤ}K_/_?keM#k ?,L%q32B(|]-:̖ʅl_sCyt6ǔ" 08~ۯ l96/`҂X';WVü[O)L< d+CqU>KG`2'ELOz>?Tw}w$s{a_Sg lbcd.F H<b 7r (P@oP (Cc#! TlQ QG 0j(P>}>SxP؏ (PPw(P@ (P@?|v# S>#}jB44{z z7׶S7oc۶ml۶͵OX<Ͽ+POz|[ھ|8E|A(P`DE3/v彏bGQ,`j(G4VvWC6-?UF"lcէ{/މ@"G\ZXpoֽ%mf/\_fi k1-$k!z]>ǘ6[R u _}HI (qB{2o'_#g:}G;n,3dcdѺ}$ϥdÑɮNj-bo_nTʙχ2gk:AwlcCg7gj2KdːNP-8HgLimj^~^bw8'vHK {AG~yMU~w)Ƨ{ UaTlvMK<Гo M?NWR@u3=8XW nYXm);Qm9IDY% fmla/0kl*ל:)QA_6<1ȃ !p/ n$725|u 'pygLٓ/NSon-7C]'֯M1 eZ^3[&Qx z•~#Q `;GrV1{gFg)@u,ؑXQh0gH[۷XLԪḭSִ?DS J3)0i]:2ZJ(AɠjyI,3 PYJQ?ZWNy)O~ǘٻ)B 5nmOSva'yF¨4 \ әT&F79Y qďӻ 1{t&NdW̤i``<bUC_ftЃxX9 +7s,ZXh0qcнLĊ|EC*Q:]ӸS0=|Yq_K| ><>U@aiv/[ŽD%`]@Z&O>OJTDy W d5jD3eiIs{3w(CYwш{1LNfhrƱ(j܁'2 #r[:\kEk(~pRpfl>ؓ"I->lՏ Yu`·4~ Ѱ # ^y48OvN~1v8/r- RH܌Rf,Dqzq>иȄhNB\܍>b8Tx8n?pTpnM<{+.W c\~#[''(!/k̗K#؋ y?B1IGzbKۧڦ<݅ԝ1TyX#8tx n0ZϢ +o[YɂWgIVُ˯L&\"ת+M4LPףwN2$'a)LF'meRVX_e$~naYMrx 8צ<[R 9>ɳs7!;kBݖ@IN:єGVN1 45 nG\,AJ>I5xmX=cl/͐Y DcxfO/⣮UϞwoMɬKw%yaaN.$(' @c~=c۾r [G#1-g4 |J(3ǧ0iy2r[ q%SjA5Ez{-*7w޽ QeϿXYj0dQlc~{oZ6r@XJBhn/x^S&t'&>F*^u⭺zv_䜺X9!WSlTNߜ&Wn iծ# 6>UgU;:ʥh;v۝ῳpNlM5.UQHJ*8`B.%^(y.wTmRd :`ocN~./,dџyuD~s+m؊\XG)v8x_*G)a_WxS(4jOp?-_O1g<챋T-/s;o?X9qu1MGVFtͪ l>p GqtB̊L\&9"dg$rZHщo5 i8sCqDQKHdGȧQ6t$~ueK |=(k9*8g@{oDb)$meS3!#g?9E(9ω 8<$e>2eb_ը_USB\g`joo͡?\Ԑkl+~̌1zb>ʵE¯x|L~կԸgxrfƘ2@X[IDATYǿbݾ$A3Yн;S1H[o:Y1=nS ]Oli6m>ͻ>dDGEyg~9u2Q?ƧƏnt.#=j_DW-gDVunP+og d+}(PpۀQ|oLcܲr"67>ɎM@^&4w@q񣙍3m-%6R`CӖNŜ#!(89'̕?{(?:J,Y܋S1;y F 3 +WEteb%t$%Q۪S * ҭ3 ̿NC87v&~) :ǐm.F>wd`Tg}Tw9,R|dX-+8$A_(*4ȫOG6uMHΑż@ ޫU' ٗ9~j-Klbtܑ{0zz{y2;s"k(O<̟e3ЈhCZbaBPm;c ~G1c~$)zf6Eф&LFS'b(w)mI/}kϚL弳-FV:A=o*ͥ;m\3Hm7(&dO ?G@U-Q Wgo^ޱ+6W{Z^Ƣ 2 !dZzSڽ3G9"Q w>qky|̽ W'q;sDNȩ_v0> ]/9di'.ʰ Jie)Q(PpdetdlO8z5SyS+bRػlm 9I*so{U8.K~j\|=Vn~MB!mTu!r%6Fmi+zIn.U7iq-%NE0R`{Wзtqf~$퓬IMg_ dr\qvB#K/Cg ޝ^Hn슫=ޙUU Ȩ "!*fy-͒O-Z*ob7Ӝrh2DN]2M4'PA@D&s (ZjKVTOI;{bc{p}5\!h]%k]I1\Dvz֤>Mu+u&y^x b>៳Sׇ^I ^%9)v\DVe;CxC+5?IP7E!m kג-_YI.V+󨠶ngmzzz[>5},kGn4j 1g=*{*_jڿ/fWD>-[g{ue0nD.?8ΤCn_$jV5vMH :t@ )|ΙV 8A+\Nr鎍z!e/NIfIlg|ή׺wlG¯2 'H/UOv6- Sr|@ (N$NCvfKeFϺ38w5G*_q՛4z1'^A4)QUpUO)2Eui3x8Xs;yo#`9.e$FR~b~TQW:[zse?b摓z[xҿc4?ݹu|Z!}b!cb7q#=L591ffs2} L].٩Ļc y\8m.Yœ-w0#9{? |/S3xB UTEeoꋽ qз\u 7˧_͐е|ΖMJt>/9* H˒É2wWOU6| 9a/ƒ|oNr/㪇޾dplw4p؜Lʝ>@]6s+Aa]LF>ʂƥON̛o\-Ob+DT}ag|DAGXcV|&x*ɴE+~֒Е"P6 UP־>ݺP?q9MjKKRv~êLVvB߰ !\ؙ(@!Erܾ*]c3[έb9@ iúPy -dp ?K?eLĪ @ @wdúZ;$ǐq(4uZ!E[B*@ ȿП@ /@ @ Ću=@ @ +bxhpݱ(ړл3yi(ᄯ Y-Dkˤ8×0M`N7( NËs ]g7Yi( :\c/ΧwG0c~|V'~t|Ӈ>h>KI @ km+pCrvq|6:^gEb7raxA~VZ΁t#/3@˒:iUx?)kp2;̥Zc67۹'7Lܐ N3YpƮ!Vd~L/6CG;7GQ' eu^>27UPחAަO ; I5RKŕeJr0мUWM)[2rGw%I'ٺx!L+oQ}մ|[)Ouv"z!#O:G/ xQYnQ*ߚo8vƢK9sފL,ECX fh:~Mf`G\b#F@ Q?--\0j(ɜC?dls=S,x'e8m#IF.};Hu|sAz+ s<0y鱙KU_űcS⧏T{z~0pl)؁E:K]`~ϿGy#Q[v1\=F1$,1y?:A5 ϧOݩ o8͊ 9+7y/0/NBJ$=SGL߹=i3*|aT_ `~LT[{Ҳ^.r+:ϒ1DcӸh)Tt.}wpn]z4WWSv䙭+d[zXd =ūX\"S UzICɾj|dKClԡٌO$_bjާ*WiLbRԽ#'?AP ]Gؠ$C30 c/f/|4νa} ^z,+~흰RCF-*oJSĞR@ƹhzf)y0wy|;K~[0?r\5zs ƜMo&eǟ'·&uTe^@  asO&$j\Ƌm`V6/Yп_|3D/$/px:ĥ_B~}9j$cbFA .ğU=N:PHIQ y4֤MEo?RbeE̼}pMf^loəw!?4f{ĜZHC_-uVrN寪j6MPT.%mnbB0qê I/ g2)Q?5umFr: iv=Tؙ>LN TW?M#9!#Rм>u$E)Ŵ}%P,=ѝVʧg)G=_z+c?_'4$XO 5߼lo\#K,ԀLޙPa 3_݉\6Ӻ`pBlԴdfBr rT@ LAU]G0#< + CEiiup-r=ԿyzxyBJ%;^< 1-vTdyҊbQ~ sgOl W?)O.4f7 Qc`U|bh}OܲҌ>W!Y7{6Na„ L0) ډu$ dFS>ajS>$WLgȎؾM~*IGA~rSS̒IGs2v 1ˠ(W/5,_%Դ;O[wž jnrnN=ͽƓ yDei±ȼ@ :7zy:{0k~AWyw4 _N> haWFL8[ {0 z-Ѩ3 ~njfD~M7*OyPv1>o=9qRE.~R&Hɔ\댥NV#u.Z@fhлvc N&?Ha4"i1t8ݚ8S߫+Æp#b7!'|> Of&mI.;7R8aϵkms)Xp$AWz:V]*S$%%DɃ\06KSkȉd3:iFBܙoū hpti=mŠ%Jb}մ|hbѵƐwNt(W/5+_EԴM{԰}wnNdԂ}s+_a]n{kz{Aq"v+޾nי={I(*@},]'?gAJК8!6X-+7O<==pG/MZî7D@ PV8ӱ:<~( -r/K>'sk>dnFag'ypcLőahޝOQAIƭѴeM8eb^̷A:6>^v#]`9ر%'M|^s]dYHnG7Q x1xx5|sPV_1 [bǓAZՋkGK,;~ۖoNCԏlrqlw4p؜LƝM\E|œ ∈W3/>-z8R5?⢺*A$ $G.Byи}AO dף[wuBVeZe?kIؚ" "T<_6 U7hm펭:W+X#cL$a!iNC TmoO.ϻD\Σx(Ld B"GIثv f[='sE$ETG`8uDE'#s;B7پt=n6bR`0oMuٮ'>KY3!撨r@ .aTZ7`r U#"h6*R]>*Ʈ=[jqo$y~χ~9gY<>V[_>ѿHBxrA yHU )Æ5M$BSn8EnTr0 _^ .5A0@ 3JDu{QC+t~?kE] _vz|q(su#f"EVav}ZQ.crfEƐ=hʜ `uq4MsȧLlY7I|4љz~]ۓHʯE j䋿eM 0lVVՈF|ϦSX?Ƃw]b׮DZ@jdʛFۦU, {]Xd[GN+HZ2bӊ3~(;qhڧUyJ.0=Gu_iO5W!!grh|[=ȇ\_fd8F T*Q)UEj(^ 16;~wf}_VJFtЏiCc*lTL_}TcgB œdB++ɢaݕӲ J; r+)ufE6/HH1zRvcTō3Z+\!kfx%%Oghs|1s9:L!1 !KVՋdńfG#l?}`_I}e5v5soBS]ǪKVk@mK&D]ʻ]L()@PyF qݣ _q r ;v_ثB7ū; ;0`dƈ74s=4l47@EN$^)RtTsxF*,!p;W55,cT[ZJFzkB9*,3\z1L\ji/pr27 چVugX:X!'r.O;WqMApV&O@ jx;"zFuAO^mЌ^Sߦo1u, ]y|ٚ;{4@(LklEfJ+eI}oNȎCXUq4:w%X %2A<ëZYFӒE@eBaွQVLv\8*O(9G߹9w$˗thNٛܒ}G2)} QL^ԦUĎzWfgaDyٯG3u{8*Tmmn>rE/IdT%>f5bJxKeGwNXQ4hܚ{z_`_}Lg_EMdDPQ8L,0"\i@ ser5dI&XݳD" K TLi去i4{w|dTs"ÍkXxԣdt7Oϥٲ(qkrʯ\!VnJq*[G|^U͊/a6{&"9up~C9niO^Oܹ}>:Tůp]zP*?jQ pMqKJ̫b[q@ 06`̱y_IzA74g8|oK07RVIE nY=#jO\{ǣ-. XUeKOU>s:IܕhэQp_7ƽnuʔ2^0xɽ=6։\0VAn[{l]Ѷiӫ^<>~˧EM5^{16XU1?w]%^|J,׊V]9kX3Nj @ T;0;ecCcռ`"1huWKFk?n/a2$!!W3،!C0ǫ*| ~w8 /G>'A('j/p1`6sB| ?-?wR 4MK3!lm峯R8nϫJx Aѭ,~_B/~< G3 ,, o`LTu}{U(Ӥ N$@ xQ)HÇ 7l,QѲ$/ˤAҗ392da@ gi!g=V0<;"vuΊdQ GY.ʀ#_FBLOu|! !@$ H@ @ҏ@ R$@ @ (9aT EA,p7K"|p콂Q<ۚ6bR`0oMu9Sbu1AzTi_P<.ݘ:6QDğ@ B{QMz4f4mрg ^<ą.`~ojZ rc8y$9ӣ|4f2Vsf53ì #~ġbਪ dGȩ8n=ɍ8sβx/}$,W>ctfu3qS/K k}~Do;a+i>d6oVvh{h$  K/KESGFmHWUo΀OVLppkfGKۊߕBUK;iʹlY2wZQ9$@\Zwn[wU\ Ʋ1}ǏaJF4S&_Yc'| .xqo7s ܿ@ <Jc5TUp 5ɽ{1Dsic ]X}&?N@G_}ӊC5SE*\܍v.&8)TP]/˖`@4~{WҢz5XG_ٲ&c 2^BP3$~8E>|cGuDnԈK>sZT8xaQx>S7P;ya86%sj׎ v{Zy c[ak> Wrɺ!l5\sy-;:W~ BQ5D$ аgo=զb_ }Q%sYXio@ dx9Ư ePl/ FXuC@5drl,)t.Q(NWH1jGub [qv[ÏøHAݎΛxpBy &lƫ>~FhAʹ1>I5viK{,a>?dQIYKvriy2rA*IYherO}MrN៴ӫ x^$/&4Ӕ<ሁ@ɹU{)`תQ3DZ ^,G8yٱG9EW)HX[)aj#UlG+]>cƬ ![.| kZU|~[U샥(lifN\dW.d4Х'`+=$sg"|BʠkdzP\ZJ`:=}ϖ-ߢd#DtB2<~]бIUO_.p`/\V{_sgQP;iQVG3XMךtxѲ#^w 3d1<\ / ˯[ g5ac^D0YtdNl9䒚߲׫\O 1L͛ݱ<f0#ԜK:Tr0 ~4Lvo7;i}I8-QyV{*p{&l>\".sdz5L}bLjwo\oWb`ʹeGqzL扝~=8q8=jc !;/NfFzX4,G[SV?B W_>$tiʁ h݁'N$`/r"*-ؿt# ߹ }rdiyWZcN6ᷬh7m5؞L6T3SBA>camXt&EG5[fF{%^Y3똳5\j.p)z릓Jn L a?K`.?I\ DyCEEu &8*)M:ʉk7/Zau7 IV+ۥ=?CT͵ 95UT4;&x~@kɄ/[vNdES6HGr2pgѧ?yDsG|Y[Nqa7БQ,)F-9E'[( <-N/,zZ¼vW'-_V!i7PWn*T;\n^IBaheT ?(6fd?csH&O4ZSH$9Vsx?ފCw~Eʫ2-0~ё2>B՚-<=#]GsZ5Obm'$NnJSefujqpc{W j_ O GRUJ05haQԳ/ ݢ/x6\zpHscr¨I!SLJS+L&%$.M~SٗXLy3Q*Kfߔimngz7yLU|fУcAN YamS8 kY$gI_xة)UzSՁfsV.3yhnxӻX@zH3~Rf ykIY(V*ΑK(}]5ٓ{W޲վ_%ğ@ /j¨RP*{/cB1i?odpznj;m׊[}3ν:RM+;\ϵeE,*R6y 䧤=&E##[wl:YB%<,9ܸG=J K J̫b[ͼ&Mݽ+vrL"9up~C9nտnE<<:4AzYi去i4{w|dTsC-=h|t0Qm MBS`mPal뱿> dJϩ_&+0j92P?YфiU߮huIM1Kۛ1by`!˯nEKgW1~&},=o2+IGgHH(&e[A-EFCZu:5ƿDHj3LP av~* ھ_z)_@ Ѣ!uލpmC&/\gĨItɓcvi?gR?)gcL~G殼dGn c#)_bp|MXf%HUw7O,mOCUԳ\͸gZ{ F;uꍩrF'ܠR!gsa|6ό $}C;%1{ǟUƤ@cJŀ,F 5hByg%FC `WU._9]-x۲чzVè%˧O4;wmPDʒ]b!oW>;ǟ$8!yi8WAM0~lEƫN<~^'3wPf G.em[?P.z/sZnd{1szd1v2PjG-?-fE5?L[B_)+V3__/S~t;ed.c4ǻ1˗RI7^T\95s7ŰWe Ty(\КYL++?Va2/cĈ|4av6*TT/_bh|xj@ OR X#S$}T>,lϏ^u3Z Q>Rm g~G|G|G|lb|gT*Qc[^ʺHdzsܜ}_ˉ De NMpJ>"g~@ <9Ľjrgz~%E5 /WhaQ?@ Q%{+Dqxy8 G^,w5ps@ _ AERFAe ?_6 ;"@ T"!@ } 0ËR۶x- byOʷ± t^1mĤ` ^Eߚj}au1Az|/~`Kп+hbw IDAT'Tn`֔On?ʔ0vA2l39`}'зcܟ/b ĻRi9K$T"][,Y#XR0C™9aQC,iɓw[adG"[s|,0w] i0m˨_y`K'{SSjۙȍ܁oذufdh4LU-o=f45S{zGoe?1rUlԾ`iHJ&8wﶧNu#t36Z;VR[)ʯMa1|u5h5p uZJʁͬAΛY sɂFR7 8Ej\C.U> c ٗQkx G?dODM{nycG n ܃V/[IVGԶ3^ 7֑|W XBEUF:“&khbBZ<A5ד_EДaXQ}ƍGjhcP5s$ ;Z#I?g@_R[tT. lp#x9Ma=܀>o2m[oέGL]yk(iBIKFY~Z]Qy_W9e8}w3"k;>hZFı]|iWnOܾ.>ךoXX7o'b'!N]hQ baz$ j?mJZTV=\+TL=~93Į]ׁQ\^Ņ_&(;s'jpF _1̜Т{z՜JFdݺ4̹!ɷ_ _ֲ}'|Q._MCj8|/b v?[vtbu8@Da_ZPIOc!UR%Ư evE+9|F`Y0j;=M4L'$ODEF%wZ96@Oghs|1s9:L!1 !G60kh(i4ETL_}TcgB S Xϋl^0d3^c4$ƐUYKvriy2rA*IYhkhUtO)\ι;9]3/qsh+\p코EX? kZU|~[Us"yΊ>U|^nڽGQ4\b_.sT.= kXuC@5drl,):tT8x}{"Y7}1GjuK\믍ߕșSKa?b82\ӆ0fUrk 1 m_W]:Dƛ6x}!dKп)>.Uq]*[1aEWU_|TӷO%-_*\!kfxEY|O$sg"|BQEsپ4B?X<#Na_AgFe 7, Ҙ3, PT_(x 1m'٬t*AiQVG3HـW?edWnߚى-\Rs8E׌oOK9,g5d!Gɿ~ʀ;^-9^NC&[jg|) ?M-}FL|h$Ë\J|:9?*޿ 9)s $ˠ#HZW+yD;NW:{V`Kj_ˋ~ l_b/G扝~=8q8=jc !Ǵ2XS7t147"_~FI[J ʹpTa؝rT4ՓiomD=QZcN6ᷬh7m5؞L6T3SBA>camXt&OQ&^%<² i6˧\RFuM'I5n݀X(P(ſ'󇲌ao*t|'r~vHXv6('$^*~g+*޳G]hēW4ԷgLp, . @pRU8VQ!aԑD2Vd] EUGkP3'\ӠЄjJB/_EJjcOA<6dR18yD! IV+ۥ=?sw㒒Kҧ_Qܑ,_֖ӡa\8ugomR2_y0ݕI˗d r_ёՂ#b}YuIB~ġ*|ݔvtU˃J}-_id-%/W,kӁXUZSH$ሔm58燐YL(Zѭȩ$rZ5Obm'$Nn )>ڧxR 'F XĻE_XUm{պ0xu Ŭ)TMiQ>C?ϱv0Pָ~#/H6Me_bPKfߔ6&r/G[)ޯ@Wݟe˥P>*gqfD&Z]!たKu3}VIp=2UˉmT7_wGhԴ1 f8ƣ3Oʮ}cA]'ǬL6 #/2?V,zAN*ȊN ڴ8qƼpY *y_YﳋT&䤐&\?IErWp$7^&$hE?Xyl_> fKk ^c]4 (PƎnI?Go*z& g.qCV:&g N1cgZgW1~&},=o2+IL&, #qUѬ 0upJ JZ9ÍkXxԣDVsXKxY<.̄ݻb{i'oA+fOx#[wl-P&ԦD)Jug]]˫>&G$WKFE1e+I~Jo],KLL 111&dJϩ_E2WŶy975ν:RMnVh"9up~C9n)r_UYRzVF'GFM57;ʬf א.Ӹ 6We/⳴rV R԰cw= kJ=5dB#NW|/ S] :/cr+5cB1_/\3vsG{&,{%(EFCZu:5ƿDz__gJ!aHKLԭ 7#&*78v.$2e$b111gHAbv%x#Դ#f-rMjkGa9d^0xɽ=6։O9^JZרi"nwg2tyDv2x԰ޥ1br9v̤~nKx{%8$%=fԤ?}ZbIA13⸨ko4*FHʯMhգ* C|^_^~g>ؗζ86E&opU}%LC?l9nlk=g kI:5]puZ2nTUKHU0hDhѐ:yGʵ}7ĿgDݶ>.6غ6m} " 1 J[3 %ErFQe7og]TH;wd[0-|S^oִuKSro/S=wѽ3-˿z3_eGoU|h{o7IӁq=pص-zۿ ^>v3`Zۋ69W\_b?zSbӴ'=5nFt?qX$ǿS)^m*xιK9ŹijxzЃA0;ecCcռ`"3!lm峯R86U?o&9$@۾ aK 29^UQkV f8wG/ Ӣ sg +-e})a%=%1{ǟUƤ(JjWXwv3κÁPϏ;;~"K;s)]#Xni.sD":D?T_ʏFnbPw*PI+蟨Ͼz[&h73O ̀k?-E:i]e۸IN\:T9#_no,߿JO&?*MN][3rGd3$w%?([wo i-CHx[Z˗><+g1vGi~ j}G#O[Je>~a߸\GyjO?ZbZ̊j~ R:WbG< ^v.e\f_i>ǏwOM!0,YBa~-㏰TS| Sr{PEA""dZӅoTzJ~*x۠ϳ1+ذUZV_Բ5rrIݿ_T<{[|OJ_!aҍɫ eG}7ƸBk+/Þ̻ܜO`gcMߦ5(!/*~AJ|0NKyE_/ 8PCN+km9d`Ix gmD? v蹀%1yNb+ݖtWٷ9HmOP`Y;CMK(S{'s kw-?}V;ɮ^~U\[DžLv (T~>%) H&8wﶧNu#t36Z;VvyiS;g _]ͻj;Z {]<Ҹr`3+Ef c ٗQkx G7P>=7jh1H<wb>(is>R En<|Æmگ5]"&r=V|&"a4v>sQ9ybt\@(HGtR]S>Y2&JLn"*f4$a, &mϥCi|kʧ|0v{ٳ{Rp+>h K%0C,#dO K%:rI緙hf*Z(SW66"eqmõl+yL>-UZe}|26|SO eI.X)9y&CG7 AP$p`j[Z@H+[r,QjHGYxUO]a#:11DSv%Ң_G}0Ws2W|*\܍v.&8_Qav}ZQ.cr>tPb1KV4߃WVIO?x#^I+>}EaO0TY=%gsKaeג\Kς3n$=WC?W%=~wU{/Ϸs:UJ=ԏ.š6uqYJ5|r%#,?Xή<7})1:*}Sfz>m?; qB[j{ _yo mJZTV=\?] jg:vq!Ip:|bǎ,܉?n!ܨ×|&38pâ^|>q53q7=.snmim1װld+9'iӐf.˹<ϖXݫN?G>=_S=D썠TW#!/ܵ<^gNFn'VS~*Grw>㕡7KɦA,}<&fԡ T%q6K^iq@Ɍz3~ [! 0f2Gڟ>ZʾȀir-5'mP)ufl~\01c#'/ZH˓RIJB[\,S}?q1c-琢Q)8ʟzz+3VoxMSa߹7q][eȧ֏SKa?b3}#3mh$7qWD9prUD`+nߙLhvsXŨpo6)vw(,7njSaMӣQOˬ2iUi IDATLOmK'BbРqftbVX+ ^rhcc/%%<dHp]g9fv_Xz7Ji+%PzOΥ1۸fصCԗxoxxn[1Q.UDZF2w]*[1af )4RV.uܙ:68Pto-ȮAMs 93PGxPz #e4 .d^T_|%(&/GO|B.O+8>4@xX>}ؽ' ؑf;rbcS$t70< c^D0Nb]H׃g3v&²"ď1s>ZHpv@/5pOs3;ċ8#\㞰s)6_ɢ>^磉 `v_jkhxϊrB0až;dRvyC bۑ+D_;{0v0hB9NhX29nK4B$@0Pf)(DU?)*M@Qjt|I/AJ IH}H@J]ggٝ;̙rfk\HIX?ݹ6 %&&ٮ4uR<&/yh u fTٱ־xɯ ubߤ|E}~m*S^ϗs*rq灵ƣ;kw&r-~+7[#=l&(FJk%9ҢsH'r&aCOJDy #9j4(L'eIGGh R1W"g V 9 6& TJ_-iHQ}h[韕;OsX:W`݋y>+x?;1@$芖τߓszJ=Lvܮfs/u"_^uaCg~ *T#6t-s#$߾[@rdEi_c}UǷr#sOY6b10OB/?3_1}^Ǥ1hҢu`'#fP*KITW>/vQ*/,ZY6E诔7S@fD=[ӧF7.vJH?Yr6f'-NYbK&IYg Hx @PSSwj&eiX-sΟLڅ> 2>ϲ$dMT ^36rZ.ΆU 85ڸoq@e'bLlfL/3>X4y~χLIeL?w9d"  $ƒ)YcQ`̈&V@,a^ G}w ցAJ*ڛx͝[)֧JKDѴ}V kk[9x:01,LOs-{ۈ5>HX3#uPa~[JG|l"س+t2jkU!m&8`t;Jd]jԽRuL%ԿILYkrW*a\NuU6\:ʱ thMմ+oI$pTݛ+st4FSPD"7FdIJYEكX=:Mؘ~I &JhWgr? V.8١S%(.ɭd.++Ue7rXJ'rPn]f#3D+iP5JK&_m*ˬ߬ߗZV%dEnDg0#&7$^⯸Jt:mj݊;x zPUǟ3$kf-jժ VM/ۏt&Iiō7Fyn߷}KBݫ蒸qr3W$.r1TC^_OY5f,þ\YDZΓ7iϬ=I ?;=`(7̐9r(ww@Kk9msH9o7n.mA[)IQV܏I{Op16E@&3'zbgӊ_Yh%̟,].J 3+/?.;Ƅfd&i1س#/ٌ6i+%/2<(CܱuQ_Bτ?b/]=|! <۹g3trٌ1-k;_69wĶLАzu7 'H=EěY'Y-ʟ0e2:Ob- 9kfsW闰}y/Cb [4WmD2JaLY'+쭀ҋo~*K7ZBfMRG1[?`?nߦ_ٟSaƍ#}k_lZu6/Gp?F*ѠGnt1(?1y! @xCK?cݙV̟ualr1 9}Р#10}[3thbD>d~qk"}beS "T`SO~gZӎNBO/_A&&@,N">X6%O};kBj#%aLޟvTgDurMW7gq{Wb/<6p6IL(ЄЏ@ |StdL=F2[M Ϳ] 7HzS\4Z̗ v3~.b +qtĖ,RR1XBYSggo7/.{JR&Onfي߸uwֆfSW0.c/1/4.ٿE7?bY4O簪<^g?xg!e@JA0{cܬ $]ǚ9mK6޼<=^oE%IOzyv/ZpyĄ&phx3ڈcXDg d~r,%s#sjǡ_t"g"U2_GE4ǹpkOQR =~Y/U1OCnP}"^g{5u%ԏ…Э\FG_g:ŠY9o0?ݧe:dkL00@ X*[6M2 clV~{Fyh_q՞o%Cd/ʦtvs__^˭ll#xnrqK_=TȠ6OrUe7/嗼4oV(B~SvY#o7BnL5٫p}dwP5/t]U *M&ȫVO[KfȤ~M0~LٷF<&OwyGƲd˧~YfQʮ= WpD`q(nZ([Le04JuNfܽԐ{\/l n#wsQADeS,>J\bhoO/_{[;.Sah^wꬺY*!+#Fd]%(Ǩj$q'^%Fȗ+8nF:-ODF)p!q$ɐ_-P~R"ш95{ò!مifWXq@$}g z;|4F>kr7o7i΅!^q~Cᦺ@2e09غerJ5^}Н `P2dؾ0]ftA6*cZFVH4AG"ڻN dwHy԰v@LQJ@K|;rR0Wb~P$4^T##[|*UƄgysY3U?ʨ HQ}h[ AeGCDVFrO楝x+hoH+j:PiZ?yOM&*у^5j/@ Έ[DPe_ c^|EƼ^e9b9i` IC?Oao|yv:&9FhԬ>M1s_l)KR&.sKGϐx}!{u _~:*S~l3bp|N.bʬ3Dm)+HHT,(q}yKGz0;K >TA.'?KO=rH qF  u++svَt1#Xjw6pq'Sb Nx92!%OAMk9֧q6V/eS76f_bLON\:eE.m#e*1s{oPC\ܠU8r:_W\H$,I_n)qKHX9dJ(twRԫK/ڋG 1OoR/ex+rn/(Cӹ;|:1lX#rsN߶§^Q$Kk⎝F:ו3.`-ӿ7?|dCЯ#x c'.e/яҩ\ρkX@ 嚪 IDAThʉV# ~)3FwU=ڃ>s65=*(N+[KM߆fS7+/kdƒ8v6\i\ɪk=ao.udW84qۢdm]>sNv_BYZV.xt3DaŬ7 >| G`%5QW]{gSU{rOD8=56+_C d-kfطIBdP h(qoN$N^_Aw_"O>AMu^9mLp )0~/h|Fx'+ߞYl;t:^edK~JԭDUw7뇱쓯aC5&07ĵ*06*`<wD988+ ߽F_"·FUsMHpS%R:3AU?Z=U|_}C1}ԶDltt%M;7ھ.~w.qvNt7ޕ`~k|uTQ=R-WIFXz!LF5RQDEc&cNmW)u(aTv$^kߡP=zobڟ}O}#uVs˕[[NKm'QJ*;"'\bHI2$Ɔs,2#Ah &[^&71ī#r9b@UAԺEe4&FNlvam_Wp!"н=;ۥ1\3cowVrvF :upR] ۾95k3Ap{#:=8IiI+|AzTIZQKM?thdOxʇ@ R1tb>+P5Ff|0F{%-NhCflTهN4b]I#^ h ?x`~G] #9SSfi5jp1DdI%_ d4^T#=[vKKƫ+xoz\(c+A-B8@ F v3b a.FƳz,}Ē[I[hIC?Oao|uLs&-ѨY}қ+?bR|WHNzنF%/lKjő_FSa&.sKGBϲ/d`ϵ4ԝ᫛٥S> {@~he-EY6b/h0>OcN9XaoBѐCZNiew >W!Kx3VѾ\Ű_3Ɍx\ N@ B%jk : Y~h^߸%vؒERR8F`YFdIS72ti-{~>58{7NO{c/ 雏u?JqK_sMON܅:4 XQ 2ϘĹ7F>Sܠل&v}i߻5* skWep>2۪Ĺ/QA,NteFPGo&c z# I4@PnF31jSH{cb]7Nb$O'd[*;?u[@[ХFpV y}ց'1Nɵ|9e?eዯU2| xLONypBy8z7*wòcOfWL'_f߅\:ғd'sx&7:1x?b  -pEi+м aΐPs%+쭀ҋDOܱuQƠ/FoS1cR$d˦9ADԲʕ$ ʗU~iVtPIvMV<,/\1AnQI*::Ɋݙҏ頔_'oJD]AD(eS,&G¶ '+*?<:sP0qm;,49_ı;*USW7j% /7; -ϬkQG[6 MS05m,^wϓb 'oj vO_1-ű@  3Fs$)W."21hN.z2Odζ#e=ѹBw* $ `YA+Dfp4{IFQ]>'6;zT_w}¨3Vt<ϳbIfە +l![D`ކ^$,#Ɣsk$ûdP:E'a,836wp(u:e_׉uiP[HI 4k(5w!=pV{Yu,_sXA@K 拣"?eohZ~ƪ fCV'H;Suַ  QGX1k9 <^g}7δC$K.t1wl| :Όr*:;=t¬oy|% =:du;~gJ%(C#k FcZm|' DE6Y2vwֽ1nVcvJ6޼<=^oE%IOzyv/Zpyi_evc$TT81SFeԆTBOmfEE/6F9/ȠwFaE%+=ن''svIMOM8dQ>b!ۘ•?b't=ρ, q`{jl %,JKS/و&LOk?,l^c۶xZy*[1#9ykR> 0P`ޜH:w{̔8vuԐfŖ$_9mLp1iI^#m===s|8Tn^g/jC9@֙ Fy|ժU%YBe1.@V/ Q,ʷgg}?90e  Jh\%ad=YI jedc I;ϜEόHpS%֛*_ɆC3UV I4ϸIDLJ^{y~>K6TmB s73p~X\Ό%WIE[7앐hP`S@lMƛnc::_ K.:+A(zMaXaWf1nT'EȾ=_ѷ;F\+Ux ?O"}_oxhseFs#TVh.#!s}?JV!WM)~e@iW387r~/Ɨ'#ٯ)D//q(bhoO/-I8nr;40EӶ4X"Yp8"xNo?n4|)=r=uxsS9&HC{IuR2SM40wme `)]z2-OR2KC>ۮ/71rj&NeC/ B _Ck u ǎ71n ΟiJRdr#xE~:F?dNfbʴw8 *+ُYˡ~Z1}m`{Eduv1'-Sx: Qkfa,Lw o'!CBP']oGP%NN$zf'a|0tb>+P5Ff|0J.ZmC A։L.,iIt }m-餂= &Q_1MxYs=KgpYCOŀk폌.)9Z !c]Zc~A碗e$mY֣5J\-R> 0{\ƌXngB-"˲ѯ\y\G~΍JoW$J%%G(]Y~䙥1'Rc!K>#<ɹi*<?IzX;WR})!7`g?;xIf4jցaʏ/߅ψ)9)öէsEJRo횼 9|t^Kc ,;'95O97[_<d6"ǔ9$ٟdmrҾ&;wi]߳h<.{_)r^Z[|@Pqjh'P[ߛ| U} !%vή:!޶4?^ASՇ*$Re#@UL'kp˹8sAF$22VXLŗDn:PYpJ*[L' WN7YQ篐' PtAa=ˬCiMi؏͝[)֧Jt&=H!ƹVU^D),WQ&J&Oϖ1bQLeCpzo˼MtV.8١ʦ~>'e,l%m/V3䣹>x-3ywG];WMoa̶ߢ+y p-ݕpwRԫK/ڋG ɡ9D֍ۀv}gBwn=B|)KgC-jihcH{oyhbj O"Y]w4jԏ93C8} zU*9k)8lCMk Sczv䴋9݈tF nnSj+g\d Z+oyۺ'k7+߱^n.zc{RC%|nnV7;[7f녗wѹҴ *$<;3e&ȊʟiJ>\t݉< tZ(U($ eqv[T=‰Slha%O86*[涫 *H}αz; 3]6m&n/O %GBݫ蒸qr3W$> ?6m?V8 'zIl[ Wwpq̺PͰEsya1@'+L;K@8Ec*l _Usp XŹ,ɇ*&T'JNL8H~%tqQvUi9y7Pʗ'èAvɾc/82}kPE ˯A6|H쀤T5E:7r௣ 5}F n٫Zvހg0,/w/!m~z6.ufݝ>_@ז/'$߄I<_9"俫!yǡ lL:c2^_Vȟbwna!~0¨7U o .dh*LΨ IDAT7߽+lZp\fy΃R^rNSF>*l}hʾq7=~%Tc {e'o|p9Qx>|;#` Mff<ǽ l9 ـ5P7VC0]5Ĉ˽-]~ 9o ),?skכyťhhN̔vUTj '™0!.*e Ha=:LMė*cI/|LKfG3_& t awL$O8 #o@N<+9?n 붂R zH0ɮ1}$2hߓaNp4_('pm2 {w@aVg47=a矊DhQ ~M;? ۳,$Y n@L+HP}c?@ |۸u">Yp 7v r#.&@,P1o\T4o|Lū5 3/%ɿ.B ` Hʼwrvp: l@ l] o4c.!t_: [ƾ[͔O@ h''J]}&nC(m84 r HYTHڒAP}JӃ"ϙ7`xhZ5qC}I63e}/I\x?&/%)?.%ՐridfF>e^%~. Mu)z/{\Ks@8Oj0?mHغfq{IVj 4s8;A% >Yz`1p;*7j4ŘQ:uE{aՠng]< ݗ#*ɖπ:4U ؕ o T,B(-d2y + ҏ9qW#]3+ʢ}7e_ WO@ tk5f/称X:JghtހimhLq5O/xs0X݄iOK% В;\3@jP  yxGY#{IIC;%hh-oP[(ZUQjU%RDE_kծ],Y$d|$r2s=,<39h0/dsLK8'Vo?x6 %x>ؘY)mļ onX_?RMIЮxۃH!87o PB]b3a6wgh >V>_r:"BD[R,8ujAY|"c:u \z UQ/1 xm uŽ@ xJxf\#0K_΃+8-\9cMtq0R W`<h` *-\8 ο``558O2&˃6`#(dq >ېw%V#0ttDvkF)=|"mcbP~\ 48{03;8;| Ql[J$Uߋpln̾*D'AU3 RE [" =HS!|dW{ ͳc"/]5Bز" OAؾ5H~f 9 WypϦ 7(@8~Dgwn9$Y;ubu O_Z7HpZbE))f+ V?gH9>V2»ldcKl*:1vp% hkчY=kGD#T2}b+WVm/kArqs%;&x6<"H:Ϯ wO7ۣ!Q V_1i$l|1dpw^E僁,t ބx- q1דtuodָ|& gpx$}pFx=F  =@ aKצthZsI?:ڠ MW2\PWyG c7ڬ,dA>*zE4ԇJWz̝&הix1EV_m"~ĚX:6G9YuOaX|3u!W7)CXq̨rlIU[7Sr)Ò|V\2y?W1}UR=h%hF 01~\H~FMH%rt3U~k7fUһ}JY@ (xdSY,@|1G4V3 JA!ЮvRwҊZ[8Cs0Ñ ^;>tneo7pz*2l~v U~ۮjx$ɠɿ7óocD5ԴxJzuPsxi E6&Rxة@SH%Ҧ @ a< Rj5Zk0gaz;O'6"$l 6%5:t"+=.`L^ԖIq,KY+[2Y1VEYܜGCm9w)+gs|lч<1K`KFuWfaG/@L6J+#q~Hjr[ڵToיIGX+&xCN9ccG`A~ػq ȄGiԬ aY3|V*P&I}8k&7m%g f䐖S2ˉ ~\ N@ gqcƸ Z4cb&Ѥk{'Q %Ӿts5fUIXzcNz!wH6 K Te4.]j8gdϘ{65dkAe.x*N6mXέl|XT֌47?Gcob31@m<8B5R;չ8v!Ψ9 @ Іa#ZԩK!`/yV%F˚y6PpT]_,g93SX[;EPӕ|1p`rOzva)dɃ֍\6SVho wzx8՜lH Kȿ+R&Z _Ү!];rػ0vVwų ]if<^θ΃4 -xߖ6_s3ƾ/VѧUu: 1 @ TĖT1䥐f&=?聃I8O|wgTz]^V ąOj/.Ûw1[FL *OoߵN?Fcjr&u#>`XEɍ|y = 6lEŬ jhѴqB!~b#8\ZnZÞZߕ3?]!G*f7K 2/:WCpқ/gs5pss?j}@ɥc;H֛"#M8~ e*R bM [Q"$dHL g?yr*RPʮoΗ~N%KB" " 3o $@3/eElb&Q\ǎ|zYl {1Y7B@ a[}&@ @p[k8@ @ (0 @ @8@ @ @ GP{1A;XZ snL\Dpp03%u["oqSlĄMi/_^ĩ\U)JtE5}ÆX?>(Pb4ݜ?(شf~S9`gK &88ޥZN/B&+4GƐ[H|M4ZX7р~ aȇp-硡s;[iyOw0(ϛ[aS6.폧nTO-[徚֨~*y3a~d;}/!D[ F}Mrh+JVH(U$ *m0R_Z"L|Y%x'Q IR̘:/9G(i?foɒ2r"[Gc_Y zje2ǐ{IfV.nlduwY KQpg~a~,}W5Z/S:b&'<PtVԏbŽ}fQ0Q`"o{J?RbϭҩT?YF%T`8!;Fvv̬狝:*GjVW1a0z j/F%J,mm"RVDŽ҅ns5bAjΥܵRKL^ͨeFN*Ҹ~*_笛X?>t5#@sw̦p% hkчY=kGf>|}?nO'Yr㬕.ldcK|wH]~DBZ9'kM~4"coGN>;7\O}lXK^<"H:Ϯ gZ=l|1dpw^E僁,t ^sAGɷkws3S6*_~ٖEcc\>$_dtg.8.X+K!!A2(N+̩b#=[_+yb!+λSxwŇL+Q3~<>~m #ܤj%ˈ:a7Ffb(K*߲'mCXusg-1b;ӧs3G6~͟ [d@RlJ~oy0_d*rӀo.װd]4evl Tj%rZRJ.ryrp4,7|VSdrRַZt#g'+便z/fwW8g>;װfnru5 a3T&hª89] 9dE}yŮ/4-돒L. ūdÿ5QՏd)LZ S+bc9r:Vәq(!Xx4YhNtuj;"sIԏщUq$+ k#Vd]txd9HtY Z`Ɲ"q1=,gܥuw}zMj^ŕ'/YlЫ3װ?$M[h7/LTȉO .Wfxv~m[h@<ލ# D~љ @Y8 ئ=\+ldr#t+ymDebܸ}~+li>czZQnZ‚N 3+CN9ccs]۳'w•13{njy=Jc): ބ@&8JfMhФ t͚qI9IŪTVkor򙒿+-Ȳ}!2 T} 0ٌؖ;GC,q_ߣLrՏO@&Eq*sIJW$ !-o?65hڡ3w@jq~>j%O)_R+B)gqJj jHj+< $3ISbm5TAB+̜}pDCdo)%2V]R(qz;<:#N8ΛJ{h":!ce׏Nshs4)qK ~Ϧ׃^Ur6wn`["T2=&2]{og^d(N>SWf7Q>ţEc#lq<vE薥ɺl,ϠNՈ|%N2>U?LWsx .Km<8BQ\!a^ݏyn_39tsjۿpCkS/!]g"1\MpöY F.~[⤒PDUmuh $)CףӂRB2>{PvJVLM2r~)Uine*Z-u9Ogy~ V~boz4r@ x|-6y)YIz`m7Nc$ IDATC8f.~3hBbfn t?U,q7#.-;Ixo:VnD0_MglيQY@)u f8MLZp0'\O#ZWyڡbi9mj$(8CFW& 9-myC Pj5\m# ڕG;|d{=?P۽!g_0*1-BɯvPgH7oHĊxy#WsS{U l%8v<] eq 2&c96@j,2Ur~)iƁgH4Yv= 0c X?导/Z D!Z y.x:dHˬHd)ԕ-} R6͛OymPP{+7"=vc,Q" VClIr%lm]WʼIN̆cxX x"ܽ)I>៬jquO2(@xo {(]6g]OL@ Ag @ q:ޟ_&@ [R@ @ F@ @ Q  snL\Dpp0gQ߫p뽘q(ܺX6b¦4үFy/!Ue.A z*@ xlwMvhn/զz%%p`Vo:Bt?voh_Vt8Pimh4u¿agI)M2Y9!Ax;R՗?=3,gӗ~e~IVz0[ @ HKR_LDrn#F91Nyޞ4MM7v4GQT^A+Ĥfhs=gXuFR J srBÅ("p1Iݹ0kcf=_IplHs' btDgöWXֳ=?vcTbikYd Qt㬕.<|[Yǘ.pn;V>;vnnf/%Z5u#fhJqh}vnذ|'+Z#~4Eg%uLif>|>8+yI?_'U$Qٵx!;#LK(62;~/آ̎@m:Fv% hkчY=kG|3^ K* 30 [8Ы_qh@ 1ҵ)V#uR )T(0H<JZYI_]7fN&LXzT L+=owk 0*'䧥lC>`(F/@ Ygfз E)/YR{44s!Ɋ5!;2fxW IpJꨢMK^cPMcשp_ޭ)sasp35}Sc׮LUL_vsrF gDL5tlCrv*ţĩl,26:h N@ FSY,@|1.ٷ )7p[ rLn x~]4Eu zِlЫ3װ?$]+~-͋.?ـN tp{ m3ɵbrgQJ"'^bhI:!UV%cLpFnNAK~ x ?>J7F-ۄ2O50thZ`ǽ3NSU>Y@:>FY D+SrFcχ<""vH.h˹K!\9{c<ܧ굤 d\!QW|^'%fRy^ WtKdV z23> @ ƧëvF"ڬv-b ALUl2ɫ.$fwSe]OωLut-V-zTKY0 Ȳ|51 y>@vH FQ&4h҆Sf8f{B ˏ8ЪZATc<6pjpx}˞ĖT@ a|$ C.i\lhJC,l'< O=Vd)Y>4z@3j)t.A4a_B#.9-*HTyؖ ȒCw7{牢s`8geLr_F7.W6wn`Ӹ.k[RS;!5&<4ޡ7'%Uy5;l9dEF!T`١ F֍SӗC_.!,'thփ/7NFGmd1 {tb9gt]-*x:0d!VD:0]JPn W5j<찭by0fлϹx۲kr%]{KTjחպJK&Yu#WԨUϿ1m–Wsֳ!5,<7N{wqƾNx67<ʟKCxh(0S&J˭jGoܨVx@aG+Y905D2 VM0祐f&=?聃I8Ol1\y @?'L*b\#ڕG;|d{=?P݉/.ÛnK-#.hF1;RlNcnpG͡hS#tlz̉ > ֿG:N'*e=֜`VZ̺ ];ahѴqB!~b#>0 NYnfO2d_tRo94 X*sL-LIv)xd9K~!A@ھ5H_hB lT nh:,N_f %U s' p@ ,-@ \^{@ @ Tj^m{  @ Q {F/pO 1 a@ p%@A,V9Nt:=\QV-1aS0/_gǭT^ypQV e.A z̓h*9&?,hvG=ɒ-c7ŠƳ|^kՌ϶#H_,aٍ˂eX@= Q2>S:}tZdD-s'Kȱշ9͜qKEMµM%?,_^>;LÁ[T}f~TUR]O}&H>Ī3O |yEU]O?UZz.ԥg,9 +&2JS{ V1}%CvlV(WIRbϭ! TaTܰ@!m_Oാ1~ĔL!sIGY8ƙ !n8PXb ~bR3Kqulb?TmB$=O~DkT>#+i?foZfj|46{7?2<;#-HɭTèr[HtAεI+~/ۚ/5iK jm*mf: $L `Iɫ[EO1萰Ɛ{ev<l)4z@D˾3sC\$]dž8_ހDxI:3gRw>GY87Ɵj a>ԵΝ LjL+N> s[F˞ET|Z闯|T8Ĉ^~qZJɝ|v773eliߝ7$! `1Bx91_V?#*| /p1Z̜He2|~I,'` Z{~P}?Iz袎B9q~w Xh R4o|To3A\ 1a}FW'U$Qٵx!;#LKOY`sMoӡ9{+l;P_OB>H Ēw!/l `@~/%ƾXbE))<*yQ2c -h#ec  %_1_`yIw` _)p4ڿ|,x7%&ڟ:149#ۖ0+jC'O7E%~P 5bļx2/~A ׮_u8}i OCX7Hֿ5|[Yǘ._%АN.<φmg{ $LkD>#%9Rݜ cPMU{1iӢ -vVI:浆1zg V/Mb+enBHfe/uR~dnESV"L]6ƍdʐ(V\x42Zxyj>vTk8oPve4b{Ь 6J,=`c_e쏹dE^JDp:I͓ )$&e+QQҾW=~g\:tj&nq䵀.eD?@i97d:f構ye`:{k W|*\:q~ܶG3`(|׍_Q`YUOOKr#t3/:}aQ^z,H-R³J|0; bŽ6ӽ~NO[WTG]˟V!_T1hm>hxC壋1}~(~˗d~Uv/ g唹\ʰ9Fab_(:~kbٜB?ڋ)\c.4rwa/'P+Ɔžyc|Qd";/l]hR-%|Lr미¤ǘIUi΍bVd2"b߀Uk*]#ڃ]/uh"/5%n%_`Ӳ#̝_: WڣUt JFvcp@J &IV%P^+ӡtDX\|Fͩib3%RvykW2.$GJl;~A`'5dEsYGoy4?ܫ&v*KP.$}oG\B9.vf_IiDq!2kuIGįv<7 ;O?·+q0ב~ݴL7䅷&3},kXI,".i㎅ƽ|5TkOp2dS[t4Tm@:NnNn!Li{S9KԏȮۉU%㍕OQUR9CEpȫP D_E?Kqzn`ȋH _OaDUs'^UMҋIY_w%-{+mEмm%?BWUj`'q'uwH˗kHεk&5VJ@&rw ӱl;O4V{ 49(5&NskNܥ1j m} Xak0*[=aƭl \ _L۹KH<5 f/Yk/=Io>xH['(kѤVk*6$jGOpV,qٮZObL_Ȩ$/,{6#OxҠic7hNIoo_1i92m\q1KRtV2Y1VE&_'+,/ؒr" *{,he I#F dK^/!Ùd#FT𾩁\d%f('ud)OG^Y֑ 3SW|z4b)0hhA ; |K_W򑰮مC{;az)~ɩl)Wt8b0N'Q[rxGD$*Ew.5n۱.YަkhHgS]OњbʮR" pbo$w5}xt$N>.6ɊK7-}Ҿq3FpA[] >[A*|F:ڿFʯR'=.`p+$$ ~j|/ dR'eHa[YaBC7Οr&Fo[Ō*$jtJh[uyQc*:I /gqu2/NW߬ dQJVt[dܯ6~(VDX @"|wG+.}E5ZDOX!nSCFɇ1L\t$}y<"$ǐ$.aFv=c'3?liiS`x 7u[t]S>|VJ.5sGpLx0P%IEFF-,Igm$&<5$k{zMb'׋2 8:eM#31%W\g,e]OωLut-V-z˿!+\N6(~hQOL @dE&WG{Y&xx_1)&m߯{qVVygK VPTn)_|ez~Ao. </K޾d2aQ5kB&m8;m֌cƾ8Ҿڿ(ʍ \tSBOfdʽҥƐJHUW?c% G-\].Oj|UߣGgI#slPV% !-iN&+,28u[aE&IYB HrTs!aGEMvtOP> ALUl2ɫ.$fg,}]sS- Dy]=N`w\b' BU% IDAT:`s9W-K+0f:?Iܲ9 ,1i2o,rv982% l2b˫UAtVϝt=Z{*N6)gsV 6uq,bNshs4yC jk;8xtQ4)SbrohOҕ[>cZ>A#{J[|,#i"ӵȨvqSK/tw %44<>Gj˩3b\3y6:A՞y3¹D txMKӮf0Q%L$%G1n7Wfak|&O}9{+MYRR}ѥsNYgS K:ױNe8gZk^;kTek=ZIΌVU]U[?XQl/U:Y{q7~=~Pvx3G&aHB4<_Ϲ`uWCJJjwz`v3'%dI.t =_#፷7^WݲOCW[R<_e g\NC-΢ހAts>8 g}-/RBBiאJyw7agw 䌋m克{cz jյb(|7|rcW`m# w:Ѹ*$=:0uGNϠ]yj6zGq1ɜ6d5o/^0\PDM<׹9VQך3.[׽%N* Kj]3-fMϋx?4VGrf:{7~?~븄r9>uTb_ʬ%m$Guo6AÕq;9Ȳq>x9{ͺ9!eμdwcJը|JMS'Q8|x I__Uh;m^vի=u&G%R z/lHmz_vƭRM=[RQUo[yn>y4DUFx~co q1̌o% Kgɥb݈8s1dyr#_}wz5]I8#aڕ3C Pj5\m# i9mj$Z;n^> =v`Y4"P"F95/T:3)"e049ܿ?6agFm~>}]uy=ւf;ve5)3s/yo, 7֚[oO 2LVI'Q~6:X~~άg2 FuBcH_2\ٻܐ ^/|EK W,xs8#Eqh4H&B6!Λq4,@`' |dd'@x&t}_ulo+RNna}\3e!-~͉Y1Cf<|/r*Рp^wCq~*n} ݂/@?KHL h9k |[Rw.A5pfͺ9yh7|e|c~G_[z)$翄ǟJ1L`z-FT޿*,q19,Aq&;][8WhnY5J*waʷo-~U_r s~#Df*j gWs>^YT:/} z8j0$d׼OY}(֨`WDl0yor'0q6p(:>*MJ6jj[Դh%?\a!7Tū1]T_MZOu˞~[ϟILlu\R?$hgu6owuajrYo%u]NU!c6ߍCT \m+“0I}H)u}maRR?B܃Ac8Yz⻍r|R~i~Js?DAG$yw@ XT3`bPWȜ`C܅q}ڥ[TѤ/SK6rbٹGBhٸ>DF8C ?^* Bq B!B E!"x(Ae0 C[-5efP:6yi]Ŭ cZHB!LIcQB& dfD`w.h ܱko#_,t+ݱGK'݈1b~+Syl|? hhޝ3y2J2JB!0F,a⢢ݪq+rdz}զ*VGyQH(B!$`,_ 9w{";gȱ sx(í;2HNTJh/;׆ȭ|5s5ቹGbt}1t.[9Zl?j1C/&$Eh&c+0i[M+GX(86 S|2t5Q&7ZO6qԻ \!v'.doBL~=:Rs6Jh ůc4PMΘB!(bsVbuKF3(CŔcD[ )$/[RMs?M?Pcֺ1C:zQOS7iOֻv!‘:=MkckӚvP-sըS1 TGMkm;iP &]B!0FXϒtxf}W';͝QQs~/Wp);l3Q\oV&sр?ms|Jv#n֬:MT^r9@fI'Y8Rr=|/daΉ#|O V~q7ήwʥԂs4\"|\;@`VfH< ӔB!D'SR-CO\u͸6-Z" - g~+n/ nI2İ!+JeM$LV$!TuѡQJ!"6#<*qHգ·az`ǘI>\dAoUPEg#9B&s0F_Skg|+GHI[V!B!c9S z fR088\O"`KjzY~ZV[TxCc̲e1r19+,q@㖊Vde.V{\؏_7~"$hB!LIoVxWDIm٤&&cGVu3)Z]qw8jPVkFϩ@*vy!W5Wf*r͐lsđ2 _Cx&|] .Ex{S%j^ǭzB!RvFuP&˰8m-[uy.h87q%@L1o\RjD~xzףS͐u3գWKzMvvNeR83/gG32fw2O?CUKڷRs` ~Z#pΦkkF3B!ɔT{٨[ЫUlPӢ _?pq&΋gz '5SVJ)Co4ؽ69>֤D~9F:&| zN=Iˎ7=!na25pn1?Abge ?>}DalYl̉~KܝRi̍;qTlE+!Bo5+I$@U-YݵM]xgZiE.:U$I$I$ITJ! rq5=5pm[xՎMƊE9lB[6QǯFO%kU ʼA?=ȉ]_eJƋ/PO9i)4. !BҊwڝkΌx9ܵu i1j)F?K52N+X.k;XO.gL8I$LqM=/A=_4SrI$IiB!B2CQP+[#vlSNʭSd$]%!11İ!+]ߕŲDFT$ƻ~5|;ny Z6S[5f(ڪ;YU{B!0d20q5&sƔ8Rq^93tpΡƒYbG:2ICŘuј9g=sʴ|u["RǘKC^[b|)Gq9^́ɾc0(r:B!ĿLޒjyHIsxQH8-_25>]I9LVE+K̉Y1Cf<;հ dL;OG_MA'f3(Z6G!B딍C.݂&x8~&N|k-^|̗O1yRJ2B!_q} b`hwtgǮY6qe_(ۮ2bZTB!ȔT!ȕf+#kKʔteLjU!BH(D9`e]$5!B!*B!BF!B!0 !Jȫ5rV0k _GYS!BhVk{ opӑoxJ u5v 4Vw}Ƕpts%B!c1ܷ!i7 .c:֐˿R]BJ~-h5m]+*!BTf0"ƂA@ /m{rݹ+=p-E)q'p BOܾ]W߂gwfy+I q:D5nԢ *[C)L.3O `uo±U r !Br!uu`LOW`t0 ׀Iu .PN_W!|7|Ȋ9ӡ0wZ3`+o_vlm;BzC%4$Qo🚰s-aޟ~^}\ߟga^(= lJj?.oN¥zy:W5+ ~S蝡11j.B!t@9Imlf} 51GXGn^B!O0#,IF ʛ+P 52~dlzjόwl/1LN_RqksM.dj`W!Z{hOW_Y#sdiIdÎQ*4 ,PWPL+駡PhXօ! _ߦl 96M!BѦ6ELL 8 @w$w @B1GW\HHf WԼiy[EokMt(]%h y%YӸ ?$|!n'r&A ]{ !Z'p@R Ti;B!(3O@}`xh?}p"9> _x;XyU < OTU \t]G†W' P4|ZJ: B|sww5 2Yǐ Wh8XU5ê_i_xx{@@7X%x){/X.ܾbAߌ'3`Ex[>NfiԔu7B(7!_`/w;`-\>c@\P֏46Q#Fy 5!+ !U!:] ie3_y[ۖ8 apk 9p7w}@з"hT8}Fo=`,,u z˨pR!$F!埲q}ڥ[ԄѸ' X}6/ cga ޫB!D)q}H*PZ#6U ˴I Bh˿{eB!Ba= z|B!$`B4녽H$d\~6 Z:o]:f*ABQ X07խ] !)GDm}Dal+Eb5r4YSC!eq}ڥ[ԄB<nf|p01ioB!JCdJBS}ma, !l)B:>CBQvB!B B!BH(B!BF!k-!,l-'7mh=9Y]`bKsT Y Q,B&-ݶ.ׄFXW-"Z}INxiK6y j]Ŭ cZHBQ{r >-Q Sj;MbdLг5쨅N c_VJl"ڼ5i4[lXQX͜>,?gZ5N)eg巭ch=A_GzY)nәOwX dDWm#|٣+ӳ[!]x~"߹4|žvPh⍭NO_d 1?}Ǖoq\2x4NۊO$y E|m(6`GSdK*3kZƇOwx_koakߦT5=A3?[,[H˜/'FS \*NXo"P ;O%LX{ΜI|Zi44Oq=?+PRw?lzʶQ#`tpwt(g$XB!#FIˮd昼Dd~5opQdVoɄZhOqj-ؑArr&&R4MfЁ>;qgW8s5s Ѥãy/tnʓUЛRm3_-ʙtkLǙ $zZ>:uE7!_+WISWb~|a/LgQI ,Xj؉O&zy+aq+~4^kꋣb$̚ _+*"Ʒݴ*7ov46mimɟX9o ]VRb\_LH&gM*Vc͘bATC2eV]X{Sx b|'PD4tlsebJDԹsdsϤqn*j{?x$s2)jG݊&ncŢI3`ՀTڟm2/ hmic67fyggAX\ع'I!'ZH4iu2BOǑfGA{% uS2 -ΈЊ>ọJqFi>vWv1}kcјPk|";SGDy%hɔ|]ުyIu[*ԥJ޾NjF[qYlz*Hrou-5z|z'Y1C^ B̨M\4޺I-o)P~T84n]uT2/WD.4_::ng$TiOb{uݻ~Ԣ+E?$^xz*ף&ٵ6՝4O,~اiP &]B!Fc;kEC~"A-m'2ImWmیZ ;~V}+`Ş)W܍9D蛿o9MLjR1{I=Mnk4/(yޥ*.J*RM֟9JvJA2kV=KwR}Qlob,'o_359Ϝֽ\bFW.8uJ8ct~^Ϟ K;fyeM(-vxs`?l2NP+L ybQڴm䷉΄ n#nfY]Q+8Sv:">uɛy)*J1qxZٜ9GfޅnLD -qAbq+XդYm$  !Q((-x0gX<)JR~#P{eh|uԭgz 1lRH܎h5!ױ u_\UU**W=>/R|*ƻaTs-r*~a* LysT"F~K,9c/kg|+GHI[c$`B!ƜL&co>whL#?쵐C1]x8jxb 0c$*C fjmMzYxia f]m8+,q@1U,ٿ) ]=?H%0?˫qyYz?} _vLY>>{IiFM'ݘxXS%Us(Yv峸{&twU>cR4fgu7XqqǾq,YS1dqj߄چkӗ_ΐc9Wab;zf*BGLv~\/FtSHQѺ57xI=@$O9~!*ʴ|u[zi09DoVK*[AK\6SI7t(XžQ\x/udLӼ#J/|zw^'pP0]QӇF;,bU>O83/gG+ ʧFqvlNA,8:VƯZ5H~޸X=1lw#Noz4;{/V-_%ֵ.67Nlϗf !LI-F@q%h4?sJN2Njp3n~eF{f%ŸLЧO>o[!^it^>^>ʏFT;ܘ!Xm.̉~KɲGM'b$D 'V1iّ7T;V1TAnFMULp̖ǟ>fsw@Ov)'`ڱӟu,oGON,2 e 3zNf#)D6mzhyIUmE4sC\yy|+ظ>D+'IңUWW+rZNžޢjsI%owuajryhUW TTET$I$q}*_ +~1MwK6 wf$tx4ŀMyzS Qm櫥[9~iӻ╗a8w^UXGBǺnbhB&ke4iJ7ܽ\a/LgQI ,Xj؉O&zy+aq+~4^kꋣb$̚ _D0Mt{0kb+["(ž~ ٮwQl[OkNykš.aDWxf~8éj称zaLGBDg-wڝkΌx9ܵ;ڥg2p*5Q4Zel`Ɗ={!l}3W:ߜ&6#!{|5k_R%KwM."6<GݬYu mn{ktz&v_œGn_3Bb|4S%_qMF~[8~ e֪t~^ϞK~R7>7i-yjƔ&fLY4r7F0`j{Ww]7J#=8j&&PF쏿m ?_81iTVAՌhiorUWϩ@*vyW5WfygL9᝛Y1&ʤzSۗN(9cR4fgu78pq7jE]nL:k뗸lpޓnPy/y#%II]/uE[9\ɊwCEu3գWKzMvvNeZg+{] wi^ˁ IDATւ,755дc#u zgFoؼ:ЏJ>4@aAXX).;cUGxϫ=y|yW3NXZ/Q&z>RGJX)*9qb|bXrע-5 lf4zB!J7Z j$9KШii $抬Q(hgYґ }U0KeXNm$Ou=s~VmnLY,e bDo?KP@ܿ%dl YؓAo+>եǐS݇5W1uùP7' |dd'@x&ԬLN/4d ]CľM$W ~ՖLJw)6XY)<3Lulo+RNna}_s^x7 t咵쳡af@,`$=#C٦B 820x" q~!};oڷo[B<:dY In$EU`:ʪ.c_W}ol5Jj!괗=U#\z@G>Ъ^LS/wI$I$I&`Wc$ x崤jzk\ +9②IN[ˑ}+Bv5ֲ|h-lbBs2%U[.|j"aW̓.)b\^=IY6 ˤBBH(\0^jB!$SRB!BH(B!LT￀Eϴ'0K9YN/B mi߶.ׄFXW-gh>GG.X7RQ`}INxisָ],>-=}H|W?)[j̠jwPoi{ʿuuuδ;c©'q0]N}9ujPA{cҳ֥>}7J)1'W{|RWS'ԚL5cas`ц{_P^&3oXsv|j)#|٣+ӳ[ߘS͗W֐Ĺ71g6b x?r>maIx{<{dDWGZJǍzйU =dslZxC)9b}*o׎1v\& dfDOBG]ʰl?cE si =j}4,*ܟ/GK'݈! b~+SylbF*LXtVpYy&/|}&oQ5X/4N,7,{&-W ={.⌔;O|Y';1髳d9=F`SoH:CbK@E`ml]7bz9לc(7ϯK9j$-.V?=?v}?>}GWQu -! B/tE|}A,HgAT)A}-4Q@APBI! : 4f$s3s>gfξERXRɵ%iZDJZLM|fپo쟮U =oؗyYk??=ay :"azM u{5:-%ߌC_] ь. sm**q#8pvG#ܕXſrP-dg4>3 ]h ^3^\̄Ŭ,kf2v`4B[ʑ-x.2,ޟNßdTuyl#_-XnvCC{i[˯0/ĭ|"Ylǹ ,FLQ]vm_̞b+| :@7t"'W>`93|&˯Zm4O B@bvTjG/fJ$c1C&/p`{~eoOlimx?EQ*]Y?23]hY׉U϶| zF@'.(om_9x4]1pcmѾ?._i-Kb/m&1k8ԏna>ť}(~ 'ݝY$~$T`rhlro{)wGY2腢֙Y*3^UUM 6:*ݚ?UeRKt6oEuL&6:]˻$;KLt4ŗ^<:.vGaGY}wח!_Qobs٬IVCl.B1s3L|i GcpQ쨿SC:ߢ'~+j~KBJ3xI>%r8AGpMBpH:Y-cxu쾃yS'w޿~]?-q=YV ];1'|axdΘa 6a/ll_3,{O|;? |;O9 |T7ztiFgS:)qsCҳtޓЂ}l3Tl*C峻ѿlF+?8:S`%S J3ZbyDK°6xko_u4g! _Y|[_PZq26EwlV4 _1&Pg"f2yDİIL#E;_T|AF0c(n_sũ owȊr"banOS ,s3KOrc>D[㉩$G![+ҳ%l:OJR[V"^wnkn9S<7ǫ~t g͖W\[tp%l?Ik!Msz$ʤNP#u*TgڿU;bHϺT|6_1W SIN֊j׸h&+5ݴRYE_3g-bgB"3n'H>zG]<׿R2a5>=S1?xlFDj-ΥG5P)Nn8PLnAw#Gg:ȅLH8# 7 $RF9 /s*g,(2܍ZxZٸw3挓$Z6ԭ;Mݍ5l9[36cɮ*к/Sqo/f\>[˷}T +z5s<<*z|Bpʩ>e&6\әMtt FL9O1a1_bmF??H˞բx7K޶r$ǟ[܆s6rථ{\-狤82^yWebvOo ?2?&|;_Պhi+1IJoZ o^D.!8۱_cDzmmh#mDUd*{a+oLީ_0=dY]}quM}CGO_|]U@XjUu%[Uύ:>n 1g|x`Ό&MC[^k z-U5s;;FYv'%5X+g0r4NO b׿#. GH5rgn$8ep'u ;ٽѳ~GPw]q8Q|{ǜHL6:ї*m_ Zа/!Ky^o'DXڎbtG8vgM[U~գxk~ǭA(xq0k 5qxŅ,|o M*3\V}g{F?9>Z,{)=9aW"5~j|3{}BBKfhh(!Ax;(gOϷj^+Zͮ34iWƗZ|ᒸE@۠AW-9uم厡1{V7\K{M"<;g80 댆"R"7"1[|Szc>so}q8ַěKMb0@gKƎ}Y=њ282vYJcgN㌜6\Ok&MYP37BT%P ۬=3߸<0ɉ>V*lS_)Wc M>h9)>-_/b쨇xSN˥uHݾeUS*fl+K~ʮyL&CI>g ԽZQP<ŀjeb'h8I_:C vNRMwi69|@α?ɴRr۹Z3vlL0/'qcm_ѓ# 5xw*{6ʧa`'m2N8ua=vYۧF?lfmOFtmB&sa1c§Dw[+Gd*sܫlVe+~P,ƒ?U6>մU+IZcvӞeeY?7Jo\oiFD.hh՗{I߳|s7|ՒQm:nSac*W-O.^j|RuՁTTWVfl2If#L2t>:Ց!W7~x]ەj-x\TRWW6|YX|R?q jOPf"I|WP "Y0^\zU:ͽ9SKt<7K^~^'K#j#1nA#(hKXpM$_ȧױd߮T>K%0!;U胹sĝ c"[V'XB%K]vemLB!BԆQaB!BqU0at鸅|T>L`d(Wx|V]m""">bD}|Z~!@[2p{,x5tc!Ba<2A y=Fa3%(8dl֔dRLUM.I+xsdxcĔ SQ-'Әi,W2{Q$E(\P1Z_{RE䩠 ` bs>"ؕtVM|HP7-d]ɢj{*-ʉS~κt,w0)bM^k2_6,$B!Axw+Yx|څyZt`˼N4B&ZݛIˉ9?2 dga9+ɱDg1h }D.I|Rѥa.XŶS%CH.oO.>$Wt|/D^6q.7f -ElOoaę^*ݙHgOb u扡]hޒCε|*Ta4mx?Eؕδ{q1N&Kg֯It$cj v[,}BQ` ̬m_Mܗ+a]\CdB!Лe '_eْѡ|*-($\,de7g8W5=~yͻ…{0|mRgҌϞ呇u^gݹ!lY)x$` g Q?|)0 IDAT%ɋ[>7]';7u2~W C5Hy=6)FUiL&ߚŏsgYNȄv*\>-:,\J~q}ZC6!B! cue xeٞ+%sQt^-8(pZYLE{KԼ,_qot;̘8ǩɣ޻J.gs+sJ5q1[qi0&|B{z6m8ȩTRbvú8n5'W1yz_ +W>8@)S7@:{~NZP(M45R+aTY$ :;Ҫ}[Z}aoo1}+./-39njlD,^b,6|g4w.k=o1nli]\ͣޜ?9s}5:)RzZLt,caL˖ӄ@'oھ%M Xʭ_EʧlǘiCKsEӚX㤗G !BIcPx60x<ͫ[=}J~[& ׬ex>WȉcqG9>@=ӾZK19jeTA|=Cv)~anD{twcKkΘic>KB [g J{TՊY-V* UsSlHJpna~Oqm𗞥яx%"«T@qrÁbra !BICC0fLlȦ7e w (n[t].Y{JqF J0n'hR,h裃~-!mLنVp? 4j^Mh&> ^IVVt>{fΊ#ڍ /^ն3NhOP76^٪=SB2Ez~˟!4ǚBAB!hozUNbB SbJ>fHvY -Cܽ͛ȩ<vFIw}}Z9k7Zzn AV<9c2tE4 Έqq#'~jA48Ҥ_ |PLXڎbtG8E$i xWI:8m}덗]g H6qNw0{ìݒO&q!ԫLX<6e$ag|z{~y`5(i`_/ fa$t*B!(a.;y52WY7k7,Wph=٭/[?L{ )q` EDGoDc*t:.s>Qs|Y>iKoE8dqBtۙ|5C!/[)y/^Q,v|20d`4,!=8|&? o3L9D,(S#qFߘ1SԪ}W_b7%"[B!oW@-զ>:֪rtnR\ۨ?P &}L2$L2$LNRKREODjapp@iͱo`\*B!lKRE%XH $7B!Bܸ _3x>6s; .t1-S,B!00)?8!BQ!B!č0:tB>}* Gizʣo,NnD!BQ7vsÌ/yoA/bǜ' 5}#Vr8y)~)jMm1/8eBw)B!3Sk saP%·2pT&*bMe-^?3~ӛ&|^z9T h@`B!BHX[h;D, ])45s$lc) E3hB~/AJBA5YB!F%v3[l<řlk=ts.W 6xŏY˫2) >.Z2WC|ʍiQB!0F6%ܯQ'I9z$j0+4 jhga {^i֯0 !B!j\ZiOC ֢, p)^E{s2 -ղE3٤͘K#!B!$a%/\ De8ҨEDNoƸdLwjqǵQ1G||֑Q!B! cmxgө5ZgߓhLlGcM!$n3ƋπY X0gpzc6[(,B!B$0ڝPwgtqV@͋c7䗳*ILb2BxPdB!BIkgN`yy2WyyCoαSkx@Y^!B!rc!UlHO-p!B!jaSƬ=|P!B!] _3x>B!B! *9.m#B!ו(B!FIo3ׅ߰<׳CM<懶2 {^f/3 tVlGN]¡ÿ<>DT%B<]gYi%w[:toxK㪤Ǧ%)`T1DqTɬ#uy?])Zͺ-OvH7AѸG.}_.!'>v cٱiKڊS+FM_)fO7i=3Ws",MFPWCATu5dφhm{0{xЗ[=A/nZ4"4$uZ|Þ3(m_A.ѧaN%WBsN;ߕ|T\ZStm93Qh]s3,drߖ#DwE}o&|hD 4h5lضx5Ν@4>O`z~w x5l5|uԃ\QptrImmlouϾ:?lů\?Ϟ?>fm ;>|3|V|lߞ!΅$񥕊!7F8(^UB!$aClw ",#ۍH{TcUG^rneSY ߉^Fu1+N$7?kD%il&CÛα"Z7hKQ Tgǘ͎sVUUl*ʱ}ƚ4}rV'7 Ե$]}:`3 P4k߁b\\]Q c&_T\)c'b =)=37z>H!xjc;YCc#~tِ'y&Tr8q2GmVkSܔB2 , V9iH.JB!$ה8#8! PmacɤEڹ_3sCZ{wR]56_7dtQlm&bv1t Vꖛiۋho%zw"@q[[@\#c~28h!a4z0YXD'|#)YBAn^}oVFEWp>no !ne3Uǩ4 4?G-[lViP4zX0[˾@Ad!BHx8!Aڇc6ODVf{㬁F5x;)'q!ڊ K4rz/I@v:OF[ZN&Ŝϊ+ƌ|akLú-ٹ3.ۘ eWh]zޗ,y Lh[DP(EkҠQc+\ =NZ`(:g(4!BHx¹=3mC+51)D\Zw5t؊d[ſt2^s5bU^;NɥB!47K5}[il[cۙM&j׃!4$ u%9BE灿Wu] Gu=}q8_:v{'ߎPCau|pU(0z&K>qI]1$R4T К.uL8s$5ܲ/-}|nM!Ck4N!tl[j:4Kqӫ)d1l!~hG[zz_As& Ҩ ~:.-e3~@W݂єZ@qՎ؊cJD_Oe|qȏ"j[q'DݏBq4OI͍븚[j5mwTNM3Ο{;ZX{О okm=z}[aO Ǧ%)3NG=9ڏg_p.e>D͕cDf} qO3u#Ŝ9g8a =q3.=d&z a[9Ɂd, a-4n ]]QBR73b?)&* N&РJ{EЭ3W>J?b6ud[}\N$ѣqvFwXy7sY0uEDD|ĈziB!B:t@tng[:i7t"}UD,;S&794yOWVkut `9vt,!o勛w):;cevB!n& 1Sk saP%\^@VNsŦc QOk ϯ(B!BHxs3&GY2ߏ` ̬m_M'Hjq…BM/oPC뉧yKC3y i<={#SFpj!O;Y*h<0 n9/~ԣ\[/o[@ƎL^hR9e9Ew>>aw4])̎,\+ Ug4>3 ]h ^W1g47\V[+F23=Z-x$'ׯۧo?z: Q[SB汍|`;SM総{cp(| q+\W>[jO!0V-^}g R,?ÒN4=Ԭeo3՞ eKL65'|aQ>̒qSxڛ`M̛L\]#/g.`/Eَt.nZȰ>%kqOgڌύ祱 L6jo~v!{һ;7vc.V{G5SNQEfY45%`wnzmY(x$`_Ǚmx&HRw˯O-~g=5_q~c/򣎒~kCdbaiU ֵ%][ :2_e=d+2:8}vYyscK.O&V j]Gӄ@'oھ%cX-^&b,6峥B! c3|" xh҄Qqm𗞥яx%"BFJQr>6Ѫ]WF4KcFSU+B+ײJQ=XWc!sg,̠;q#lݸ [kc~5ȸS"=܈4ZkZ^WW˷EK,OΆ4վqTP2} !BuErnL80dN?S潍>>PHffA{9'}[bٷWv]BpޘBQUѠp82AufeW8{:_k~)FOB]PbrPQp˜< &Ls:-n\2g3%9+ovϠAy? glUgU|bٶȴmhe zJ,{.IJ|-_fjOǜqDKچ1-}Vt8*F7nbr+qB!9y~r8}:YX : S{rzVMC^;XsC2|O;}rwtxŅ,|o M"B ~P,loѵ3 }8υ>%P+b2z~TwAc﮾֌,[{;&I\x-5̣'y8 'ص; KH56Aү̝0v֔ߖD~_>ޘ+\[_@0q%o97 3n/`q:ʬ_3*39d?+9rq؃;4;T`jW._-~"-;ŏ3r sSN<)J[>S%%DD|76_D!BQ7vsÌ/yů.bǜ' 4$FьZ0qF:^n j82#ʾ%B!BI730wm&L^R"kQ6|? Pt'&*ILD5ORŜ}fn$aB!BHX[r2do GPԴo[{d˹Zp",H+"m!B!YЛ w#"X:[{:W{O2 P_As{ WV^B!B$gf&}׷,x3z |xyݹ{ k!EQ\0v2]iwҍ8B!BI'#qwר{}Ȝ~=kL2zF٠C}<7qm=qB^ooUc$ bʾ}Exв-|ƈ3|`aJS:<ߤr;l0cCy\i_DgxFh鎹zq0cpNJ=0S6k?!cs^yo$cS.1Ǩ?hmm Ǐ!yŚTL)JDqk o Cb9r-#SCOIwgœY3v4K6DY|3ǾՇ|?k1 [ ;I>3}.|=!]i 1{Y0vdvH(.O0e^ QSG䜱W>@c}f77T8y~mҲVcL(K+{?oue2#c>-0r+c+W3?kǰzcQ~8e>2zX( _MB\-tuh֕j~9-uWQ^:/:uO/cX$zbNҙz?@u3}7)c1`>{>hZmf*!k&}kлm 1h8 :q?\b)s3ǜ0dnr&u+(P $F1j21ap^/їx"s=+odۥTß1f9PhdF=3cĨ)ڊcҴ]5@jBBR&v:+:nBҶM˾{._[6h5;y,N_5ۺd+rpҖS vj2jd'jia.HOs(&,mVxt{W_bل:b<6! oA:2~/1zMlg7umH7ˣYF94o:>X=?IRpj̣-UbQD23_ cZJ~-} eiS$ "Уa-]<8_fh+I+к6iI+'~*܎>![\e]+Ec.(|xf:#1~KFYR\5r ?u50x"Y~sPP3BX1oަ[V2ZROۿ-߲ΣZT'9n+ F58Wf,]9F {:^ l}ځS+~`׹XbaŲضF,i'KJ3:kwյ|t/gcr%(WBd(MIޯTqZO𘻅H8N͜lO?zfٶAβ~;.>Ī牺xDb+cH8ɉ0N&}oE%$w bpDc{| ]4e>3/{9΅ą䧍k_/԰1|5*fW|/pϸWvBH4ED\yb&ouB-ur* ҵ?~XˡXX#%9oYcOT.!#qW:)7W?E mZ3FI1N1hg/ۥ1.SIb#4c$◫-oK=j* p|FK+Kg Rҍ )Hִt3Seh/yDÕiCrV{ ѽ=~d(]k?˥G#ɏrlFD{)-nE/7%i3hlo4>fiHjejZVu3g.&N l ;}z篘ֵu7$Roow gxV'<@F8r9l=X^Ѐj-x)85f!i!<14q=Szv].و|OˈkRD" e>s˷~T#Vw:k"*]W7nX1Ϲğ x= B!2aa>5cRW3otxWpNϏ΅J#m>XXGqK;MXs")9D3V7Εx9[~̢iq3~n$#[&TEt!56tLߝMY/ɍ`߱<:6iƘ#,$WgEs7_׸tS9L6ZZvݕk!Mpq?߲֟9Y2wy77O2ecpZ!kָDI­W->ʔımqjם.O7&.r,<~(WQ-j??)j4>ov~RqFݳ\GXbƨQ&p_S+j4s\#z<3/N;?e<>6F3/y`  Y?;akʛFGir=k-oN%!"etjAm ДC;=A&l !-G6q/__ZԷ5veyě^=ڃFWNNJsKzScJ|!-(%g"~qlN?SLe>s˷~rc9cO>W ]?Ҕq+Z4oT+l:׏M\yUz>Ѡ"~w}+~2'XGu{7zDD S\[bgIRJA8T+A,+u֛^-y~`;OD̊oIRcHVhkJךzO&wA-VoHjx-d(je_,너7 B^1iqVt0sovV^t>Q8o*.]ggk /`A4.Ioy~bΟb20y^&>ˈRǓ>DC&ymFwm{o}eRYS'SCqƩ#}rpOͧVeW Y9,=)||߲Q38xF58ŵ1XOGkG$nyY=5^Ky6xI][ǃYFV1[mMy]::Ŗ^>xץNA[ }4Q?w|;˖_98nͳ/ vh&8YDO;εvҦ%l}p$ӗy1t(ٯ-̘0xLV>.Zyfd>y`(N3%:z8i .oA1{l,>q SeCjffݗ2n[X?(6/\O1 7_.gLҮPay\Xf3xLFL؟?2\ݿWeiwT.]/އ*Xh¡KG0v-$@`1$s/?Mf-Bn9]Nw~bw4&&f$,f)6f9|?U7~Uyi }k٣QӉ8/oft )x,XcUb<=.w?fJۇ~s>5CIFL{z~eEkY+m+w{_eE;N5=C˒_n{pTiSNf~!~(eW]dٲ"_1 ǔ oI1Ƶ5iѮ;PO7s渎d/诤q~\>;mG9rȔ=Vf+~ySc>;1zg SHsxE ; 8{-=PA'on[m> IDATMdʓ]#I]Tl_w' ufOwU[TۯR:y um-AU?gmܡ:bWjtV[VSJ|+ZK1Y.v,֭ R0hK%cK}Hg uKwc]3Ƭ&88+|a9ŎC1;玛aHB!$at& G:8es4 WdEbXrK#kWY4Go}__/PZNCKO%:̈́B!$a"oE|culj˅-L_h>w(JYI>µP6D:3bG y)/^M1\!B{O^Q]OˊeF^{sFiL=}kÔͨ:Ob=Ydc,[}cD[ ;I~̭A_\zB<bxB|qaoNMSڰ1l^5}͌i`S%drZ,,=sx,וֹBvXxF-'܂Q;Λ mSM1}MsdCq*M&61f/VҨ:c*lop!.dfz_Y;=>N.Aw[٫9bY|ߒAW6m]JZR38{m:yٗB!=%#%+1bQ-6vV,s9fiH(֎ `ml\Ur Z)e'AKx NxMyL@聻u*'c˫FUsVw_G=\6/gPNW <@JTRTL(Cj/Zril~ɗn.\?Uo;4?=dӨ޾;6&e{3ĹaaRIQJyc,_)Ώ0`L&tuG[&Sk̠q񽰔q/ @RICA-P^E%4rѦGuĚrL!Bc2hs퍃mk&ώ`4T@׸t9LrBZ\]'Lw U`U8<_N{GMUǧ=Jx** v>8r9l=XcZ-GJ-:ImGi}bntS=F27Ư<-5|=UbP͗$b8>ov~RqƮw+~}K4H#BqyVN1DO1qW Yߺ旖Ku֛^-y~`;ODjA|߲Q38xF58[ŵ1)B!dGfv(<ɈiO{گL2._̀9LxX>r,jbLX5#XZ>w)`&>7bsp ?wǹvܯҦ%l}p$ӗy1tސ:մϙ,^|V(3$B!0VlO7\)4۾Q (n-y|H,#=Gn9&1^ $B!BI+Q[cYc}o0&qtڛ 'A>n⇋W7>;gg"%%c@T#&!B!D{K-?)WR5yS$>GJPW+fh4z. !B!*0Z-?kx8oMgk$\ek4]SGzIB!BHxU;zn$OI}VzG=5F`7aGvdkK65uɖ(IB!J.I4]lo& ` Օ :\O3qV1giy.|>e3D'"B!@2hs;I#/q> EAEwKZ{HJ,CoTrN[HCFB!0sjN17ocA#%2YF51(Q!*!5ȏs/xSfW1WY`0io$B!B! c%fK!54O L&Pr=B!B(b+ƥb?̦H >aN65B!B#W[Ͷ]G5V"B!2XS|70I(B!HFB!BH(B!BF!B!0RjeFsԕ_+bG!udp !BH׌5EqM`R'*"}EAyľF@ց։5*U?zՖ/][GýGѼ&x\& lN!BIVtQ./|QxKtUֵol==$SS_lX]+eS[.lϧNfGA !Br'Wpӟ:Dzbx>hsvƞ,RR1V)8`gi{3쫜ڵy+ ՚w<۬Ƙ,F yw[uBgL% |.d; |II| +xҦ&aoͮX$;=>N.Aw[٫9bf #c_Dž9q7ɪpWXڴu%fc(j5sGЖÉ[f7*<6LiٌZÈ1TG!B{ЧH\9~%6 J4 iɁZygHekwhީ Kf1vuM`d$>K7]ע17ɏG_M𵓤:-ظѕc^EsoL,gR' X'5w_O#~UNbɐ*lEmv 4(QPtGQQ?*gIqmJ' bjcg1-LcB!$awgx{&N[5Z]7D*ndbd["y{\B2"o,*?mn蔫%ޔK{SBh끭C n$QMr}j]jH #ؕVpX%Gz8 ST@׸t9\el!5%$B!J^ai>@Lt4SL\5gοy4])?Y<+;ܶ n}J½50e\抾 N]/u֛^-y~`;OD 1$+^i恃Uѐ~0‰I|R %|ռlNU- 9Lt}o /:`(ヷW l Vƅ` 6B!*0IOfLU\s !BҒKRtUnl] \CΩ .-D!BF!Jcű@6K$B!(7rIB!BIB!BH(gap!B!$t8~[ }ksVpڨ/# 9xХUn_P~!B!ޔ}]y%[Ga穐Wʗp fUldM!^^/B!$aX?iCͺ{^ s~^bPT0T:> [FǗa@$ OY=tu`t' >D3aX؜Jgsf^›K5ܧ/M?BBTd\ T] Nઁ#+aW!B!$a" 11dߐ^#C:2 kG Ȇӟ7^+b%2AAaEx.| _\p`d\]<-_w^,K`ˁk 4̂EQ־\0h+# VlGBM6|;"o=PP:%$-66$9@QۇB!ʉ` t/ Tز e_}O _`s#0s\L&09<|s'Gk ξaxwieMl`1x=8ICCq8k a;I 4x Avգ0i$\O*/#{7ЉвlK-AYamvba_tDB!Bƻ"/m?A`zhdl8: ~e|.x?!:| o WnUՄ1fZ)eC3Gc_sv^π&0&c/.I*@B{W@ ƌH+1V!B!$aԴж=yZU߷~/m]h? }y &/[MU+n9Qp 7x"-ǓpIjR~"۵ג̴ڗ6OtOR5Z !B! c U4 WZ̓8f`S  NP!Lba-wsa[xZxBs,j/I-hyn>`^ZSe'p@r!B! c9?s>_@۔ _[Gb\ B "j6k pksjO:?<䕠=x瀥|zŗϦ(,M+򣁧ޅ`pMW~p U(B!1eݚ O@cխw)_} %>Q!B!Y&TBTۺP?%ɢB!$BTg%B!BF!# !B/" !B!Q!B!$B!B!$atwbW!LzZ)CqWUM{i&B!BTuЛgxI2rc[ 8k>:NׅB!0;EOˊeF^{s֝-I WB{HIɦrv<<~13/vYƉdK,]-&=3a f #Ic?Oޜd]3޺ (Tk7`rfֿ-ӿxv+e7E֎k\ IDATo8T\`ʼ@dɹ*P?B!BHXE>E eM d9iVH\6.Zi=ͤfcF"R_ їxbb>|$4uAUhdF5?dσG2|L*Q#~UNbɐ*2 ímC"'Ò+5C2T}uٳ/<*T?B!B@X-?kXv8tM-ݐetw:RK[ŚDN;ƕ,=g8t*cSzwұ%8E\l(V&? RS21B!Ŀh!5'h󧘸 j)2B%vޏ{@kldjCW)?Ys^'p؃>5'@LX5#|Ҧ%l}p$ӗy1tGH^ w~@HBSC!B)}J$pP _ɘ$$B!_jݚ $Ul<[C, !B! Q@Ω .qB!7B!B!$aB!B! B!BI=l{k +YX8~jDόyg9Y֕p/n+L[8!ԆB!BJ-&] IrYloxjp!֭bH1Z9IB!F.I-i[cY|, C:# 6WR ~-v5lG.*U1M(ԅB!Bʔ-?)WAyv:[>Ci Xԕn3LB!0VlOatO_òé+-zGVH:|6J!B!$awe7.`҈ vOԧK'wbw%D-ؓERR&o5:'%YB!BHx9 D}5gLtqKl=W^?e&}53tj4FIB!Ja,OJ5t 9ojP%[B!BT0a,s?| bCo֖2Y~?Zq*TB!BF65:;zq'K~ɫB!BHoK X(B!BrB!BIB!BH(B!Bƻ͊}4 5Il` ^:&XfY|ms_OWEy Rꅇ4EVW[ne/m͟σfLJX0|:}TZ;dpPdB!J0j]Y|&|3s"ۻU'Xʢ9~E{퀸ykyw$M4ch ;n{ϔ͑GV+g l2o&}tn}# {^ӕ6>#H""u*A;Z#-6t3BԌWVZ bT22Tq rOM.sH$ѐIL7wNZG:+"ڴM3{D7L93v{9ԽߓGzU$@ R j=7}LX=w9e6xt&-5^ y6o!{%2 1OOCh7'6R'křRar*Yw)|y*{D:00T*-+%у}sS".,=l0Ǜ=%!_|v(ٷ&اz99>e; &n^"9]y4 $txΉԣpOfNg[Kic}[spIBx&qOCw4C'H?y8cBU-ţS#6U~wrUî$*xNj.^lF`'ҷQT']c@-F{c;*hҞ!ѿƴ#VOeJrՌ /z4\G20*طdKcW}gDz%lM.W%W>jhXuPKNȂKO_0-)OV-lIYj~Q߆oW%tn=0g},)ŗK[~P2wRY62M_ at@[ŃYyF^C?l2Xy_K=c>y1ggFtxX:e /&RMy)ƜF%nTTG㷸TBJ$ID@ (Q՟y'V %Y1e"O!51~j3#3cc@C,L$Ot5Eh58.>25۸~ESf=nI=5}o ;1}o1p/)Kȱ7}9Q2(2gl3Ncr5\~i3ropIn͠5*c(FJ=eePk=w1s_n; kUGSmS.E\K*{wTA 6r੏#8}{ǒGf4_A^KO]ȳ;V׷c)'Э Yɾ:<7$rBboY4=RrU^Cɾeŵksv>ΰL¤$oVۿiJUIT9Rxn{L Kc䘠"% Qh1 6AяULA]ݱBn#6ƋηI]uHxJB𶑈ϋ!rŏ,gsoƽOp^baTxbMu(s+ Nאk^@  T?(g}y\- bBfO;5òj _ dP/=G>_þdeq02>ڛ9 '2IȟNh˅bnRrWaA}wN)\AT pTe9;ײygxۮa{cg7u<Գl[{'zQ,рOߗ̒#\I&34;O +Gl(!;oߤL 8#xcP\}sE+{ah2~wq7c/@ Ժb&u|!SvfWxGX}2'<-zzUD!Zt\Y^]^v|.&Z6FYF*7R^fD@gàP~%&0U9eF[aP/M¦ytmHY oN5 M/rdJ2uN˹ֿ3=',c}-uKfdp"Ӆ:%5w}eUٗ\F5(I#W䃇ɜ;%{r66Kp|fGJr5>\T/3ϛStQEufEm>_+77>*{(ϹN.OWFQ}J4kK-8 Ͻ%\޸#K9΋=ƆIGFNfLJDܪg#rLԋR@ xZZCɜ==ێMөy9I*l{rn>O!Pk]YP(me^Yu?jՆ3F|3"gzDc 4}hsY!eX`k(V@`ZlZ1S8 e3Z3wݝPcYE+Pc>#3|VܽYFF{OU%[ҢU/QG_e S\G18ZԪ,tŚbn uNOoH~<'@Yi͐Ypi9ojڈdi2 vT@ Ԡϑ)͢X֠{tSS:m مVMYΨ=B|YҠkJeѤU ύ:ɯ0 ~U/Eb J+@gy-vuG6W`BwO$er Izptt&Oɓ(^ic/aK&@s]ZC\^*X[X>*?C־?]YR5~8{Toc7B.FEUOCǯZk3$46>R~6 .oS˵E[:[:*)w5xʄװ߿y,6?ځ/f gL1@'s o@ ,` BڶEgrq E0?KSw/k62\ N]eU$I^tkA^'U9tYJ'!aՋ7^rW_xFjAS>5'7&et:ϗ3G۹W9Vhs^۟LEy: kh"w$oh+?m_F2z\>mn8M3TʮG44N #Y~p{YP$81c%Fz9}ʁu4=z#;)Q3?aTȵY-6ЊDqDF*W9avz:- 0 = T ;7L@[p灥FNzwgv$o$/>>$ya"U' y?>jYG~!]ߛ rWۺ2Pyw ;IؚH"$H"'O:mfiSºxVطxArPb1DE^`a瀣s3{iu CYd̒#/͋$jq>N*tϼDY{=|( @F}dKﱣh,Xgg D/L(B =` C%ZzaްSz}BW6@ ,yaB@ @_N?&1@l IENDB`anbox-0.0~git20191115/external/backward-cpp/doc/rude.png000066400000000000000000000140471356361734700226250ustar00rootroot00000000000000PNG  IHDR% 1gsRGBbKGD pHYs  tIME! aYIDATxy|Mw]"HCLlԾL `PEk2h_1v-U!̘h--CQ{b-$IDֻIrn$y|}s_gSڷkBX2Ԧq70g)uH+T{?邟> ؾz3*!N۵BQ!B!Ľ F;IB!B{z|_irYƷ86f̊H"##OrƧ=>!B!Qɍbϡd Guc X9NOf2w}C=x1w=эᬊ$r|&oA>dB!d_-d\ɢ22_1,؁sb],>7xZS21B!`H~}1+sf \q<|"~_Hǩx籌& 3 MaQ>AŃNS5љg!i.be i,c\X;n-͆2b8lNa;^Wd$[4]uf 1E?[vOZJp}iE^.b&;(fm|mkRp=h[]^'G`-zϐ^mE|&娚GWW%33KfWyЏV7WVRܞ$Lcf`W1GCdC+bڔkod7C9KaP>jUH2ˇB!6åxvbV4Y GX^m?q$KRz,׮cZ!B'ݯɫXaRrM]>Eԉ $\Z΋X ڕ1nz[?xK0/6?K!>kVWaYQ]/aRcؾb=K+o=J4/ω߲%.3eV3;|HpE($~2V<ʹ4Rc~Y֣vRGa"?NqQře7qL`3&*>8XPaU3:ӧi>{&KZ!B'iї_TG1d[Bnl tR0 G}?U+RRv>_ { n48N-F~NRYp8:vhJ<'p\M=Hb YFtB!x|qnJޕ$ILL$r2-/Ѳ<J3+W㹢VN5c_QT+bgITI-R sV%|LݑG8оv\y\:sP}Kk l.l*kyaPlJxWzc_ÅulLpXB^ZMX`([iΈ'J Wr\+&ckϖzib?!. !B _GLܛέ:>{];vB ?O|J~DG>T20]?i6,ZPۏykT(AFz?=o<Lgb/ʂ7p FA=oJz)&O@s}KO g|65;}K~ov.UɜJw MpõѦ9^f h^Ӟ^m*WȿV4Wxu7&\j"{E>hB!T{M\ܰ Øލٺ;s j@yjp |uĝɁE3vpޟٝĽߖDF2ecք 0nyE"&1#0ç)>Sb*}vj6qշP&obdQ*La9,fW 0j Z16a *=>[,nv~vP#L6.ZCQىiėg?b(ߦ .c /dJ˿f9>AiUi%_,d\ɢ*nG'Iyjݩ]>j_|~ ;XL!Bq̿uG,K0*.ui&b>c}OZJp}iEvU 1?6t0aūv2zz2Ƣ i֮L7;R5&O\Zzvt:?ƮX<IXǯz{D8J/q(>E89>_ &ǰ}*.T{Vz`^lle9B|׬9J4/\ :*yp&4Ǯflnv^ZLԮup&B7.cΣKJ#5ם!(I!+qb2I&NV,?CqWA n5qSqڝgUw}4R.bG|-*%&%DSDj*u sVLUD,([]/R7L(@5_Lbgk|KdᆟUG!BR0v#$l; ~ WxO0::5uTUSJΧc)7f -chl,Wa mzB:/1hPOZv3@.a9m":)8 d[YǑ_YI0`|Ǚ-ő]s+oɍ!6SzE;x~6K92.^ sE2SMު!>s! 8QB!c`=7%9#;e:Wa%/c3YURh;uԻm0?2nAM8! uجN9S ۺͬgWŪb7ޫ/-gX)';-+͆gs-_.GB!FTrvϒdFZ<6_Z:JެgWml}xI}ۏꭨ;6s $1EmBŀ{-/:r5 ɤVSq >p5q)j"z|V?9O.jq!<.9>U_s99#t+5\Kz36Wcq+i⻵t wk*B!ւ1G4]?K~W-׏vu T#ewJ=׎mfiGJ"CMc* Jqq'MyG9mϳ%*}\v_` r&fC6g8uK@[$o݇kSWH֩ YUjį_^_y W,!(B!Oӡ <@]$!4o D?{JԘzgel$@Mx~_!=߇1zdB!w[?M^=e.pݑhSҫ3w W[9ѬZq>%znϿ9*ŢB!РSRU2:i`0#fپ Yv.$ B!B!l-V0_ʄK%BNelL!BDŽ0 !퉌,uyHH$I! xB!Bs`IENDB`anbox-0.0~git20191115/external/backward-cpp/test/000077500000000000000000000000001356361734700213645ustar00rootroot00000000000000anbox-0.0~git20191115/external/backward-cpp/test/_test_main.cpp000066400000000000000000000074201356361734700242150ustar00rootroot00000000000000/* * _test_main.cpp * Copyright 2013 Google Inc. All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include "test.hpp" #include #include #ifndef __APPLE__ #include #endif #include #include #ifdef __APPLE__ #include void error(int status, int errnum, const char *format, ...) { fflush(stdout); fprintf(stderr, "%s: ", getprogname()); va_list args; va_start(args, format); vfprintf(stderr, format, args); va_end(args); if (errnum != 0) { fprintf(stderr, ": %s\n", strerror(errnum)); } else { fprintf(stderr, "\n"); } if (status != 0) { exit(status); } } #endif test::test_registry_t test::test_registry; using namespace test; bool run_test(TestBase& test) { printf("-- running test case: %s\n", test.name); fflush(stdout); pid_t child_pid = fork(); if (child_pid == 0) { exit(static_cast(test.run())); } if (child_pid == -1) { error(EXIT_FAILURE, 0, "unable to fork"); } int child_status = 0; waitpid(child_pid, &child_status, 0); test::TestStatus status; if (WIFEXITED(child_status)) { int exit_status = WEXITSTATUS(child_status); if (exit_status & ~test::STATUS_MASK) { status = test::FAILED; } else { status = static_cast(exit_status); } } else if (WIFSIGNALED(child_status)) { const int signum = WTERMSIG(child_status); printf("!! signal (%d) %s\n", signum, strsignal(signum)); switch (signum) { case SIGABRT: status = test::SIGNAL_ABORT; break; case SIGSEGV: case SIGBUS: status = test::SIGNAL_SEGFAULT; break; case SIGFPE: status = test::SIGNAL_DIVZERO; break; default: status = test::SIGNAL_UNCAUGHT; } } else { status = test::SUCCESS; } if (test.expected_status == test::FAILED) { return (status & test::FAILED); } if (test.expected_status == test::SIGNAL_UNCAUGHT) { return (status & test::SIGNAL_UNCAUGHT); } return status == test.expected_status; } int main(int argc, const char* const argv[]) { size_t success_cnt = 0; size_t total_cnt = 0; for (test_registry_t::iterator it = test_registry.begin(); it != test_registry.end(); ++it) { TestBase& test = **it; bool consider_test = (argc <= 1); for (int i = 1; i < argc; ++i) { if (strcasecmp(argv[i], test.name) == 0) { consider_test = true; break; } } if (not consider_test) { continue; } total_cnt += 1; if (run_test(test)) { printf("-- test case success: %s\n", test.name); success_cnt += 1; } else { printf("** test case FAILED : %s\n", test.name); } } printf("-- tests passing: %lu/%lu", success_cnt, total_cnt); if (total_cnt) { printf(" (%lu%%)\n", success_cnt * 100 / total_cnt); } else { printf("\n"); } return (success_cnt == total_cnt) ? EXIT_SUCCESS : EXIT_FAILURE; } anbox-0.0~git20191115/external/backward-cpp/test/rectrace.cpp000066400000000000000000000045741356361734700236720ustar00rootroot00000000000000/* * test/rectrace.cpp * Copyright 2013 Google Inc. All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include "backward.hpp" #include #include "test/test.hpp" using namespace backward; typedef StackTrace stacktrace_t; void end_of_our_journey(stacktrace_t& st) { if (not st.size()) { st.load_here(); } } int rec(stacktrace_t& st, int level) { if (level <= 1) { end_of_our_journey(st); return 0; } return rec(st, level - 1); } namespace toto { namespace titi { struct foo { union bar { __attribute__((noinline)) static int trampoline(stacktrace_t& st, int level) { return rec(st, level); } }; }; } // namespace titi } // namespace toto TEST (recursion) { { // lexical scope. stacktrace_t st; const int input = 3; int r = toto::titi::foo::bar::trampoline(st, input); std::cout << "rec(" << input << ") == " << r << std::endl; Printer printer; // printer.address = true; printer.object = true; printer.print(st, stdout); } } int fib(StackTrace& st, int level) { if (level == 2) { return 1; } if (level <= 1) { end_of_our_journey(st); return 0; } return fib(st, level - 1) + fib(st, level - 2); } TEST (fibrecursive) { StackTrace st; const int input = 6; int r = fib(st, input); std::cout << "fib(" << input << ") == " << r << std::endl; Printer printer; printer.print(st, stdout); } anbox-0.0~git20191115/external/backward-cpp/test/select_signals.cpp000066400000000000000000000033531356361734700250730ustar00rootroot00000000000000/* * test/segfault.cpp * Copyright 2013 Google Inc. All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include "backward.hpp" #include #include #include "test/test.hpp" using namespace backward; void badass_function() { char* ptr = (char*)42; *ptr = 42; } TEST_SEGFAULT (pprint_sigsev) { std::vector signals; signals.push_back(SIGSEGV); SignalHandling sh(signals); std::cout << std::boolalpha << "sh.loaded() == " << sh.loaded() << std::endl; badass_function(); } TEST_SEGFAULT (wont_pprint) { std::vector signals; signals.push_back(SIGABRT); SignalHandling sh(signals); std::cout << std::boolalpha << "sh.loaded() == " << sh.loaded() << std::endl; badass_function(); } anbox-0.0~git20191115/external/backward-cpp/test/stacktrace.cpp000066400000000000000000000032541356361734700242200ustar00rootroot00000000000000/* * test/stacktrace.cpp * Copyright 2013 Google Inc. All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include "backward.hpp" #include #include "test/test.hpp" using namespace backward; void collect_trace(StackTrace& st) { st.load_here(); } TEST (minitrace) { StackTrace st; collect_trace(st); Printer printer; printer.print(st, stdout); } void d(StackTrace& st) { st.load_here(); } void c(StackTrace& st) { return d(st); } void b(StackTrace& st) { return c(st); } __attribute__ ((noinline)) void a(StackTrace& st) { return b(st); } TEST (smalltrace) { StackTrace st; a(st); Printer printer; printer.print(st, stdout); } anbox-0.0~git20191115/external/backward-cpp/test/suicide.cpp000066400000000000000000000045471356361734700235270ustar00rootroot00000000000000/* * test/suicide.cpp * Copyright 2013 Google Inc. All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include "backward.hpp" #include #include #include "test/test.hpp" using namespace backward; void badass_function() { char* ptr = (char*)42; *ptr = 42; } TEST_SEGFAULT (invalid_write) { badass_function(); } int you_shall_not_pass() { char* ptr = (char*)42; int v = *ptr; return v; } TEST_SEGFAULT(invalid_read) { int v = you_shall_not_pass(); std::cout << "v=" << v << std::endl; } void abort_abort_I_repeat_abort_abort() { std::cout << "Jumping off the boat!" << std::endl; abort(); } TEST_ABORT (calling_abort) { abort_abort_I_repeat_abort_abort(); } // aarch64 does not trap Division by zero #ifndef __aarch64__ volatile int zero = 0; int divide_by_zero() { std::cout << "And the wild black hole appears..." << std::endl; int v = 42 / zero; return v; } TEST_DIVZERO (divide_by_zero) { int v = divide_by_zero(); std::cout << "v=" << v << std::endl; } #endif // Darwin does not allow RLIMIT_STACK to be reduced #ifndef __APPLE__ int bye_bye_stack(int i) { return bye_bye_stack(i + 1) + bye_bye_stack(i * 2); } TEST_SEGFAULT(stackoverflow) { struct rlimit limit; limit.rlim_max = 8096; setrlimit(RLIMIT_STACK, &limit); int r = bye_bye_stack(42); std::cout << "r=" << r << std::endl; } #endif anbox-0.0~git20191115/external/backward-cpp/test/test.cpp000066400000000000000000000036761356361734700230630ustar00rootroot00000000000000/* * test/test.cpp * Copyright 2013 Google Inc. All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include #include #include #include "test/test.hpp" TEST (empty_test) { } TEST_FAIL_ASSERT (fail_assert) { ASSERT(1 == 2); } TEST_FAIL_ASSERT (fail_assert_ge) { ASSERT_GE(4, 5); } TEST_UNCAUGHT_EXCEPTION (uncaught_exception) { throw std::runtime_error("some random runtime error"); } TEST_UNCAUGHT_EXCEPTION (uncaught_exception_int) { throw 42; } TEST_SEGFAULT (segfault) { char* a = 0; char b = a[42]; std::cout << "result: " << b << std::endl; } TEST_ABORT (abort) { abort(); } TEST (catch_int) { ASSERT_THROW({throw 42;}, int); } TEST_FAIL_ASSERT (fail_catch_int) { ASSERT_THROW({}, int); } TEST_FAIL_ASSERT (fail_no_throw) { ASSERT_NO_THROW({throw 42;}); } TEST (any_throw) { ASSERT_ANY_THROW({throw 42;}); } TEST_FAIL_ASSERT (fail_any_throw) { ASSERT_ANY_THROW({}); } anbox-0.0~git20191115/external/backward-cpp/test/test.hpp000066400000000000000000000117551356361734700230650ustar00rootroot00000000000000/* * test/test.hpp * Copyright 2013 Google Inc. All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #pragma once #ifndef H_54E531F7_9154_454B_BEB9_257408429470 #define H_54E531F7_9154_454B_BEB9_257408429470 #include #include #include #include #include #include namespace test { struct AssertFailedError: std::exception { ~AssertFailedError() throw() {} AssertFailedError(const char* filename, int _line, const char* _errmsg): basename(_basename(filename)), line(_line), errmsg(_errmsg) {} const char* what() const throw() { if (not _what.size()) { std::ostringstream ss; ss << "assertion failed (" << basename << ":" << line; ss << ") " << errmsg; _what = ss.str(); } return _what.c_str(); } const char* basename; int line; const char* errmsg; mutable std::string _what; static const char* _basename(const char* filename) { const char* basename = filename + strlen(filename); while (basename != filename && *basename != '/') { basename -= 1; } return basename + 1; } }; enum TestStatus { SUCCESS = 0<<0, FAILED = 1<<0, ASSERT_FAIL = FAILED | 1<<1, EXCEPTION_UNCAUGHT = FAILED | 2<<1, SIGNAL_UNCAUGHT = FAILED | 3<<1, SIGNAL_SEGFAULT = SIGNAL_UNCAUGHT | 1<<3, SIGNAL_ABORT = SIGNAL_UNCAUGHT | 2<<3, SIGNAL_DIVZERO = SIGNAL_UNCAUGHT | 2<<3, STATUS_MASK = 0x1F }; struct TestBase { const char* name; TestStatus expected_status; virtual ~TestBase() {} TestBase(const char*, TestStatus); virtual void do_test() = 0; TestStatus run() { try { do_test(); return SUCCESS; } catch(const AssertFailedError& e) { printf("!! %s\n", e.what()); return ASSERT_FAIL; } catch(const std::exception& e) { printf("!! exception: %s\n", e.what()); return EXCEPTION_UNCAUGHT; } catch(...) { printf("!! unknown exception\n"); return EXCEPTION_UNCAUGHT; } } }; typedef std::vector test_registry_t; extern test_registry_t test_registry; TestBase::TestBase(const char* n, TestStatus s): name(n), expected_status(s) { test_registry.push_back(this); } } // namespace test #define _TEST_STATUS(name, status) \ struct TEST_##name: ::test::TestBase { \ TEST_##name(): TestBase(#name, status) {} \ void do_test(); \ } TEST_##name; \ void TEST_##name::do_test() #define TEST(name) _TEST_STATUS(name, ::test::SUCCESS) #define TEST_FAIL(name) _TEST_STATUS(name, ::test::FAILED) #define TEST_FAIL_ASSERT(name) _TEST_STATUS(name, ::test::ASSERT_FAIL) #define TEST_UNCAUGHT_EXCEPTION(name) _TEST_STATUS(name, ::test::EXCEPTION_UNCAUGHT) #define TEST_UNCAUGHT_SIGNAL(name) _TEST_STATUS(name, ::test::SIGNAL_UNCAUGHT) #define TEST_SEGFAULT(name) _TEST_STATUS(name, ::test::SIGNAL_SEGFAULT) #define TEST_ABORT(name) _TEST_STATUS(name, ::test::SIGNAL_ABORT) #define TEST_DIVZERO(name) _TEST_STATUS(name, ::test::SIGNAL_DIVZERO) #define ASSERT(expr) \ (expr) ? static_cast(0) \ : throw ::test::AssertFailedError( \ __FILE__, __LINE__, #expr) #define _ASSERT_BINOP(a, b, cmp) \ (not (a cmp b)) ? static_cast(0) \ : throw ::test::AssertFailedError( \ __FILE__, __LINE__, "because " #a " " #cmp " " #b) #define ASSERT_EQ(a, b) _ASSERT_BINOP(a, b, !=) #define ASSERT_NE(a, b) _ASSERT_BINOP(a, b, ==) #define ASSERT_LT(a, b) _ASSERT_BINOP(a, b, >=) #define ASSERT_LE(a, b) _ASSERT_BINOP(a, b, >) #define ASSERT_GT(a, b) _ASSERT_BINOP(a, b, <=) #define ASSERT_GE(a, b) _ASSERT_BINOP(a, b, <) #define ASSERT_THROW(expr, e_type) \ do { try { expr } \ catch (const e_type&) { break; } \ throw ::test::AssertFailedError( \ __FILE__, __LINE__, "expected exception " #e_type); \ } while(0) #define ASSERT_ANY_THROW(expr) \ do { try { expr } \ catch (...) { break; } \ throw ::test::AssertFailedError( \ __FILE__, __LINE__, "expected any exception"); \ } while(0) #define ASSERT_NO_THROW(expr) \ try { expr } \ catch (...) { \ throw ::test::AssertFailedError( \ __FILE__, __LINE__, "no exception expected"); \ } #endif /* H_GUARD */ anbox-0.0~git20191115/external/backward-cpp/test_package/000077500000000000000000000000001356361734700230375ustar00rootroot00000000000000anbox-0.0~git20191115/external/backward-cpp/test_package/CMakeLists.txt000066400000000000000000000003531356361734700256000ustar00rootroot00000000000000project(backward-package-test) cmake_minimum_required(VERSION 2.8) include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake) conan_basic_setup(TARGETS) add_executable(example main.cpp) target_link_libraries(example PRIVATE ${CONAN_TARGETS}) anbox-0.0~git20191115/external/backward-cpp/test_package/conanfile.py000066400000000000000000000005571356361734700253560ustar00rootroot00000000000000from conans import ConanFile, CMake import os class TestBackward(ConanFile): settings = 'os', 'compiler', 'build_type', 'arch' generators = 'cmake' def build(self): cmake = CMake(self) cmake.configure(defs={'CMAKE_VERBOSE_MAKEFILE': 'ON'}) cmake.build() def test(self): self.run(os.path.join('.', 'bin', 'example')) anbox-0.0~git20191115/external/backward-cpp/test_package/main.cpp000066400000000000000000000017741356361734700245000ustar00rootroot00000000000000#include #include #include #include using namespace backward; class TracedException : public std::runtime_error { public: TracedException() : std::runtime_error(_get_trace()) {} private: std::string _get_trace() { std::ostringstream ss; StackTrace stackTrace; TraceResolver resolver; stackTrace.load_here(); resolver.load_stacktrace(stackTrace); for(std::size_t i = 0; i < stackTrace.size(); ++i) { const ResolvedTrace trace = resolver.resolve(stackTrace[i]); ss << "#" << i << " at " << trace.object_function << "\n"; } return ss.str(); } }; void f(int i) { if(i >= 42) { throw TracedException(); } else { std::cout << "i=" << i << "\n"; f(i + 1); } } int main() { try { f(0); } catch (const TracedException& ex) { std::cout << ex.what(); } } anbox-0.0~git20191115/external/cpu_features/000077500000000000000000000000001356361734700205345ustar00rootroot00000000000000anbox-0.0~git20191115/external/cpu_features/.clang-format000066400000000000000000000000631356361734700231060ustar00rootroot00000000000000--- Language: Cpp BasedOnStyle: Google ... anbox-0.0~git20191115/external/cpu_features/.gitignore000066400000000000000000000000151356361734700225200ustar00rootroot00000000000000cmake_build/ anbox-0.0~git20191115/external/cpu_features/.travis.yml000066400000000000000000000040571356361734700226530ustar00rootroot00000000000000language: c sudo: false cache: directories: - $HOME/cpu_features_archives matrix: include: - os: linux compiler: gcc env: TOOLCHAIN=NATIVE TARGET=native - os: linux compiler: clang env: TOOLCHAIN=NATIVE TARGET=native - os: osx compiler: gcc env: TOOLCHAIN=NATIVE TARGET=native - os: osx compiler: clang env: TOOLCHAIN=NATIVE TARGET=native - os: linux-ppc64le compiler: gcc env: TOOLCHAIN=NATIVE TARGET=native - os: linux-ppc64le compiler: clang env: TOOLCHAIN=NATIVE TARGET=native # Toolchains for little-endian, 64-bit ARMv8 for GNU/Linux systems - os: linux env: TOOLCHAIN=LINARO TARGET=aarch64-linux-gnu QEMU_ARCH=aarch64 # Toolchains for little-endian, hard-float, 32-bit ARMv7 (and earlier) for GNU/Linux systems - os: linux env: TOOLCHAIN=LINARO TARGET=arm-linux-gnueabihf QEMU_ARCH=arm # Toolchains for little-endian, 32-bit ARMv8 for GNU/Linux systems - os: linux env: TOOLCHAIN=LINARO TARGET=armv8l-linux-gnueabihf QEMU_ARCH=arm # Toolchains for little-endian, soft-float, 32-bit ARMv7 (and earlier) for GNU/Linux systems - os: linux env: TOOLCHAIN=LINARO TARGET=arm-linux-gnueabi QEMU_ARCH=arm # Toolchains for big-endian, 64-bit ARMv8 for GNU/Linux systems - os: linux env: TOOLCHAIN=LINARO TARGET=aarch64_be-linux-gnu QEMU_ARCH=DISABLED # Toolchains for big-endian, hard-float, 32-bit ARMv7 (and earlier) for GNU/Linux systems - os: linux env: TOOLCHAIN=LINARO TARGET=armeb-linux-gnueabihf QEMU_ARCH=DISABLED # Toolchains for big-endian, soft-float, 32-bit ARMv7 (and earlier) for GNU/Linux systems - os: linux env: TOOLCHAIN=LINARO TARGET=armeb-linux-gnueabi QEMU_ARCH=DISABLED - os: linux env: TOOLCHAIN=CODESCAPE TARGET=mips-mti-linux-gnu QEMU_ARCH=DISABLED script: - cmake --version - bash -e -x ./scripts/run_integration.sh anbox-0.0~git20191115/external/cpu_features/CMakeLists.txt000066400000000000000000000120261356361734700232750ustar00rootroot00000000000000cmake_minimum_required(VERSION 3.0) project(CpuFeatures VERSION 0.1.0) # ANBOX allow to build in our more strict build environment set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-error=switch-default -Wno-error=unused-parameter -Wno-error=overflow") if("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-error=cast-align") endif() # Default Build Type to be Release if(NOT CMAKE_BUILD_TYPE) set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE) endif(NOT CMAKE_BUILD_TYPE) # BUILD_TESTING is a standard CMake variable, but we declare it here to make it # prominent in the GUI. option(BUILD_TESTING "Enable test (depends on googletest)." OFF) # BUILD_SHARED_LIBS is a standard CMake variable, but we declare it here to make # it prominent in the GUI. option(BUILD_SHARED_LIBS "Build library as shared." OFF) # # library : cpu_features # set(_HDRS include/cpuinfo_aarch64.h include/cpuinfo_arm.h include/cpuinfo_mips.h include/cpuinfo_ppc.h include/cpuinfo_x86.h include/cpu_features_macros.h ) add_library(cpu_features ${_HDRS} include/internal/bit_utils.h include/internal/linux_features_aggregator.h include/internal/cpuid_x86.h include/internal/filesystem.h include/internal/hwcaps.h include/internal/stack_line_reader.h include/internal/string_view.h include/cpu_features_macros.h src/linux_features_aggregator.c src/cpuid_x86_clang_gcc.c src/cpuid_x86_msvc.c src/cpuinfo_aarch64.c src/cpuinfo_arm.c src/cpuinfo_mips.c src/cpuinfo_ppc.c src/cpuinfo_x86.c src/filesystem.c src/hwcaps.c src/stack_line_reader.c src/string_view.c ) target_include_directories(cpu_features PUBLIC $ $ PRIVATE include/internal ) set_target_properties(cpu_features PROPERTIES PUBLIC_HEADER "${_HDRS}") target_compile_definitions(cpu_features PUBLIC STACK_LINE_READER_BUFFER_SIZE=1024) target_link_libraries(cpu_features PUBLIC ${CMAKE_DL_LIBS}) # The use of shared libraries is discouraged. # For API / ABI compatibility reasons, it is recommended to build and use # cpu_features in a subdirectory of your project or as an embedded dependency. if(BUILD_SHARED_LIBS) set_property(TARGET cpu_features PROPERTY POSITION_INDEPENDENT_CODE ON) endif() add_library(CpuFeature::cpu_features ALIAS cpu_features) # # program : list_cpu_features # add_executable(list_cpu_features src/utils/list_cpu_features.c) target_link_libraries(list_cpu_features PRIVATE cpu_features) add_executable(CpuFeature::list_cpu_features ALIAS list_cpu_features) # # tests # include(CTest) # ANBOX: disable building tests set(BUILD_TESTING OFF) if(BUILD_TESTING) # Automatically incorporate googletest into the CMake Project if target not # found. if(NOT TARGET gtest OR NOT TARGET gmock_main) # Download and unpack googletest at configure time. configure_file( cmake/googletest.CMakeLists.txt.in googletest-download/CMakeLists.txt ) execute_process( COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" . RESULT_VARIABLE result WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/googletest-download) if(result) message(FATAL_ERROR "CMake step for googletest failed: ${result}") endif() execute_process( COMMAND ${CMAKE_COMMAND} --build . RESULT_VARIABLE result WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/googletest-download) if(result) message(FATAL_ERROR "Build step for googletest failed: ${result}") endif() # Prevent overriding the parent project's compiler/linker settings on # Windows. set(gtest_force_shared_crt ON CACHE BOOL "" FORCE) # Add googletest directly to our build. This defines the gtest and # gtest_main targets. add_subdirectory(${CMAKE_BINARY_DIR}/googletest-src ${CMAKE_BINARY_DIR}/googletest-build EXCLUDE_FROM_ALL) endif() add_subdirectory(test) endif() # # Install # include(GNUInstallDirs) install(TARGETS cpu_features list_cpu_features EXPORT CpuFeaturesTargets PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/cpu_features ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} ) install(EXPORT CpuFeaturesTargets NAMESPACE CpuFeatures:: DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/CpuFeatures COMPONENT Devel ) include(CMakePackageConfigHelpers) configure_package_config_file(cmake/CpuFeaturesConfig.cmake.in "${PROJECT_BINARY_DIR}/CpuFeaturesConfig.cmake" INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/CpuFeatures" NO_SET_AND_CHECK_MACRO NO_CHECK_REQUIRED_COMPONENTS_MACRO ) write_basic_package_version_file( "${PROJECT_BINARY_DIR}/CpuFeaturesConfigVersion.cmake" COMPATIBILITY SameMajorVersion ) install( FILES "${PROJECT_BINARY_DIR}/CpuFeaturesConfig.cmake" "${PROJECT_BINARY_DIR}/CpuFeaturesConfigVersion.cmake" DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/CpuFeatures" COMPONENT Devel ) anbox-0.0~git20191115/external/cpu_features/CONTRIBUTING.md000066400000000000000000000017111356361734700227650ustar00rootroot00000000000000# How to Contribute We'd love to accept your patches and contributions to this project. There are just a few small guidelines you need to follow. ## Contributor License Agreement Contributions to this project must be accompanied by a Contributor License Agreement. You (or your employer) retain the copyright to your contribution; this simply gives us permission to use and redistribute your contributions as part of the project. Head over to to see your current agreements on file or to sign a new one. You generally only need to submit a CLA once, so if you've already submitted one (even if it was for a different project), you probably don't need to do it again. ## Code reviews All submissions, including submissions by project members, require review. We use GitHub pull requests for this purpose. Consult [GitHub Help](https://help.github.com/articles/about-pull-requests/) for more information on using pull requests. anbox-0.0~git20191115/external/cpu_features/LICENSE000066400000000000000000000261351356361734700215500ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.anbox-0.0~git20191115/external/cpu_features/README.md000066400000000000000000000132661356361734700220230ustar00rootroot00000000000000# cpu_features [![Build Status](https://travis-ci.org/google/cpu_features.svg?branch=master)](https://travis-ci.org/google/cpu_features) [![Build status](https://ci.appveyor.com/api/projects/status/46d1owsj7n8dsylq/branch/master?svg=true)](https://ci.appveyor.com/project/gchatelet/cpu-features/branch/master) A cross-platform C library to retrieve CPU features (such as available instructions) at runtime. ## Table of Contents - [Design Rationale](#rationale) - [Code samples](#codesample) - [Running sample code](#usagesample) - [What's supported](#support) - [License](#license) - [Build with cmake](#cmake) ## Design Rationale - **Simple to use.** See the snippets below for examples. - **Extensible.** Easy to add missing features or architectures. - **Compatible with old compilers** and available on many architectures so it can be used widely. To ensure that cpu_features works on as many platforms as possible, we implemented it in a highly portable version of C: C99. - **Sandbox-compatible.** The library uses a variety of strategies to cope with sandboxed environments or when `cpuid` is unavailable. This is useful when running integration tests in hermetic environments. - **Thread safe, no memory allocation, and raises no exceptions.** cpu_features is suitable for implementing fundamental libc functions like `malloc`, `memcpy`, and `memcmp`. - **Unit tested.** ### Checking features at runtime Here's a simple example that executes a codepath if the CPU supports both the AES and the SSE4.2 instruction sets: ```c #include "cpuinfo_x86.h" static const X86Features features = GetX86Info().features; void Compute(void) { if (features.aes && features.sse4_2) { // Run optimized code. } else { // Run standard code. } } ``` ### Caching for faster evaluation of complex checks If you wish, you can read all the features at once into a global variable, and then query for the specific features you care about. Below, we store all the ARM features and then check whether AES and NEON are supported. ```c #include #include "cpuinfo_arm.h" static const ArmFeatures features = GetArmInfo().features; static const bool has_aes_and_neon = features.aes && features.neon; // use has_aes_and_neon. ``` This is a good approach to take if you're checking for combinations of features when using a compiler that is slow to extract individual bits from bit-packed structures. ### Checking compile time flags The following code determines whether the compiler was told to use the AVX instruction set (e.g., `g++ -mavx`) and sets `has_avx` accordingly. ```c #include #include "cpuinfo_x86.h" static const X86Features features = GetX86Info().features; static const bool has_avx = CPU_FEATURES_COMPILED_X86_AVX || features.avx; // use has_avx. ``` `CPU_FEATURES_COMPILED_X86_AVX` is set to 1 if the compiler was instructed to use AVX and 0 otherwise, combining compile time and runtime knowledge. ### Rejecting poor hardware implementations based on microarchitecture On x86, the first incarnation of a feature in a microarchitecture might not be the most efficient (e.g. AVX on Sandy Bridge). We provide a function to retrieve the underlying microarchitecture so you can decide whether to use it. Below, `has_fast_avx` is set to 1 if the CPU supports the AVX instruction set—but only if it's not Sandy Bridge. ```c #include #include "cpuinfo_x86.h" static const X86Info info = GetX86Info(); static const X86Microarchitecture uarch = GetX86Microarchitecture(&info); static const bool has_fast_avx = info.features.avx && uarch != INTEL_SNB; // use has_fast_avx. ``` This feature is currently available only for x86 microarchitectures. ### Running sample code Building `cpu_features` brings a small executable to test the library. ```shell % ./build/list_cpu_features arch : x86 brand : Intel(R) Xeon(R) CPU E5-1650 0 @ 3.20GHz family : 6 (0x06) model : 45 (0x2D) stepping : 7 (0x07) uarch : INTEL_SNB flags : aes,avx,cx16,smx,sse4_1,sse4_2,ssse3 ``` ```shell % ./build/list_cpu_features --json {"arch":"x86","brand":" Intel(R) Xeon(R) CPU E5-1650 0 @ 3.20GHz","family":6,"model":45,"stepping":7,"uarch":"INTEL_SNB","flags":["aes","avx","cx16","smx","sse4_1","sse4_2","ssse3"]} ``` ## What's supported | | x86³ | ARM | AArch64 | MIPSel | POWER | |---------|:----:|:-------:|:-------:|:------:|:-------:| | Android | yes² | yes¹ | yes¹ | yes¹ | N/A | | iOS | N/A | not yet | not yet | N/A | N/A | | Linux | yes² | yes¹ | yes¹ | yes¹ | yes¹ | | MacOs | yes² | N/A | not yet | N/A | no | | Windows | yes² | not yet | not yet | N/A | N/A | 1. **Features revealed from Linux.** We gather data from several sources depending on availability: + from glibc's [getauxval](https://www.gnu.org/software/libc/manual/html_node/Auxiliary-Vector.html) + by parsing `/proc/self/auxv` + by parsing `/proc/cpuinfo` 2. **Features revealed from CPU.** features are retrieved by using the `cpuid` instruction. 3. **Microarchitecture detection.** On x86 some features are not always implemented efficiently in hardware (e.g. AVX on Sandybridge). Exposing the microarchitecture allows the client to reject particular microarchitectures. ## License The cpu_features library is licensed under the terms of the Apache license. See [LICENSE](LICENSE) for more information. ## Build with CMake Please check the [CMake build instructions](cmake/README.md). anbox-0.0~git20191115/external/cpu_features/WORKSPACE000066400000000000000000000003021356361734700220100ustar00rootroot00000000000000# ===== googletest ===== git_repository( name = "com_google_googletest", remote = "https://github.com/google/googletest.git", commit = "c3f65335b79f47b05629e79a54685d899bc53b93", ) anbox-0.0~git20191115/external/cpu_features/appveyor.yml000066400000000000000000000011301356361734700231170ustar00rootroot00000000000000version: '{build}' shallow_clone: true platform: x64 environment: matrix: - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 CMAKE_GENERATOR: "Visual Studio 15 2017 Win64" - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015 CMAKE_GENERATOR: "Visual Studio 14 2015 Win64" matrix: fast_finish: true before_build: - cmake --version - cmake -DCMAKE_BUILD_TYPE=Debug -DBUILD_TESTING=ON -H. -Bcmake_build -G "%CMAKE_GENERATOR%" build_script: - cmake --build cmake_build --config Debug --target ALL_BUILD test_script: - cmake --build cmake_build --config Debug --target RUN_TESTS anbox-0.0~git20191115/external/cpu_features/cmake/000077500000000000000000000000001356361734700216145ustar00rootroot00000000000000anbox-0.0~git20191115/external/cpu_features/cmake/CpuFeaturesConfig.cmake.in000066400000000000000000000001461356361734700266000ustar00rootroot00000000000000# CpuFeatures CMake configuration file include("${CMAKE_CURRENT_LIST_DIR}/CpuFeaturesTargets.cmake") anbox-0.0~git20191115/external/cpu_features/cmake/README.md000066400000000000000000000021211356361734700230670ustar00rootroot00000000000000# CMake build instructions ## Recommended usage : Incorporating cpu_features into a CMake project For API / ABI compatibility reasons, it is recommended to build and use cpu_features in a subdirectory of your project or as an embedded dependency. This is similar to the recommended usage of the googletest framework ( https://github.com/google/googletest/blob/master/googletest/README.md ) Build and use step-by-step 1- Download cpu_features and copy it in a sub-directory in your project. or add cpu_features as a git-submodule in your project 2- You can then use the cmake command `add_subdirectory()` to include cpu_features directly and use the `cpu_features` target in your project. 3- Add the `cpu_features` target to the `target_link_libraries()` section of your executable or of your library. ## Enabling tests CMake default options for cpu_features is Release built type with tests disabled. To enable testing set cmake `BUILD_TESTING` variable to `ON`, [.travis.yml](../.travis.yml) and [appveyor.yml](../appveyor.yml) have up to date examples. anbox-0.0~git20191115/external/cpu_features/cmake/googletest.CMakeLists.txt.in000066400000000000000000000006531356361734700271400ustar00rootroot00000000000000cmake_minimum_required(VERSION 2.8.2) project(googletest-download NONE) include(ExternalProject) ExternalProject_Add(googletest GIT_REPOSITORY https://github.com/google/googletest.git GIT_TAG master SOURCE_DIR "${CMAKE_BINARY_DIR}/googletest-src" BINARY_DIR "${CMAKE_BINARY_DIR}/googletest-build" CONFIGURE_COMMAND "" BUILD_COMMAND "" INSTALL_COMMAND "" TEST_COMMAND "" )anbox-0.0~git20191115/external/cpu_features/cmake/mips32-linux-gcc.cmake000066400000000000000000000023511356361734700256230ustar00rootroot00000000000000set(CMAKE_SYSTEM_NAME "Linux") set(CMAKE_SYSTEM_PROCESSOR "mips32") if (ENABLE_DSPR2 AND ENABLE_MSA) message(FATAL_ERROR "ENABLE_DSPR2 and ENABLE_MSA cannot be combined.") endif () if (ENABLE_DSPR2) set(HAVE_DSPR2 1 CACHE BOOL "" FORCE) set(MIPS_CFLAGS "-mdspr2") set(MIPS_CXXFLAGS "-mdspr2") elseif (ENABLE_MSA) set(HAVE_MSA 1 CACHE BOOL "" FORCE) set(MIPS_CFLAGS "-mmsa") set(MIPS_CXXFLAGS "-mmsa") endif () if ("${MIPS_CPU}" STREQUAL "") set(MIPS_CFLAGS "${MIPS_CFLAGS} -mips32r2") set(MIPS_CXXFLAGS "${MIPS_CXXFLAGS} -mips32r2") elseif ("${MIPS_CPU}" STREQUAL "p5600") set(P56_FLAGS "-mips32r5 -mload-store-pairs -msched-weight -mhard-float -mfp64") set(MIPS_CFLAGS "${MIPS_CFLAGS} ${P56_FLAGS}") set(MIPS_CXXFLAGS "${MIPS_CXXFLAGS} ${P56_FLAGS}") set(CMAKE_EXE_LINKER_FLAGS "-mfp64 ${CMAKE_EXE_LINKER_FLAGS}") endif () set(CMAKE_C_COMPILER ${CROSS}gcc) set(CMAKE_CXX_COMPILER ${CROSS}g++) set(AS_EXECUTABLE ${CROSS}as) set(CMAKE_C_COMPILER_ARG1 "-EL ${MIPS_CFLAGS}") set(CMAKE_CXX_COMPILER_ARG1 "-EL ${MIPS_CXXFLAGS}") set(THREADS_PTHREAD_ARG "2" CACHE STRING "Forcibly set by CMakeLists.txt." FORCE) anbox-0.0~git20191115/external/cpu_features/include/000077500000000000000000000000001356361734700221575ustar00rootroot00000000000000anbox-0.0~git20191115/external/cpu_features/include/cpu_features_macros.h000066400000000000000000000077331356361734700263730ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef CPU_FEATURES_INCLUDE_CPU_FEATURES_MACROS_H_ #define CPU_FEATURES_INCLUDE_CPU_FEATURES_MACROS_H_ //////////////////////////////////////////////////////////////////////////////// // Architectures //////////////////////////////////////////////////////////////////////////////// #if ((defined(_M_IX86) || defined(_M_X64) || defined(__i386__) || \ defined(__x86_64__)) && \ !defined(__pnacl__) && !defined(__CLR_VER)) #define CPU_FEATURES_ARCH_X86 #endif #if (defined(__arm__) || defined(_M_ARM)) #define CPU_FEATURES_ARCH_ARM #endif #if defined(__aarch64__) #define CPU_FEATURES_ARCH_AARCH64 #endif #if (defined(CPU_FEATURES_ARCH_AARCH64) || defined(CPU_FEATURES_ARCH_ARM)) #define CPU_FEATURES_ARCH_ANY_ARM #endif #if defined(__mips__) #define CPU_FEATURES_ARCH_MIPS #endif #if defined(__powerpc__) #define CPU_FEATURES_ARCH_PPC #endif //////////////////////////////////////////////////////////////////////////////// // Os //////////////////////////////////////////////////////////////////////////////// #if defined(__linux__) #define CPU_FEATURES_OS_LINUX_OR_ANDROID #endif #if defined(__ANDROID__) #define CPU_FEATURES_OS_ANDROID #endif #if (defined(_WIN64) || defined(_WIN32)) #define CPU_FEATURES_OS_WINDOWS #endif //////////////////////////////////////////////////////////////////////////////// // Compilers //////////////////////////////////////////////////////////////////////////////// #if defined(__clang__) #define CPU_FEATURES_COMPILER_CLANG #endif #if defined(__GNUC__) && !defined(__clang__) #define CPU_FEATURES_COMPILER_GCC #endif #if defined(_MSC_VER) #define CPU_FEATURES_COMPILER_MSC #endif //////////////////////////////////////////////////////////////////////////////// // Cpp //////////////////////////////////////////////////////////////////////////////// #if defined(__cplusplus) #define CPU_FEATURES_START_CPP_NAMESPACE \ namespace cpu_features { \ extern "C" { #define CPU_FEATURES_END_CPP_NAMESPACE \ } \ } #else #define CPU_FEATURES_START_CPP_NAMESPACE #define CPU_FEATURES_END_CPP_NAMESPACE #endif //////////////////////////////////////////////////////////////////////////////// // Compiler flags //////////////////////////////////////////////////////////////////////////////// // Use the following to check if a feature is known to be available at compile // time. See README.md for an example. #if defined(CPU_FEATURES_ARCH_X86) #define CPU_FEATURES_COMPILED_X86_AES defined(__AES__) #define CPU_FEATURES_COMPILED_X86_F16C defined(__F16C__) #define CPU_FEATURES_COMPILED_X86_BMI defined(__BMI__) #define CPU_FEATURES_COMPILED_X86_BMI2 defined(__BMI2__) #define CPU_FEATURES_COMPILED_X86_SSE (defined(__SSE__) || (_M_IX86_FP >= 1)) #define CPU_FEATURES_COMPILED_X86_SSE2 (defined(__SSE2__) || (_M_IX86_FP >= 2)) #define CPU_FEATURES_COMPILED_X86_SSE3 defined(__SSE3__) #define CPU_FEATURES_COMPILED_X86_SSSE3 defined(__SSSE3__) #define CPU_FEATURES_COMPILED_X86_SSE4_1 defined(__SSE4_1__) #define CPU_FEATURES_COMPILED_X86_SSE4_2 defined(__SSE4_2__) #define CPU_FEATURES_COMPILED_X86_AVX defined(__AVX__) #define CPU_FEATURES_COMPILED_x86_AVX2 defined(__AVX2__) #endif #if defined(CPU_FEATURES_ARCH_ANY_ARM) #define CPU_FEATURES_COMPILED_ANY_ARM_NEON defined(__ARM_NEON__) #endif #if defined(CPU_FEATURES_ARCH_MIPS) #define CPU_FEATURES_COMPILED_MIPS_MSA defined(__mips_msa) #endif #endif // CPU_FEATURES_INCLUDE_CPU_FEATURES_MACROS_H_ anbox-0.0~git20191115/external/cpu_features/include/cpuinfo_aarch64.h000066400000000000000000000035731356361734700253130ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef CPU_FEATURES_INCLUDE_CPUINFO_AARCH64_H_ #define CPU_FEATURES_INCLUDE_CPUINFO_AARCH64_H_ #include "cpu_features_macros.h" CPU_FEATURES_START_CPP_NAMESPACE typedef struct { int fp : 1; // Floating-point. int asimd : 1; // Advanced SIMD. int aes : 1; // Hardware-accelerated Advanced Encryption Standard. int pmull : 1; // Polynomial multiply long. int sha1 : 1; // Hardware-accelerated SHA1. int sha2 : 1; // Hardware-accelerated SHA2-256. int crc32 : 1; // Hardware-accelerated CRC-32. // Make sure to update Aarch64FeaturesEnum below if you add a field here. } Aarch64Features; typedef struct { Aarch64Features features; int implementer; int variant; int part; int revision; } Aarch64Info; Aarch64Info GetAarch64Info(void); //////////////////////////////////////////////////////////////////////////////// // Introspection functions typedef enum { AARCH64_FP, AARCH64_ASIMD, AARCH64_AES, AARCH64_PMULL, AARCH64_SHA1, AARCH64_SHA2, AARCH64_CRC32, AARCH64_LAST_, } Aarch64FeaturesEnum; int GetAarch64FeaturesEnumValue(const Aarch64Features* features, Aarch64FeaturesEnum value); const char* GetAarch64FeaturesEnumName(Aarch64FeaturesEnum); CPU_FEATURES_END_CPP_NAMESPACE #endif // CPU_FEATURES_INCLUDE_CPUINFO_AARCH64_H_ anbox-0.0~git20191115/external/cpu_features/include/cpuinfo_arm.h000066400000000000000000000044701356361734700246370ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef CPU_FEATURES_INCLUDE_CPUINFO_ARM_H_ #define CPU_FEATURES_INCLUDE_CPUINFO_ARM_H_ #include "cpu_features_macros.h" CPU_FEATURES_START_CPP_NAMESPACE typedef struct { int vfp : 1; // Vector Floating Point. int iwmmxt : 1; // Intel Wireless MMX Technology. int neon : 1; // Advanced SIMD. int vfpv3 : 1; // VFP version 3 int vfpv3d16 : 1; // VFP version 3 with 16 D-registers int vfpv4 : 1; // VFP version 4 with fast context switching int idiva : 1; // SDIV and UDIV hardware division in ARM mode. int idivt : 1; // SDIV and UDIV hardware division in Thumb mode. int aes : 1; // Hardware-accelerated Advanced Encryption Standard. int pmull : 1; // Polynomial multiply long. int sha1 : 1; // Hardware-accelerated SHA1. int sha2 : 1; // Hardware-accelerated SHA2-256. int crc32 : 1; // Hardware-accelerated CRC-32. // Make sure to update ArmFeaturesEnum below if you add a field here. } ArmFeatures; typedef struct { ArmFeatures features; int implementer; int architecture; int variant; int part; int revision; } ArmInfo; // TODO(user): Add macros to know which features are present at compile // time. ArmInfo GetArmInfo(void); //////////////////////////////////////////////////////////////////////////////// // Introspection functions typedef enum { ARM_VFP, ARM_IWMMXT, ARM_NEON, ARM_VFPV3, ARM_VFPV3D16, ARM_VFPV4, ARM_IDIVA, ARM_IDIVT, ARM_AES, ARM_PMULL, ARM_SHA1, ARM_SHA2, ARM_CRC32, ARM_LAST_, } ArmFeaturesEnum; int GetArmFeaturesEnumValue(const ArmFeatures* features, ArmFeaturesEnum value); const char* GetArmFeaturesEnumName(ArmFeaturesEnum); CPU_FEATURES_END_CPP_NAMESPACE #endif // CPU_FEATURES_INCLUDE_CPUINFO_ARM_H_ anbox-0.0~git20191115/external/cpu_features/include/cpuinfo_mips.h000066400000000000000000000031051356361734700250220ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef CPU_FEATURES_INCLUDE_CPUINFO_MIPS_H_ #define CPU_FEATURES_INCLUDE_CPUINFO_MIPS_H_ #include "cpu_features_macros.h" CPU_FEATURES_START_CPP_NAMESPACE typedef struct { int msa : 1; // MIPS SIMD Architecture // https://www.mips.com/products/architectures/ase/simd/ int eva : 1; // Enhanced Virtual Addressing // https://www.mips.com/products/architectures/mips64/ // Make sure to update MipsFeaturesEnum below if you add a field here. } MipsFeatures; typedef struct { MipsFeatures features; } MipsInfo; MipsInfo GetMipsInfo(void); //////////////////////////////////////////////////////////////////////////////// // Introspection functions typedef enum { MIPS_MSA, MIPS_EVA, MIPS_LAST_, } MipsFeaturesEnum; int GetMipsFeaturesEnumValue(const MipsFeatures* features, MipsFeaturesEnum value); const char* GetMipsFeaturesEnumName(MipsFeaturesEnum); CPU_FEATURES_END_CPP_NAMESPACE #endif // CPU_FEATURES_INCLUDE_CPUINFO_MIPS_H_ anbox-0.0~git20191115/external/cpu_features/include/cpuinfo_ppc.h000066400000000000000000000103141356361734700246340ustar00rootroot00000000000000// Copyright 2018 IBM // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef CPU_FEATURES_INCLUDE_CPUINFO_PPC_H_ #define CPU_FEATURES_INCLUDE_CPUINFO_PPC_H_ #include "cpu_features_macros.h" #include "internal/hwcaps.h" CPU_FEATURES_START_CPP_NAMESPACE typedef struct { int ppc32 : 1; int ppc64 : 1; int ppc601 : 1; int altivec : 1; int fpu : 1; int mmu : 1; int mac_4xx : 1; int unifiedcache : 1; int spe : 1; int efpsingle : 1; int efpdouble : 1; int no_tb : 1; int power4 : 1; int power5 : 1; int power5plus : 1; int cell : 1; int booke : 1; int smt : 1; int icachesnoop : 1; int arch205 : 1; int pa6t : 1; int dfp : 1; int power6ext : 1; int arch206 : 1; int vsx : 1; int pseries_perfmon_compat : 1; int truele : 1; int ppcle : 1; int arch207 : 1; int htm : 1; int dscr : 1; int ebb : 1; int isel : 1; int tar : 1; int vcrypto : 1; int htm_nosc : 1; int arch300 : 1; int ieee128 : 1; int darn : 1; int scv : 1; int htm_no_suspend : 1; // Make sure to update PPCFeaturesEnum below if you add a field here. } PPCFeatures; typedef struct { PPCFeatures features; } PPCInfo; // This function is guaranteed to be malloc, memset and memcpy free. PPCInfo GetPPCInfo(void); typedef struct { char platform[64]; // 0 terminated string char model[64]; // 0 terminated string char machine[64]; // 0 terminated string char cpu[64]; // 0 terminated string PlatformType type; } PPCPlatformStrings; PPCPlatformStrings GetPPCPlatformStrings(void); //////////////////////////////////////////////////////////////////////////////// // Introspection functions typedef enum { PPC_32, /* 32 bit mode execution */ PPC_64, /* 64 bit mode execution */ PPC_601_INSTR, /* Old POWER ISA */ PPC_HAS_ALTIVEC, /* SIMD Unit*/ PPC_HAS_FPU, /* Floating Point Unit */ PPC_HAS_MMU, /* Memory management unit */ PPC_HAS_4xxMAC, PPC_UNIFIED_CACHE, /* Unified instruction and data cache */ PPC_HAS_SPE, /* Signal processing extention unit */ PPC_HAS_EFP_SINGLE, /* SPE single precision fpu */ PPC_HAS_EFP_DOUBLE, /* SPE double precision fpu */ PPC_NO_TB, /* No timebase */ PPC_POWER4, PPC_POWER5, PPC_POWER5_PLUS, PPC_CELL, /* Cell broadband engine */ PPC_BOOKE, /* Embedded ISA */ PPC_SMT, /* Simultaneous multi-threading */ PPC_ICACHE_SNOOP, PPC_ARCH_2_05, /* ISA 2.05 - POWER6 */ PPC_PA6T, /* PA Semi 6T core ISA */ PPC_HAS_DFP, /* Decimal floating point unit */ PPC_POWER6_EXT, PPC_ARCH_2_06, /* ISA 2.06 - POWER7 */ PPC_HAS_VSX, /* Vector-scalar extension */ PPC_PSERIES_PERFMON_COMPAT, /* Set of backwards compatibile performance monitoring events */ PPC_TRUE_LE, PPC_PPC_LE, PPC_ARCH_2_07, /* ISA 2.07 - POWER8 */ PPC_HTM, /* Hardware Transactional Memory */ PPC_DSCR, /* Data stream control register */ PPC_EBB, /* Event base branching */ PPC_ISEL, /* Integer select instructions */ PPC_TAR, /* Target address register */ PPC_VEC_CRYPTO, /* Vector cryptography instructions */ PPC_HTM_NOSC, /* Transactions aborted when syscall made*/ PPC_ARCH_3_00, /* ISA 3.00 - POWER9 */ PPC_HAS_IEEE128, /* VSX IEEE Binary Float 128-bit */ PPC_DARN, /* Deliver a random number instruction */ PPC_SCV, /* scv syscall */ PPC_HTM_NO_SUSPEND, /* TM w/out suspended state */ PPC_LAST_, } PPCFeaturesEnum; int GetPPCFeaturesEnumValue(const PPCFeatures* features, PPCFeaturesEnum value); const char* GetPPCFeaturesEnumName(PPCFeaturesEnum); CPU_FEATURES_END_CPP_NAMESPACE #endif // CPU_FEATURES_INCLUDE_CPUINFO_PPC_H_ anbox-0.0~git20191115/external/cpu_features/include/cpuinfo_x86.h000066400000000000000000000073071356361734700245070ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef CPU_FEATURES_INCLUDE_CPUINFO_X86_H_ #define CPU_FEATURES_INCLUDE_CPUINFO_X86_H_ #include "cpu_features_macros.h" CPU_FEATURES_START_CPP_NAMESPACE // See https://en.wikipedia.org/wiki/CPUID for a list of x86 cpu features. typedef struct { int aes : 1; int erms : 1; int f16c : 1; int fma3 : 1; int vpclmulqdq : 1; int bmi1 : 1; int bmi2 : 1; int ssse3 : 1; int sse4_1 : 1; int sse4_2 : 1; int avx : 1; int avx2 : 1; int avx512f : 1; int avx512cd : 1; int avx512er : 1; int avx512pf : 1; int avx512bw : 1; int avx512dq : 1; int avx512vl : 1; int avx512ifma : 1; int avx512vbmi : 1; int avx512vbmi2 : 1; int avx512vnni : 1; int avx512bitalg : 1; int avx512vpopcntdq : 1; int avx512_4vnniw : 1; int avx512_4vbmi2 : 1; int smx : 1; int sgx : 1; int cx16 : 1; // aka. CMPXCHG16B // Make sure to update X86FeaturesEnum below if you add a field here. } X86Features; typedef struct { X86Features features; int family; int model; int stepping; char vendor[13]; // 0 terminated string } X86Info; // Calls cpuid and returns an initialized X86info. // This function is guaranteed to be malloc, memset and memcpy free. X86Info GetX86Info(void); typedef enum { X86_UNKNOWN, INTEL_CORE, // CORE INTEL_PNR, // PENRYN INTEL_NHM, // NEHALEM INTEL_ATOM_BNL, // BONNELL INTEL_WSM, // WESTMERE INTEL_SNB, // SANDYBRIDGE INTEL_IVB, // IVYBRIDGE INTEL_ATOM_SMT, // SILVERMONT INTEL_HSW, // HASWELL INTEL_BDW, // BROADWELL INTEL_SKL, // SKYLAKE INTEL_ATOM_GMT, // GOLDMONT INTEL_KBL, // KABY LAKE INTEL_CFL, // COFFEE LAKE INTEL_CNL, // CANNON LAKE AMD_HAMMER, // K8 AMD_K10, // K10 AMD_BOBCAT, // K14 AMD_BULLDOZER, // K15 AMD_JAGUAR, // K16 AMD_ZEN, // K17 } X86Microarchitecture; // Returns the underlying microarchitecture by looking at X86Info's vendor, // family and model. X86Microarchitecture GetX86Microarchitecture(const X86Info* info); // Calls cpuid and fills the brand_string. // - brand_string *must* be of size 49 (beware of array decaying). // - brand_string will be zero terminated. // - This function calls memcpy. void FillX86BrandString(char brand_string[49]); //////////////////////////////////////////////////////////////////////////////// // Introspection functions typedef enum { X86_AES, X86_ERMS, X86_F16C, X86_FMA3, X86_VPCLMULQDQ, X86_BMI1, X86_BMI2, X86_SSSE3, X86_SSE4_1, X86_SSE4_2, X86_AVX, X86_AVX2, X86_AVX512F, X86_AVX512CD, X86_AVX512ER, X86_AVX512PF, X86_AVX512BW, X86_AVX512DQ, X86_AVX512VL, X86_AVX512IFMA, X86_AVX512VBMI, X86_AVX512VBMI2, X86_AVX512VNNI, X86_AVX512BITALG, X86_AVX512VPOPCNTDQ, X86_AVX512_4VNNIW, X86_AVX512_4VBMI2, X86_SMX, X86_SGX, X86_CX16, X86_LAST_, } X86FeaturesEnum; int GetX86FeaturesEnumValue(const X86Features* features, X86FeaturesEnum value); const char* GetX86FeaturesEnumName(X86FeaturesEnum); const char* GetX86MicroarchitectureName(X86Microarchitecture); CPU_FEATURES_END_CPP_NAMESPACE #endif // CPU_FEATURES_INCLUDE_CPUINFO_X86_H_ anbox-0.0~git20191115/external/cpu_features/include/internal/000077500000000000000000000000001356361734700237735ustar00rootroot00000000000000anbox-0.0~git20191115/external/cpu_features/include/internal/bit_utils.h000066400000000000000000000023531356361734700261450ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef CPU_FEATURES_INCLUDE_INTERNAL_BIT_UTILS_H_ #define CPU_FEATURES_INCLUDE_INTERNAL_BIT_UTILS_H_ #include #include #include #include "cpu_features_macros.h" CPU_FEATURES_START_CPP_NAMESPACE inline static bool IsBitSet(uint32_t reg, uint32_t bit) { return (reg >> bit) & 0x1; } inline static uint32_t ExtractBitRange(uint32_t reg, uint32_t msb, uint32_t lsb) { const uint64_t bits = msb - lsb + 1; const uint64_t mask = (1ULL << bits) - 1ULL; assert(msb >= lsb); return (reg >> lsb) & mask; } CPU_FEATURES_END_CPP_NAMESPACE #endif // CPU_FEATURES_INCLUDE_INTERNAL_BIT_UTILS_H_ anbox-0.0~git20191115/external/cpu_features/include/internal/cpuid_x86.h000066400000000000000000000021461356361734700257600ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef CPU_FEATURES_INCLUDE_INTERNAL_CPUID_X86_H_ #define CPU_FEATURES_INCLUDE_INTERNAL_CPUID_X86_H_ #include #include "cpu_features_macros.h" CPU_FEATURES_START_CPP_NAMESPACE // A struct to hold the result of a call to cpuid. typedef struct { uint32_t eax, ebx, ecx, edx; } Leaf; // Retrieves the leaf for a particular cpuid. Leaf CpuId(uint32_t leaf_id); // Returns the eax value of the XCR0 register. uint32_t GetXCR0Eax(void); CPU_FEATURES_END_CPP_NAMESPACE #endif // CPU_FEATURES_INCLUDE_INTERNAL_CPUID_X86_H_ anbox-0.0~git20191115/external/cpu_features/include/internal/filesystem.h000066400000000000000000000025361356361734700263360ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // An interface for the filesystem that allows mocking the filesystem in // unittests. #ifndef CPU_FEATURES_INCLUDE_INTERNAL_FILESYSTEM_H_ #define CPU_FEATURES_INCLUDE_INTERNAL_FILESYSTEM_H_ #include #include #include "cpu_features_macros.h" CPU_FEATURES_START_CPP_NAMESPACE // Same as linux "open(filename, O_RDONLY)", retries automatically on EINTR. int CpuFeatures_OpenFile(const char* filename); // Same as linux "read(file_descriptor, buffer, buffer_size)", retries // automatically on EINTR. int CpuFeatures_ReadFile(int file_descriptor, void* buffer, size_t buffer_size); // Same as linux "close(file_descriptor)". void CpuFeatures_CloseFile(int file_descriptor); CPU_FEATURES_END_CPP_NAMESPACE #endif // CPU_FEATURES_INCLUDE_INTERNAL_FILESYSTEM_H_ anbox-0.0~git20191115/external/cpu_features/include/internal/hwcaps.h000066400000000000000000000110601356361734700254270ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Interface to retrieve hardware capabilities. It relies on Linux's getauxval // or `/proc/self/auxval` under the hood. #ifndef CPU_FEATURES_INCLUDE_INTERNAL_HWCAPS_H_ #define CPU_FEATURES_INCLUDE_INTERNAL_HWCAPS_H_ #include #include "cpu_features_macros.h" CPU_FEATURES_START_CPP_NAMESPACE // To avoid depending on the linux kernel we reproduce the architecture specific // constants here. // http://elixir.free-electrons.com/linux/latest/source/arch/arm64/include/uapi/asm/hwcap.h #define AARCH64_HWCAP_FP (1UL << 0) #define AARCH64_HWCAP_ASIMD (1UL << 1) #define AARCH64_HWCAP_AES (1UL << 3) #define AARCH64_HWCAP_PMULL (1UL << 4) #define AARCH64_HWCAP_SHA1 (1UL << 5) #define AARCH64_HWCAP_SHA2 (1UL << 6) #define AARCH64_HWCAP_CRC32 (1UL << 7) // http://elixir.free-electrons.com/linux/latest/source/arch/arm/include/uapi/asm/hwcap.h #define ARM_HWCAP_VFP (1UL << 6) #define ARM_HWCAP_IWMMXT (1UL << 9) #define ARM_HWCAP_NEON (1UL << 12) #define ARM_HWCAP_VFPV3 (1UL << 13) #define ARM_HWCAP_VFPV3D16 (1UL << 14) #define ARM_HWCAP_VFPV4 (1UL << 16) #define ARM_HWCAP_IDIVA (1UL << 17) #define ARM_HWCAP_IDIVT (1UL << 18) #define ARM_HWCAP2_AES (1UL << 0) #define ARM_HWCAP2_PMULL (1UL << 1) #define ARM_HWCAP2_SHA1 (1UL << 2) #define ARM_HWCAP2_SHA2 (1UL << 3) #define ARM_HWCAP2_CRC32 (1UL << 4) // http://elixir.free-electrons.com/linux/latest/source/arch/mips/include/uapi/asm/hwcap.h #define MIPS_HWCAP_VZ (1UL << 0) #define MIPS_HWCAP_EVA (1UL << 1) #define MIPS_HWCAP_HTW (1UL << 2) #define MIPS_HWCAP_FPU (1UL << 3) #define MIPS_HWCAP_MIPS32R2 (1UL << 4) #define MIPS_HWCAP_MIPS32R5 (1UL << 5) #define MIPS_HWCAP_MIPS64R6 (1UL << 6) #define MIPS_HWCAP_DSPR1 (1UL << 7) #define MIPS_HWCAP_DSPR2 (1UL << 8) #define MIPS_HWCAP_MSA (1UL << 9) // http://elixir.free-electrons.com/linux/latest/source/arch/powerpc/include/uapi/asm/cputable.h #ifndef _UAPI__ASM_POWERPC_CPUTABLE_H /* in AT_HWCAP */ #define PPC_FEATURE_32 0x80000000 #define PPC_FEATURE_64 0x40000000 #define PPC_FEATURE_601_INSTR 0x20000000 #define PPC_FEATURE_HAS_ALTIVEC 0x10000000 #define PPC_FEATURE_HAS_FPU 0x08000000 #define PPC_FEATURE_HAS_MMU 0x04000000 #define PPC_FEATURE_HAS_4xxMAC 0x02000000 #define PPC_FEATURE_UNIFIED_CACHE 0x01000000 #define PPC_FEATURE_HAS_SPE 0x00800000 #define PPC_FEATURE_HAS_EFP_SINGLE 0x00400000 #define PPC_FEATURE_HAS_EFP_DOUBLE 0x00200000 #define PPC_FEATURE_NO_TB 0x00100000 #define PPC_FEATURE_POWER4 0x00080000 #define PPC_FEATURE_POWER5 0x00040000 #define PPC_FEATURE_POWER5_PLUS 0x00020000 #define PPC_FEATURE_CELL 0x00010000 #define PPC_FEATURE_BOOKE 0x00008000 #define PPC_FEATURE_SMT 0x00004000 #define PPC_FEATURE_ICACHE_SNOOP 0x00002000 #define PPC_FEATURE_ARCH_2_05 0x00001000 #define PPC_FEATURE_PA6T 0x00000800 #define PPC_FEATURE_HAS_DFP 0x00000400 #define PPC_FEATURE_POWER6_EXT 0x00000200 #define PPC_FEATURE_ARCH_2_06 0x00000100 #define PPC_FEATURE_HAS_VSX 0x00000080 #define PPC_FEATURE_PSERIES_PERFMON_COMPAT 0x00000040 /* Reserved - do not use 0x00000004 */ #define PPC_FEATURE_TRUE_LE 0x00000002 #define PPC_FEATURE_PPC_LE 0x00000001 /* in AT_HWCAP2 */ #define PPC_FEATURE2_ARCH_2_07 0x80000000 #define PPC_FEATURE2_HTM 0x40000000 #define PPC_FEATURE2_DSCR 0x20000000 #define PPC_FEATURE2_EBB 0x10000000 #define PPC_FEATURE2_ISEL 0x08000000 #define PPC_FEATURE2_TAR 0x04000000 #define PPC_FEATURE2_VEC_CRYPTO 0x02000000 #define PPC_FEATURE2_HTM_NOSC 0x01000000 #define PPC_FEATURE2_ARCH_3_00 0x00800000 #define PPC_FEATURE2_HAS_IEEE128 0x00400000 #define PPC_FEATURE2_DARN 0x00200000 #define PPC_FEATURE2_SCV 0x00100000 #define PPC_FEATURE2_HTM_NO_SUSPEND 0x00080000 #endif typedef struct { unsigned long hwcaps; unsigned long hwcaps2; } HardwareCapabilities; HardwareCapabilities CpuFeatures_GetHardwareCapabilities(void); typedef struct { char platform[64]; // 0 terminated string char base_platform[64]; // 0 terminated string } PlatformType; PlatformType CpuFeatures_GetPlatformType(void); CPU_FEATURES_END_CPP_NAMESPACE #endif // CPU_FEATURES_INCLUDE_INTERNAL_HWCAPS_H_ anbox-0.0~git20191115/external/cpu_features/include/internal/linux_features_aggregator.h000066400000000000000000000051171356361734700314070ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // CapabilityConfig provides a way to map cpu features to hardware caps and // /proc/cpuinfo flags. We then provide functions to update capabilities from // either source. #ifndef CPU_FEATURES_INCLUDE_INTERNAL_LINUX_FEATURES_AGGREGATOR_H_ #define CPU_FEATURES_INCLUDE_INTERNAL_LINUX_FEATURES_AGGREGATOR_H_ #include #include #include "cpu_features_macros.h" #include "internal/hwcaps.h" #include "internal/string_view.h" CPU_FEATURES_START_CPP_NAMESPACE // Use the following macro to declare setter functions to be used in // CapabilityConfig. #define DECLARE_SETTER(FeatureType, FeatureName) \ static void set_##FeatureName(void* const features, bool value) { \ ((FeatureType*)features)->FeatureName = value; \ } // Describes the relationship between hardware caps and /proc/cpuinfo flags. typedef struct { const HardwareCapabilities hwcaps_mask; const char* const proc_cpuinfo_flag; void (*set_bit)(void* const, bool); // setter for the corresponding bit. } CapabilityConfig; // For every config, looks into flags_line for the presence of the // corresponding proc_cpuinfo_flag, calls `set_bit` accordingly. // Note: features is a pointer to the underlying Feature struct. void CpuFeatures_SetFromFlags(const size_t configs_size, const CapabilityConfig* configs, const StringView flags_line, void* const features); // For every config, looks into hwcaps for the presence of the feature. Calls // `set_bit` with true if the hardware capability is found. // Note: features is a pointer to the underlying Feature struct. void CpuFeatures_OverrideFromHwCaps(const size_t configs_size, const CapabilityConfig* configs, const HardwareCapabilities hwcaps, void* const features); CPU_FEATURES_END_CPP_NAMESPACE #endif // CPU_FEATURES_INCLUDE_INTERNAL_LINUX_FEATURES_AGGREGATOR_H_ anbox-0.0~git20191115/external/cpu_features/include/internal/stack_line_reader.h000066400000000000000000000031671356361734700276110ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Reads a file line by line and stores the data on the stack. This allows // parsing files in one go without allocating. #ifndef CPU_FEATURES_INCLUDE_INTERNAL_STACK_LINE_READER_H_ #define CPU_FEATURES_INCLUDE_INTERNAL_STACK_LINE_READER_H_ #include #include "cpu_features_macros.h" #include "internal/string_view.h" CPU_FEATURES_START_CPP_NAMESPACE typedef struct { char buffer[STACK_LINE_READER_BUFFER_SIZE]; StringView view; int fd; bool skip_mode; } StackLineReader; // Initializes a StackLineReader. void StackLineReader_Initialize(StackLineReader* reader, int fd); typedef struct { StringView line; // A view of the line. bool eof; // Nothing more to read, we reached EOF. bool full_line; // If false the line was truncated to // STACK_LINE_READER_BUFFER_SIZE. } LineResult; // Reads the file pointed to by fd and tries to read a full line. LineResult StackLineReader_NextLine(StackLineReader* reader); CPU_FEATURES_END_CPP_NAMESPACE #endif // CPU_FEATURES_INCLUDE_INTERNAL_STACK_LINE_READER_H_ anbox-0.0~git20191115/external/cpu_features/include/internal/string_view.h000066400000000000000000000077451356361734700265210ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // A view over a piece of string. The view is not 0 terminated. #ifndef CPU_FEATURES_INCLUDE_INTERNAL_STRING_VIEW_H_ #define CPU_FEATURES_INCLUDE_INTERNAL_STRING_VIEW_H_ #include #include #include #include "cpu_features_macros.h" CPU_FEATURES_START_CPP_NAMESPACE typedef struct { const char* ptr; size_t size; } StringView; #ifdef __cplusplus static const StringView kEmptyStringView = {NULL, 0}; #else static const StringView kEmptyStringView; #endif // Returns a StringView from the provided string. // Passing NULL is valid only if size is 0. static inline StringView view(const char* str, const size_t size) { StringView view; view.ptr = str; view.size = size; return view; } static inline StringView str(const char* str) { return view(str, strlen(str)); } // Returns the index of the first occurrence of c in view or -1 if not found. int CpuFeatures_StringView_IndexOfChar(const StringView view, char c); // Returns the index of the first occurrence of sub_view in view or -1 if not // found. int CpuFeatures_StringView_IndexOf(const StringView view, const StringView sub_view); // Returns whether a is equal to b (same content). bool CpuFeatures_StringView_IsEquals(const StringView a, const StringView b); // Returns whether a starts with b. bool CpuFeatures_StringView_StartsWith(const StringView a, const StringView b); // Removes count characters from the beginning of view or kEmptyStringView if // count if greater than view.size. StringView CpuFeatures_StringView_PopFront(const StringView str_view, size_t count); // Removes count characters from the end of view or kEmptyStringView if count if // greater than view.size. StringView CpuFeatures_StringView_PopBack(const StringView str_view, size_t count); // Keeps the count first characters of view or view if count if greater than // view.size. StringView CpuFeatures_StringView_KeepFront(const StringView str_view, size_t count); // Retrieves the first character of view. If view is empty the behavior is // undefined. char CpuFeatures_StringView_Front(const StringView view); // Retrieves the last character of view. If view is empty the behavior is // undefined. char CpuFeatures_StringView_Back(const StringView view); // Removes leading and tailing space characters. StringView CpuFeatures_StringView_TrimWhitespace(StringView view); // Convert StringView to positive integer. e.g. "42", "0x2a". // Returns -1 on error. int CpuFeatures_StringView_ParsePositiveNumber(const StringView view); // Copies src StringView to dst buffer. void CpuFeatures_StringView_CopyString(const StringView src, char* dst, size_t dst_size); // Checks if line contains the specified whitespace separated word. bool CpuFeatures_StringView_HasWord(const StringView line, const char* const word); // Get key/value from line. key and value are separated by ": ". // key and value are cleaned up from leading and trailing whitespaces. bool CpuFeatures_StringView_GetAttributeKeyValue(const StringView line, StringView* key, StringView* value); CPU_FEATURES_END_CPP_NAMESPACE #endif // CPU_FEATURES_INCLUDE_INTERNAL_STRING_VIEW_H_ anbox-0.0~git20191115/external/cpu_features/scripts/000077500000000000000000000000001356361734700222235ustar00rootroot00000000000000anbox-0.0~git20191115/external/cpu_features/scripts/run_integration.sh000077500000000000000000000125771356361734700260050ustar00rootroot00000000000000#!/bin/bash readonly SCRIPT_FOLDER=$(cd -P -- "$(dirname -- "$0")" && pwd -P) readonly PROJECT_FOLDER="${SCRIPT_FOLDER}/.." readonly ARCHIVE_FOLDER=~/cpu_features_archives readonly QEMU_INSTALL=${ARCHIVE_FOLDER}/qemu readonly DEFAULT_CMAKE_ARGS=" -DCMAKE_BUILD_TYPE=Debug -DBUILD_TESTING=ON" function extract() { case $1 in *.tar.bz2) tar xjf "$1" ;; *.tar.xz) tar xJf "$1" ;; *.tar.gz) tar xzf "$1" ;; *) echo "don't know how to extract '$1'..." exit 1 esac } function unpackifnotexists() { mkdir -p "${ARCHIVE_FOLDER}" cd "${ARCHIVE_FOLDER}" || exit local URL=$1 local RELATIVE_FOLDER=$2 local DESTINATION="${ARCHIVE_FOLDER}/${RELATIVE_FOLDER}" if [[ ! -d "${DESTINATION}" ]] ; then local ARCHIVE_NAME=$(echo ${URL} | sed 's/.*\///') test -f "${ARCHIVE_NAME}" || wget -q "${URL}" extract "${ARCHIVE_NAME}" fi } function installqemuifneeded() { local VERSION=${QEMU_VERSION:=2.11.1} local ARCHES=${QEMU_ARCHES:=arm aarch64 i386 x86_64 mips mipsel} local TARGETS=${QEMU_TARGETS:=$(echo "$ARCHES" | sed 's#$# #;s#\([^ ]*\) #\1-linux-user #g')} if echo "${VERSION} ${TARGETS}" | cmp --silent ${QEMU_INSTALL}/.build -; then echo "qemu ${VERSION} up to date!" return 0 fi echo "VERSION: ${VERSION}" echo "TARGETS: ${TARGETS}" rm -rf ${QEMU_INSTALL} # Checking for a tarball before downloading makes testing easier :-) local QEMU_URL="http://wiki.qemu-project.org/download/qemu-${VERSION}.tar.xz" local QEMU_FOLDER="qemu-${VERSION}" unpackifnotexists ${QEMU_URL} ${QEMU_FOLDER} cd ${QEMU_FOLDER} || exit ./configure \ --prefix="${QEMU_INSTALL}" \ --target-list="${TARGETS}" \ --disable-docs \ --disable-sdl \ --disable-gtk \ --disable-gnutls \ --disable-gcrypt \ --disable-nettle \ --disable-curses \ --static make -j4 make install echo "$VERSION $TARGETS" > ${QEMU_INSTALL}/.build } function assert_defined(){ local VALUE=${1} : "${VALUE?"${1} needs to be defined"}" } function integrate() { cd "${PROJECT_FOLDER}" || exit cmake -H. -B"${BUILD_DIR}" ${DEFAULT_CMAKE_ARGS} ${CMAKE_ADDITIONAL_ARGS} cmake --build "${BUILD_DIR}" --target all if [[ -n "${QEMU_ARCH}" ]]; then if [[ "${QEMU_ARCH}" == "DISABLED" ]]; then QEMU="true || " else installqemuifneeded QEMU="${QEMU_INSTALL}/bin/qemu-${QEMU_ARCH} ${QEMU_ARGS}" fi else QEMU="" fi # Run tests for test_binary in ${BUILD_DIR}/test/*_test; do ${QEMU} ${test_binary}; done # Run demo program ${QEMU} "${BUILD_DIR}/list_cpu_features" } function expand_linaro_config() { assert_defined TARGET local LINARO_ROOT_URL=https://releases.linaro.org/components/toolchain/binaries/7.2-2017.11 local GCC_URL=${LINARO_ROOT_URL}/${TARGET}/gcc-linaro-7.2.1-2017.11-x86_64_${TARGET}.tar.xz local GCC_RELATIVE_FOLDER="gcc-linaro-7.2.1-2017.11-x86_64_${TARGET}" unpackifnotexists "${GCC_URL}" "${GCC_RELATIVE_FOLDER}" local SYSROOT_URL=${LINARO_ROOT_URL}/${TARGET}/sysroot-glibc-linaro-2.25-2017.11-${TARGET}.tar.xz local SYSROOT_RELATIVE_FOLDER=sysroot-glibc-linaro-2.25-2017.11-${TARGET} unpackifnotexists "${SYSROOT_URL}" "${SYSROOT_RELATIVE_FOLDER}" local SYSROOT_FOLDER=${ARCHIVE_FOLDER}/${SYSROOT_RELATIVE_FOLDER} local GCC_FOLDER=${ARCHIVE_FOLDER}/${GCC_RELATIVE_FOLDER} CMAKE_ADDITIONAL_ARGS+=" -DCMAKE_SYSROOT=${SYSROOT_FOLDER}" CMAKE_ADDITIONAL_ARGS+=" -DCMAKE_C_COMPILER=${GCC_FOLDER}/bin/${TARGET}-gcc" CMAKE_ADDITIONAL_ARGS+=" -DCMAKE_CXX_COMPILER=${GCC_FOLDER}/bin/${TARGET}-g++" CMAKE_ADDITIONAL_ARGS+=" -DCMAKE_FIND_ROOT_PATH_MODE_PROGRAM=NEVER" CMAKE_ADDITIONAL_ARGS+=" -DCMAKE_FIND_ROOT_PATH_MODE_INCLUDE=ONLY" CMAKE_ADDITIONAL_ARGS+=" -DCMAKE_FIND_ROOT_PATH_MODE_PACKAGE=ONLY" QEMU_ARGS+=" -L ${SYSROOT_FOLDER}" QEMU_ARGS+=" -E LD_LIBRARY_PATH=/lib" } function expand_codescape_config() { assert_defined TARGET local FLAVOUR=${QEMU_ARCH}-r2-hard local DATE=2016.05-03 local CODESCAPE_URL=http://codescape-mips-sdk.imgtec.com/components/toolchain/${DATE}/Codescape.GNU.Tools.Package.${DATE}.for.MIPS.MTI.Linux.CentOS-5.x86_64.tar.gz local GCC_URL=${CODESCAPE_URL} local GCC_RELATIVE_FOLDER=${TARGET}/${DATE} unpackifnotexists "${GCC_URL}" "${GCC_RELATIVE_FOLDER}" local SYSROOT_URL=${CODESCAPE_URL} local SYSROOT_FOLDER=${ARCHIVE_FOLDER}/${GCC_RELATIVE_FOLDER}/sysroot/${FLAVOUR} unpackifnotexists "${SYSROOT_URL}" "${SYSROOT_RELATIVE_FOLDER}" CMAKE_ADDITIONAL_ARGS+=" -DENABLE_MSA=1" CMAKE_ADDITIONAL_ARGS+=" -DMIPS_CPU=p5600" CMAKE_ADDITIONAL_ARGS+=" -DCMAKE_TOOLCHAIN_FILE=cmake/mips32-linux-gcc.cmake" CMAKE_ADDITIONAL_ARGS+=" -DCROSS=${TARGET}-" CMAKE_ADDITIONAL_ARGS+=" -DCMAKE_FIND_ROOT_PATH=${ARCHIVE_FOLDER}/${GCC_RELATIVE_FOLDER}" QEMU_ARGS+=" -L ${SYSROOT_FOLDER}" QEMU_ARGS+=" -E LD_LIBRARY_PATH=/lib" QEMU_ARGS+=" -cpu P5600" } function expand_environment_and_integrate() { assert_defined PROJECT_FOLDER assert_defined TARGET BUILD_DIR="${PROJECT_FOLDER}/cmake_build/${TARGET}" mkdir -p "${BUILD_DIR}" CMAKE_ADDITIONAL_ARGS="" QEMU_ARGS="" case ${TOOLCHAIN} in LINARO) expand_linaro_config ;; CODESCAPE) expand_codescape_config ;; NATIVE) QEMU_ARCH="" ;; *) echo "Unknown toolchain '${TOOLCHAIN}'..." exit 1 esac integrate } if [ "${CONTINUOUS_INTEGRATION}" = "true" ]; then QEMU_ARCHES=${QEMU_ARCH} expand_environment_and_integrate fi anbox-0.0~git20191115/external/cpu_features/scripts/test_integration.sh000077500000000000000000000035241356361734700261500ustar00rootroot00000000000000source "$(dirname -- "$0")"/run_integration.sh # Toolchains for little-endian, 64-bit ARMv8 for GNU/Linux systems function set_aarch64-linux-gnu() { TOOLCHAIN=LINARO TARGET=aarch64-linux-gnu QEMU_ARCH=aarch64 } # Toolchains for little-endian, hard-float, 32-bit ARMv7 (and earlier) for GNU/Linux systems function set_arm-linux-gnueabihf() { TOOLCHAIN=LINARO TARGET=arm-linux-gnueabihf QEMU_ARCH=arm } # Toolchains for little-endian, 32-bit ARMv8 for GNU/Linux systems function set_armv8l-linux-gnueabihf() { TOOLCHAIN=LINARO TARGET=armv8l-linux-gnueabihf QEMU_ARCH=arm } # Toolchains for little-endian, soft-float, 32-bit ARMv7 (and earlier) for GNU/Linux systems function set_arm-linux-gnueabi() { TOOLCHAIN=LINARO TARGET=arm-linux-gnueabi QEMU_ARCH=arm } # Toolchains for big-endian, 64-bit ARMv8 for GNU/Linux systems function set_aarch64_be-linux-gnu() { TOOLCHAIN=LINARO TARGET=aarch64_be-linux-gnu QEMU_ARCH="DISABLED" } # Toolchains for big-endian, hard-float, 32-bit ARMv7 (and earlier) for GNU/Linux systems function set_armeb-linux-gnueabihf() { TOOLCHAIN=LINARO TARGET=armeb-linux-gnueabihf QEMU_ARCH="DISABLED" } # Toolchains for big-endian, soft-float, 32-bit ARMv7 (and earlier) for GNU/Linux systems function set_armeb-linux-gnueabi() { TOOLCHAIN=LINARO TARGET=armeb-linux-gnueabi QEMU_ARCH="DISABLED" } function set_mips() { TOOLCHAIN=CODESCAPE TARGET=mips-mti-linux-gnu QEMU_ARCH="DISABLED" } function set_native() { TOOLCHAIN=NATIVE TARGET=native QEMU_ARCH="" } ENVIRONMENTS=" set_aarch64-linux-gnu set_arm-linux-gnueabihf set_armv8l-linux-gnueabihf set_arm-linux-gnueabi set_aarch64_be-linux-gnu set_armeb-linux-gnueabihf set_armeb-linux-gnueabi set_native set_mips " for SET_ENVIRONMENT in ${ENVIRONMENTS}; do ${SET_ENVIRONMENT} expand_environment_and_integrate done anbox-0.0~git20191115/external/cpu_features/src/000077500000000000000000000000001356361734700213235ustar00rootroot00000000000000anbox-0.0~git20191115/external/cpu_features/src/cpuid_x86_clang_gcc.c000066400000000000000000000021671356361734700252660ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "internal/cpuid_x86.h" #if defined(CPU_FEATURES_ARCH_X86) #if defined(CPU_FEATURES_COMPILER_CLANG) || defined(CPU_FEATURES_COMPILER_GCC) #include Leaf CpuId(uint32_t leaf_id) { Leaf leaf; __cpuid_count(leaf_id, 0, leaf.eax, leaf.ebx, leaf.ecx, leaf.edx); return leaf; } uint32_t GetXCR0Eax(void) { uint32_t eax, edx; __asm("XGETBV" : "=a"(eax), "=d"(edx) : "c"(0)); return eax; } #endif // defined(CPU_FEATURES_COMPILER_CLANG) || // defined(CPU_FEATURES_COMPILER_GCC) #endif // defined(CPU_FEATURES_ARCH_X86) anbox-0.0~git20191115/external/cpu_features/src/cpuid_x86_msvc.c000066400000000000000000000020671356361734700243350ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "internal/cpuid_x86.h" #if defined(CPU_FEATURES_ARCH_X86) && defined(CPU_FEATURES_COMPILER_MSC) #include #include // For __cpuidex() Leaf CpuId(uint32_t leaf_id) { Leaf leaf; int data[4]; __cpuid(data, leaf_id); leaf.eax = data[0]; leaf.ebx = data[1]; leaf.ecx = data[2]; leaf.edx = data[3]; return leaf; } uint32_t GetXCR0Eax(void) { return _xgetbv(0); } #endif // defined(CPU_FEATURES_ARCH_X86) && defined(CPU_FEATURES_COMPILER_MSC) anbox-0.0~git20191115/external/cpu_features/src/cpuinfo_aarch64.c000066400000000000000000000110721356361734700244430ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "cpuinfo_aarch64.h" #include "internal/filesystem.h" #include "internal/hwcaps.h" #include "internal/linux_features_aggregator.h" #include "internal/stack_line_reader.h" #include "internal/string_view.h" #include DECLARE_SETTER(Aarch64Features, fp) DECLARE_SETTER(Aarch64Features, asimd) DECLARE_SETTER(Aarch64Features, aes) DECLARE_SETTER(Aarch64Features, pmull) DECLARE_SETTER(Aarch64Features, sha1) DECLARE_SETTER(Aarch64Features, sha2) DECLARE_SETTER(Aarch64Features, crc32) static const CapabilityConfig kConfigs[] = { {{AARCH64_HWCAP_FP, 0}, "fp", &set_fp}, // {{AARCH64_HWCAP_ASIMD, 0}, "asimd", &set_asimd}, // {{AARCH64_HWCAP_AES, 0}, "aes", &set_aes}, // {{AARCH64_HWCAP_PMULL, 0}, "pmull", &set_pmull}, // {{AARCH64_HWCAP_SHA1, 0}, "sha1", &set_sha1}, // {{AARCH64_HWCAP_SHA2, 0}, "sha2", &set_sha2}, // {{AARCH64_HWCAP_CRC32, 0}, "crc32", &set_crc32}, // }; static const size_t kConfigsSize = sizeof(kConfigs) / sizeof(CapabilityConfig); static bool HandleAarch64Line(const LineResult result, Aarch64Info* const info) { StringView line = result.line; StringView key, value; if (CpuFeatures_StringView_GetAttributeKeyValue(line, &key, &value)) { if (CpuFeatures_StringView_IsEquals(key, str("Features"))) { CpuFeatures_SetFromFlags(kConfigsSize, kConfigs, value, &info->features); } else if (CpuFeatures_StringView_IsEquals(key, str("CPU implementer"))) { info->implementer = CpuFeatures_StringView_ParsePositiveNumber(value); } else if (CpuFeatures_StringView_IsEquals(key, str("CPU variant"))) { info->variant = CpuFeatures_StringView_ParsePositiveNumber(value); } else if (CpuFeatures_StringView_IsEquals(key, str("CPU part"))) { info->part = CpuFeatures_StringView_ParsePositiveNumber(value); } else if (CpuFeatures_StringView_IsEquals(key, str("CPU revision"))) { info->revision = CpuFeatures_StringView_ParsePositiveNumber(value); } } return !result.eof; } static void FillProcCpuInfoData(Aarch64Info* const info) { const int fd = CpuFeatures_OpenFile("/proc/cpuinfo"); if (fd >= 0) { StackLineReader reader; StackLineReader_Initialize(&reader, fd); for (;;) { if (!HandleAarch64Line(StackLineReader_NextLine(&reader), info)) { break; } } CpuFeatures_CloseFile(fd); } } static const Aarch64Info kEmptyAarch64Info; Aarch64Info GetAarch64Info(void) { // capabilities are fetched from both getauxval and /proc/cpuinfo so we can // have some information if the executable is sandboxed (aka no access to // /proc/cpuinfo). Aarch64Info info = kEmptyAarch64Info; FillProcCpuInfoData(&info); CpuFeatures_OverrideFromHwCaps(kConfigsSize, kConfigs, CpuFeatures_GetHardwareCapabilities(), &info.features); return info; } //////////////////////////////////////////////////////////////////////////////// // Introspection functions int GetAarch64FeaturesEnumValue(const Aarch64Features* features, Aarch64FeaturesEnum value) { switch (value) { case AARCH64_FP: return features->fp; case AARCH64_ASIMD: return features->asimd; case AARCH64_AES: return features->aes; case AARCH64_PMULL: return features->pmull; case AARCH64_SHA1: return features->sha1; case AARCH64_SHA2: return features->sha2; case AARCH64_CRC32: return features->crc32; case AARCH64_LAST_: break; } return false; } const char* GetAarch64FeaturesEnumName(Aarch64FeaturesEnum value) { switch (value) { case AARCH64_FP: return "fp"; case AARCH64_ASIMD: return "asimd"; case AARCH64_AES: return "aes"; case AARCH64_PMULL: return "pmull"; case AARCH64_SHA1: return "sha1"; case AARCH64_SHA2: return "sha2"; case AARCH64_CRC32: return "crc32"; case AARCH64_LAST_: break; } return "unknown feature"; } anbox-0.0~git20191115/external/cpu_features/src/cpuinfo_arm.c000066400000000000000000000213101356361734700237660ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "cpuinfo_arm.h" #include "internal/bit_utils.h" #include "internal/filesystem.h" #include "internal/hwcaps.h" #include "internal/linux_features_aggregator.h" #include "internal/stack_line_reader.h" #include "internal/string_view.h" #include DECLARE_SETTER(ArmFeatures, vfp) DECLARE_SETTER(ArmFeatures, iwmmxt) DECLARE_SETTER(ArmFeatures, neon) DECLARE_SETTER(ArmFeatures, vfpv3) DECLARE_SETTER(ArmFeatures, vfpv3d16) DECLARE_SETTER(ArmFeatures, vfpv4) DECLARE_SETTER(ArmFeatures, idiva) DECLARE_SETTER(ArmFeatures, idivt) DECLARE_SETTER(ArmFeatures, aes) DECLARE_SETTER(ArmFeatures, pmull) DECLARE_SETTER(ArmFeatures, sha1) DECLARE_SETTER(ArmFeatures, sha2) DECLARE_SETTER(ArmFeatures, crc32) static const CapabilityConfig kConfigs[] = { {{ARM_HWCAP_VFP, 0}, "vfp", &set_vfp}, // {{ARM_HWCAP_IWMMXT, 0}, "iwmmxt", &set_iwmmxt}, // {{ARM_HWCAP_NEON, 0}, "neon", &set_neon}, // {{ARM_HWCAP_VFPV3, 0}, "vfpv3", &set_vfpv3}, // {{ARM_HWCAP_VFPV3D16, 0}, "vfpv3d16", &set_vfpv3d16}, // {{ARM_HWCAP_VFPV4, 0}, "vfpv4", &set_vfpv4}, // {{ARM_HWCAP_IDIVA, 0}, "idiva", &set_idiva}, // {{ARM_HWCAP_IDIVT, 0}, "idivt", &set_idivt}, // {{0, ARM_HWCAP2_AES}, "aes", &set_aes}, // {{0, ARM_HWCAP2_PMULL}, "pmull", &set_pmull}, // {{0, ARM_HWCAP2_SHA1}, "sha1", &set_sha1}, // {{0, ARM_HWCAP2_SHA2}, "sha2", &set_sha2}, // {{0, ARM_HWCAP2_CRC32}, "crc32", &set_crc32}, // }; static const size_t kConfigsSize = sizeof(kConfigs) / sizeof(CapabilityConfig); typedef struct { bool processor_reports_armv6; bool hardware_reports_goldfish; } ProcCpuInfoData; static int IndexOfNonDigit(StringView str) { size_t index = 0; while (str.size && isdigit(CpuFeatures_StringView_Front(str))) { str = CpuFeatures_StringView_PopFront(str, 1); ++index; } return index; } static bool HandleArmLine(const LineResult result, ArmInfo* const info, ProcCpuInfoData* const proc_info) { StringView line = result.line; StringView key, value; if (CpuFeatures_StringView_GetAttributeKeyValue(line, &key, &value)) { if (CpuFeatures_StringView_IsEquals(key, str("Features"))) { CpuFeatures_SetFromFlags(kConfigsSize, kConfigs, value, &info->features); } else if (CpuFeatures_StringView_IsEquals(key, str("CPU implementer"))) { info->implementer = CpuFeatures_StringView_ParsePositiveNumber(value); } else if (CpuFeatures_StringView_IsEquals(key, str("CPU variant"))) { info->variant = CpuFeatures_StringView_ParsePositiveNumber(value); } else if (CpuFeatures_StringView_IsEquals(key, str("CPU part"))) { info->part = CpuFeatures_StringView_ParsePositiveNumber(value); } else if (CpuFeatures_StringView_IsEquals(key, str("CPU revision"))) { info->revision = CpuFeatures_StringView_ParsePositiveNumber(value); } else if (CpuFeatures_StringView_IsEquals(key, str("CPU architecture"))) { // CPU architecture is a number that may be followed by letters. e.g. // "6TEJ", "7". const StringView digits = CpuFeatures_StringView_KeepFront(value, IndexOfNonDigit(value)); info->architecture = CpuFeatures_StringView_ParsePositiveNumber(digits); } else if (CpuFeatures_StringView_IsEquals(key, str("Processor"))) { proc_info->processor_reports_armv6 = CpuFeatures_StringView_IndexOf(value, str("(v6l)")) >= 0; } else if (CpuFeatures_StringView_IsEquals(key, str("Hardware"))) { proc_info->hardware_reports_goldfish = CpuFeatures_StringView_IsEquals(value, str("Goldfish")); } } return !result.eof; } static uint32_t GetCpuId(const ArmInfo* const info) { return (ExtractBitRange(info->implementer, 7, 0) << 24) | (ExtractBitRange(info->variant, 3, 0) << 20) | (ExtractBitRange(info->part, 11, 0) << 4) | (ExtractBitRange(info->revision, 3, 0) << 0); } static void FixErrors(ArmInfo* const info, ProcCpuInfoData* const proc_cpu_info_data) { // Fixing Samsung kernel reporting invalid cpu architecture. // http://code.google.com/p/android/issues/detail?id=10812 if (proc_cpu_info_data->processor_reports_armv6 && info->architecture >= 7) { info->architecture = 6; } // Handle kernel configuration bugs that prevent the correct reporting of CPU // features. switch (GetCpuId(info)) { case 0x4100C080: // Special case: The emulator-specific Android 4.2 kernel fails to report // support for the 32-bit ARM IDIV instruction. Technically, this is a // feature of the virtual CPU implemented by the emulator. Note that it // could also support Thumb IDIV in the future, and this will have to be // slightly updated. if (info->architecture >= 7 && proc_cpu_info_data->hardware_reports_goldfish) { info->features.idiva = true; } break; case 0x511004D0: // https://crbug.com/341598. info->features.neon = false; break; case 0x510006F2: case 0x510006F3: // The Nexus 4 (Qualcomm Krait) kernel configuration forgets to report // IDIV support. info->features.idiva = true; info->features.idivt = true; break; } // Propagate cpu features. if (info->features.vfpv4) info->features.vfpv3 = true; if (info->features.neon) info->features.vfpv3 = true; if (info->features.vfpv3) info->features.vfp = true; } static void FillProcCpuInfoData(ArmInfo* const info, ProcCpuInfoData* proc_cpu_info_data) { const int fd = CpuFeatures_OpenFile("/proc/cpuinfo"); if (fd >= 0) { StackLineReader reader; StackLineReader_Initialize(&reader, fd); for (;;) { if (!HandleArmLine(StackLineReader_NextLine(&reader), info, proc_cpu_info_data)) { break; } } CpuFeatures_CloseFile(fd); } } static const ArmInfo kEmptyArmInfo; static const ProcCpuInfoData kEmptyProcCpuInfoData; ArmInfo GetArmInfo(void) { // capabilities are fetched from both getauxval and /proc/cpuinfo so we can // have some information if the executable is sandboxed (aka no access to // /proc/cpuinfo). ArmInfo info = kEmptyArmInfo; ProcCpuInfoData proc_cpu_info_data = kEmptyProcCpuInfoData; FillProcCpuInfoData(&info, &proc_cpu_info_data); CpuFeatures_OverrideFromHwCaps(kConfigsSize, kConfigs, CpuFeatures_GetHardwareCapabilities(), &info.features); FixErrors(&info, &proc_cpu_info_data); return info; } //////////////////////////////////////////////////////////////////////////////// // Introspection functions int GetArmFeaturesEnumValue(const ArmFeatures* features, ArmFeaturesEnum value) { switch (value) { case ARM_VFP: return features->vfp; case ARM_IWMMXT: return features->iwmmxt; case ARM_NEON: return features->neon; case ARM_VFPV3: return features->vfpv3; case ARM_VFPV3D16: return features->vfpv3d16; case ARM_VFPV4: return features->vfpv4; case ARM_IDIVA: return features->idiva; case ARM_IDIVT: return features->idivt; case ARM_AES: return features->aes; case ARM_PMULL: return features->pmull; case ARM_SHA1: return features->sha1; case ARM_SHA2: return features->sha2; case ARM_CRC32: return features->crc32; case ARM_LAST_: break; } return false; } const char* GetArmFeaturesEnumName(ArmFeaturesEnum value) { switch (value) { case ARM_VFP: return "vfp"; case ARM_IWMMXT: return "iwmmxt"; case ARM_NEON: return "neon"; case ARM_VFPV3: return "vfpv3"; case ARM_VFPV3D16: return "vfpv3d16"; case ARM_VFPV4: return "vfpv4"; case ARM_IDIVA: return "idiva"; case ARM_IDIVT: return "idivt"; case ARM_AES: return "aes"; case ARM_PMULL: return "pmull"; case ARM_SHA1: return "sha1"; case ARM_SHA2: return "sha2"; case ARM_CRC32: return "crc32"; case ARM_LAST_: break; } return "unknown feature"; } anbox-0.0~git20191115/external/cpu_features/src/cpuinfo_mips.c000066400000000000000000000056611356361734700241720ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "cpuinfo_mips.h" #include "internal/filesystem.h" #include "internal/linux_features_aggregator.h" #include "internal/stack_line_reader.h" #include "internal/string_view.h" DECLARE_SETTER(MipsFeatures, msa) DECLARE_SETTER(MipsFeatures, eva) static const CapabilityConfig kConfigs[] = { {{MIPS_HWCAP_MSA, 0}, "msa", &set_msa}, // {{MIPS_HWCAP_EVA, 0}, "eva", &set_eva}, // }; static const size_t kConfigsSize = sizeof(kConfigs) / sizeof(CapabilityConfig); static bool HandleMipsLine(const LineResult result, MipsFeatures* const features) { StringView key, value; // See tests for an example. if (CpuFeatures_StringView_GetAttributeKeyValue(result.line, &key, &value)) { if (CpuFeatures_StringView_IsEquals(key, str("ASEs implemented"))) { CpuFeatures_SetFromFlags(kConfigsSize, kConfigs, value, features); } } return !result.eof; } static void FillProcCpuInfoData(MipsFeatures* const features) { const int fd = CpuFeatures_OpenFile("/proc/cpuinfo"); if (fd >= 0) { StackLineReader reader; StackLineReader_Initialize(&reader, fd); for (;;) { if (!HandleMipsLine(StackLineReader_NextLine(&reader), features)) { break; } } CpuFeatures_CloseFile(fd); } } static const MipsInfo kEmptyMipsInfo; MipsInfo GetMipsInfo(void) { // capabilities are fetched from both getauxval and /proc/cpuinfo so we can // have some information if the executable is sandboxed (aka no access to // /proc/cpuinfo). MipsInfo info = kEmptyMipsInfo; FillProcCpuInfoData(&info.features); CpuFeatures_OverrideFromHwCaps(kConfigsSize, kConfigs, CpuFeatures_GetHardwareCapabilities(), &info.features); return info; } //////////////////////////////////////////////////////////////////////////////// // Introspection functions int GetMipsFeaturesEnumValue(const MipsFeatures* features, MipsFeaturesEnum value) { switch (value) { case MIPS_MSA: return features->msa; case MIPS_EVA: return features->eva; case MIPS_LAST_: break; } return false; } const char* GetMipsFeaturesEnumName(MipsFeaturesEnum value) { switch (value) { case MIPS_MSA: return "msa"; case MIPS_EVA: return "eva"; case MIPS_LAST_: break; } return "unknown feature"; } anbox-0.0~git20191115/external/cpu_features/src/cpuinfo_ppc.c000066400000000000000000000262611356361734700240030ustar00rootroot00000000000000// Copyright 2018 IBM. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "cpuinfo_ppc.h" #include "internal/bit_utils.h" #include "internal/filesystem.h" #include "internal/linux_features_aggregator.h" #include "internal/stack_line_reader.h" #include "internal/string_view.h" DECLARE_SETTER(PPCFeatures, ppc32) DECLARE_SETTER(PPCFeatures, ppc64) DECLARE_SETTER(PPCFeatures, ppc601) DECLARE_SETTER(PPCFeatures, altivec) DECLARE_SETTER(PPCFeatures, fpu) DECLARE_SETTER(PPCFeatures, mmu) DECLARE_SETTER(PPCFeatures, mac_4xx) DECLARE_SETTER(PPCFeatures, unifiedcache) DECLARE_SETTER(PPCFeatures, spe) DECLARE_SETTER(PPCFeatures, efpsingle) DECLARE_SETTER(PPCFeatures, efpdouble) DECLARE_SETTER(PPCFeatures, no_tb) DECLARE_SETTER(PPCFeatures, power4) DECLARE_SETTER(PPCFeatures, power5) DECLARE_SETTER(PPCFeatures, power5plus) DECLARE_SETTER(PPCFeatures, cell) DECLARE_SETTER(PPCFeatures, booke) DECLARE_SETTER(PPCFeatures, smt) DECLARE_SETTER(PPCFeatures, icachesnoop) DECLARE_SETTER(PPCFeatures, arch205) DECLARE_SETTER(PPCFeatures, pa6t) DECLARE_SETTER(PPCFeatures, dfp) DECLARE_SETTER(PPCFeatures, power6ext) DECLARE_SETTER(PPCFeatures, arch206) DECLARE_SETTER(PPCFeatures, vsx) DECLARE_SETTER(PPCFeatures, pseries_perfmon_compat) DECLARE_SETTER(PPCFeatures, truele) DECLARE_SETTER(PPCFeatures, ppcle) DECLARE_SETTER(PPCFeatures, arch207) DECLARE_SETTER(PPCFeatures, htm) DECLARE_SETTER(PPCFeatures, dscr) DECLARE_SETTER(PPCFeatures, ebb) DECLARE_SETTER(PPCFeatures, isel) DECLARE_SETTER(PPCFeatures, tar) DECLARE_SETTER(PPCFeatures, vcrypto) DECLARE_SETTER(PPCFeatures, htm_nosc) DECLARE_SETTER(PPCFeatures, arch300) DECLARE_SETTER(PPCFeatures, ieee128) DECLARE_SETTER(PPCFeatures, darn) DECLARE_SETTER(PPCFeatures, scv) DECLARE_SETTER(PPCFeatures, htm_no_suspend) static const CapabilityConfig kConfigs[] = { {{PPC_FEATURE_32, 0}, "ppc32", &set_ppc32}, {{PPC_FEATURE_64, 0}, "ppc64", &set_ppc64}, {{PPC_FEATURE_601_INSTR, 0}, "ppc601", &set_ppc601}, {{PPC_FEATURE_HAS_ALTIVEC, 0}, "altivec", &set_altivec}, {{PPC_FEATURE_HAS_FPU, 0}, "fpu", &set_fpu}, {{PPC_FEATURE_HAS_MMU, 0}, "mmu", &set_mmu}, {{PPC_FEATURE_HAS_4xxMAC, 0}, "4xxmac", &set_mac_4xx}, {{PPC_FEATURE_UNIFIED_CACHE, 0}, "ucache", &set_unifiedcache}, {{PPC_FEATURE_HAS_SPE, 0}, "spe", &set_spe}, {{PPC_FEATURE_HAS_EFP_SINGLE, 0}, "efpsingle", &set_efpsingle}, {{PPC_FEATURE_HAS_EFP_DOUBLE, 0}, "efpdouble", &set_efpdouble}, {{PPC_FEATURE_NO_TB, 0}, "notb", &set_no_tb}, {{PPC_FEATURE_POWER4, 0}, "power4", &set_power4}, {{PPC_FEATURE_POWER5, 0}, "power5", &set_power5}, {{PPC_FEATURE_POWER5_PLUS, 0}, "power5+", &set_power5plus}, {{PPC_FEATURE_CELL, 0}, "cellbe", &set_cell}, {{PPC_FEATURE_BOOKE, 0}, "booke", &set_booke}, {{PPC_FEATURE_SMT, 0}, "smt", &set_smt}, {{PPC_FEATURE_ICACHE_SNOOP, 0}, "ic_snoop", &set_icachesnoop}, {{PPC_FEATURE_ARCH_2_05, 0}, "arch_2_05", &set_arch205}, {{PPC_FEATURE_PA6T, 0}, "pa6t", &set_pa6t}, {{PPC_FEATURE_HAS_DFP, 0}, "dfp", &set_dfp}, {{PPC_FEATURE_POWER6_EXT, 0}, "power6x", &set_power6ext}, {{PPC_FEATURE_ARCH_2_06, 0}, "arch_2_06", &set_arch206}, {{PPC_FEATURE_HAS_VSX, 0}, "vsx", &set_vsx}, {{PPC_FEATURE_PSERIES_PERFMON_COMPAT, 0}, "archpmu", &set_pseries_perfmon_compat}, {{PPC_FEATURE_TRUE_LE, 0}, "true_le", &set_truele}, {{PPC_FEATURE_PPC_LE, 0}, "ppcle", &set_ppcle}, {{0, PPC_FEATURE2_ARCH_2_07}, "arch_2_07", &set_arch207}, {{0, PPC_FEATURE2_HTM}, "htm", &set_htm}, {{0, PPC_FEATURE2_DSCR}, "dscr", &set_dscr}, {{0, PPC_FEATURE2_EBB}, "ebb", &set_ebb}, {{0, PPC_FEATURE2_ISEL}, "isel", &set_isel}, {{0, PPC_FEATURE2_TAR}, "tar", &set_tar}, {{0, PPC_FEATURE2_VEC_CRYPTO}, "vcrypto", &set_vcrypto}, {{0, PPC_FEATURE2_HTM_NOSC}, "htm-nosc", &set_htm_nosc}, {{0, PPC_FEATURE2_ARCH_3_00}, "arch_3_00", &set_arch300}, {{0, PPC_FEATURE2_HAS_IEEE128}, "ieee128", &set_ieee128}, {{0, PPC_FEATURE2_DARN}, "darn", &set_darn}, {{0, PPC_FEATURE2_SCV}, "scv", &set_scv}, {{0, PPC_FEATURE2_HTM_NO_SUSPEND}, "htm-no-suspend", &set_htm_no_suspend}, }; static const size_t kConfigsSize = sizeof(kConfigs) / sizeof(CapabilityConfig); static bool HandlePPCLine(const LineResult result, PPCPlatformStrings* const strings) { StringView line = result.line; StringView key, value; if (CpuFeatures_StringView_GetAttributeKeyValue(line, &key, &value)) { if (CpuFeatures_StringView_HasWord(key, "platform")) { CpuFeatures_StringView_CopyString(value, strings->platform, sizeof(strings->platform)); } else if (CpuFeatures_StringView_IsEquals(key, str("model"))) { CpuFeatures_StringView_CopyString(value, strings->model, sizeof(strings->platform)); } else if (CpuFeatures_StringView_IsEquals(key, str("machine"))) { CpuFeatures_StringView_CopyString(value, strings->machine, sizeof(strings->platform)); } else if (CpuFeatures_StringView_IsEquals(key, str("cpu"))) { CpuFeatures_StringView_CopyString(value, strings->cpu, sizeof(strings->platform)); } } return !result.eof; } static void FillProcCpuInfoData(PPCPlatformStrings* const strings) { const int fd = CpuFeatures_OpenFile("/proc/cpuinfo"); if (fd >= 0) { StackLineReader reader; StackLineReader_Initialize(&reader, fd); for (;;) { if (!HandlePPCLine(StackLineReader_NextLine(&reader), strings)) { break; } } CpuFeatures_CloseFile(fd); } } static const PPCInfo kEmptyPPCInfo; PPCInfo GetPPCInfo(void) { /* * On Power feature flags aren't currently in cpuinfo so we only look at * the auxilary vector. */ PPCInfo info = kEmptyPPCInfo; CpuFeatures_OverrideFromHwCaps(kConfigsSize, kConfigs, CpuFeatures_GetHardwareCapabilities(), &info.features); return info; } static const PPCPlatformStrings kEmptyPPCPlatformStrings; PPCPlatformStrings GetPPCPlatformStrings(void) { PPCPlatformStrings strings = kEmptyPPCPlatformStrings; FillProcCpuInfoData(&strings); strings.type = CpuFeatures_GetPlatformType(); return strings; } //////////////////////////////////////////////////////////////////////////////// // Introspection functions int GetPPCFeaturesEnumValue(const PPCFeatures* features, PPCFeaturesEnum value) { switch (value) { case PPC_32: return features->ppc32; case PPC_64: return features->ppc64; case PPC_601_INSTR: return features->ppc601; case PPC_HAS_ALTIVEC: return features->altivec; case PPC_HAS_FPU: return features->fpu; case PPC_HAS_MMU: return features->mmu; case PPC_HAS_4xxMAC: return features->mac_4xx; case PPC_UNIFIED_CACHE: return features->unifiedcache; case PPC_HAS_SPE: return features->spe; case PPC_HAS_EFP_SINGLE: return features->efpsingle; case PPC_HAS_EFP_DOUBLE: return features->efpdouble; case PPC_NO_TB: return features->no_tb; case PPC_POWER4: return features->power4; case PPC_POWER5: return features->power5; case PPC_POWER5_PLUS: return features->power5plus; case PPC_CELL: return features->cell; case PPC_BOOKE: return features->booke; case PPC_SMT: return features->smt; case PPC_ICACHE_SNOOP: return features->icachesnoop; case PPC_ARCH_2_05: return features->arch205; case PPC_PA6T: return features->pa6t; case PPC_HAS_DFP: return features->dfp; case PPC_POWER6_EXT: return features->power6ext; case PPC_ARCH_2_06: return features->arch206; case PPC_HAS_VSX: return features->vsx; case PPC_PSERIES_PERFMON_COMPAT: return features->pseries_perfmon_compat; case PPC_TRUE_LE: return features->truele; case PPC_PPC_LE: return features->ppcle; case PPC_ARCH_2_07: return features->arch207; case PPC_HTM: return features->htm; case PPC_DSCR: return features->dscr; case PPC_EBB: return features->ebb; case PPC_ISEL: return features->isel; case PPC_TAR: return features->tar; case PPC_VEC_CRYPTO: return features->vcrypto; case PPC_HTM_NOSC: return features->htm_nosc; case PPC_ARCH_3_00: return features->arch300; case PPC_HAS_IEEE128: return features->ieee128; case PPC_DARN: return features->darn; case PPC_SCV: return features->scv; case PPC_HTM_NO_SUSPEND: return features->htm_no_suspend; case PPC_LAST_: break; } return false; } /* Have used the same names as glibc */ const char* GetPPCFeaturesEnumName(PPCFeaturesEnum value) { switch (value) { case PPC_32: return "ppc32"; case PPC_64: return "ppc64"; case PPC_601_INSTR: return "ppc601"; case PPC_HAS_ALTIVEC: return "altivec"; case PPC_HAS_FPU: return "fpu"; case PPC_HAS_MMU: return "mmu"; case PPC_HAS_4xxMAC: return "4xxmac"; case PPC_UNIFIED_CACHE: return "ucache"; case PPC_HAS_SPE: return "spe"; case PPC_HAS_EFP_SINGLE: return "efpsingle"; case PPC_HAS_EFP_DOUBLE: return "efpdouble"; case PPC_NO_TB: return "notb"; case PPC_POWER4: return "power4"; case PPC_POWER5: return "power5"; case PPC_POWER5_PLUS: return "power5+"; case PPC_CELL: return "cellbe"; case PPC_BOOKE: return "booke"; case PPC_SMT: return "smt"; case PPC_ICACHE_SNOOP: return "ic_snoop"; case PPC_ARCH_2_05: return "arch_2_05"; case PPC_PA6T: return "pa6t"; case PPC_HAS_DFP: return "dfp"; case PPC_POWER6_EXT: return "power6x"; case PPC_ARCH_2_06: return "arch_2_06"; case PPC_HAS_VSX: return "vsx"; case PPC_PSERIES_PERFMON_COMPAT: return "archpmu"; case PPC_TRUE_LE: return "true_le"; case PPC_PPC_LE: return "ppcle"; case PPC_ARCH_2_07: return "arch_2_07"; case PPC_HTM: return "htm"; case PPC_DSCR: return "dscr"; case PPC_EBB: return "ebb"; case PPC_ISEL: return "isel"; case PPC_TAR: return "tar"; case PPC_VEC_CRYPTO: return "vcrypto"; case PPC_HTM_NOSC: return "htm-nosc"; case PPC_ARCH_3_00: return "arch_3_00"; case PPC_HAS_IEEE128: return "ieee128"; case PPC_DARN: return "darn"; case PPC_SCV: return "scv"; case PPC_HTM_NO_SUSPEND: return "htm-no-suspend"; case PPC_LAST_: break; } return "unknown_feature"; } anbox-0.0~git20191115/external/cpu_features/src/cpuinfo_x86.c000066400000000000000000000325031356361734700236420ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "cpuinfo_x86.h" #include "internal/bit_utils.h" #include "internal/cpuid_x86.h" #include #include static const Leaf kEmptyLeaf; static Leaf SafeCpuId(uint32_t max_cpuid_leaf, uint32_t leaf_id) { if (leaf_id <= max_cpuid_leaf) { return CpuId(leaf_id); } else { return kEmptyLeaf; } } #define MASK_XMM 0x2 #define MASK_YMM 0x4 #define MASK_MASKREG 0x20 #define MASK_ZMM0_15 0x40 #define MASK_ZMM16_31 0x80 static bool HasMask(uint32_t value, uint32_t mask) { return (value & mask) == mask; } // Checks that operating system saves and restores xmm registers during context // switches. static bool HasXmmOsXSave(uint32_t xcr0_eax) { return HasMask(xcr0_eax, MASK_XMM); } // Checks that operating system saves and restores ymm registers during context // switches. static bool HasYmmOsXSave(uint32_t xcr0_eax) { return HasMask(xcr0_eax, MASK_XMM | MASK_YMM); } // Checks that operating system saves and restores zmm registers during context // switches. static bool HasZmmOsXSave(uint32_t xcr0_eax) { return HasMask(xcr0_eax, MASK_XMM | MASK_YMM | MASK_MASKREG | MASK_ZMM0_15 | MASK_ZMM16_31); } static void SetVendor(const Leaf leaf, char* const vendor) { *(uint32_t*)(vendor) = leaf.ebx; *(uint32_t*)(vendor + 4) = leaf.edx; *(uint32_t*)(vendor + 8) = leaf.ecx; vendor[12] = '\0'; } static int IsVendor(const Leaf leaf, const char* const name) { const uint32_t ebx = *(const uint32_t*)(name); const uint32_t edx = *(const uint32_t*)(name + 4); const uint32_t ecx = *(const uint32_t*)(name + 8); return leaf.ebx == ebx && leaf.ecx == ecx && leaf.edx == edx; } // Reference https://en.wikipedia.org/wiki/CPUID. static void ParseCpuId(const uint32_t max_cpuid_leaf, X86Info* info) { const Leaf leaf_1 = SafeCpuId(max_cpuid_leaf, 1); const Leaf leaf_7 = SafeCpuId(max_cpuid_leaf, 7); const bool have_xsave = IsBitSet(leaf_1.ecx, 26); const bool have_osxsave = IsBitSet(leaf_1.ecx, 27); const uint32_t xcr0_eax = (have_xsave && have_osxsave) ? GetXCR0Eax() : 0; const bool have_sse_os_support = HasXmmOsXSave(xcr0_eax); const bool have_avx_os_support = HasYmmOsXSave(xcr0_eax); const bool have_avx512_os_support = HasZmmOsXSave(xcr0_eax); const uint32_t family = ExtractBitRange(leaf_1.eax, 11, 8); const uint32_t extended_family = ExtractBitRange(leaf_1.eax, 27, 20); const uint32_t model = ExtractBitRange(leaf_1.eax, 7, 4); const uint32_t extended_model = ExtractBitRange(leaf_1.eax, 19, 16); X86Features* const features = &info->features; info->family = extended_family + family; info->model = (extended_model << 4) + model; info->stepping = ExtractBitRange(leaf_1.eax, 3, 0); features->smx = IsBitSet(leaf_1.ecx, 6); features->cx16 = IsBitSet(leaf_1.ecx, 13); features->aes = IsBitSet(leaf_1.ecx, 25); features->f16c = IsBitSet(leaf_1.ecx, 29); features->sgx = IsBitSet(leaf_7.ebx, 2); features->bmi1 = IsBitSet(leaf_7.ebx, 3); features->bmi2 = IsBitSet(leaf_7.ebx, 8); features->erms = IsBitSet(leaf_7.ebx, 9); features->vpclmulqdq = IsBitSet(leaf_7.ecx, 10); if (have_sse_os_support) { features->ssse3 = IsBitSet(leaf_1.ecx, 9); features->sse4_1 = IsBitSet(leaf_1.ecx, 19); features->sse4_2 = IsBitSet(leaf_1.ecx, 20); } if (have_avx_os_support) { features->fma3 = IsBitSet(leaf_1.ecx, 12); features->avx = IsBitSet(leaf_1.ecx, 28); features->avx2 = IsBitSet(leaf_7.ebx, 5); } if (have_avx512_os_support) { features->avx512f = IsBitSet(leaf_7.ebx, 16); features->avx512cd = IsBitSet(leaf_7.ebx, 28); features->avx512er = IsBitSet(leaf_7.ebx, 27); features->avx512pf = IsBitSet(leaf_7.ebx, 26); features->avx512bw = IsBitSet(leaf_7.ebx, 30); features->avx512dq = IsBitSet(leaf_7.ebx, 17); features->avx512vl = IsBitSet(leaf_7.ebx, 31); features->avx512ifma = IsBitSet(leaf_7.ebx, 21); features->avx512vbmi = IsBitSet(leaf_7.ecx, 1); features->avx512vbmi2 = IsBitSet(leaf_7.ecx, 6); features->avx512vnni = IsBitSet(leaf_7.ecx, 11); features->avx512bitalg = IsBitSet(leaf_7.ecx, 12); features->avx512vpopcntdq = IsBitSet(leaf_7.ecx, 14); features->avx512_4vnniw = IsBitSet(leaf_7.edx, 2); features->avx512_4vbmi2 = IsBitSet(leaf_7.edx, 3); } } static const X86Info kEmptyX86Info; X86Info GetX86Info(void) { X86Info info = kEmptyX86Info; const Leaf leaf_0 = CpuId(0); const uint32_t max_cpuid_leaf = leaf_0.eax; SetVendor(leaf_0, info.vendor); if (IsVendor(leaf_0, "GenuineIntel") || IsVendor(leaf_0, "AuthenticAMD")) { ParseCpuId(max_cpuid_leaf, &info); } return info; } #define CPUID(FAMILY, MODEL) (((FAMILY & 0xFF) << 8) | (MODEL & 0xFF)) X86Microarchitecture GetX86Microarchitecture(const X86Info* info) { if (memcmp(info->vendor, "GenuineIntel", sizeof(info->vendor)) == 0) { switch (CPUID(info->family, info->model)) { case CPUID(0x06, 0x35): case CPUID(0x06, 0x36): // https://en.wikipedia.org/wiki/Bonnell_(microarchitecture) return INTEL_ATOM_BNL; case CPUID(0x06, 0x37): case CPUID(0x06, 0x4C): // https://en.wikipedia.org/wiki/Silvermont return INTEL_ATOM_SMT; case CPUID(0x06, 0x5C): // https://en.wikipedia.org/wiki/Goldmont return INTEL_ATOM_GMT; case CPUID(0x06, 0x0F): case CPUID(0x06, 0x16): // https://en.wikipedia.org/wiki/Intel_Core_(microarchitecture) return INTEL_CORE; case CPUID(0x06, 0x17): case CPUID(0x06, 0x1D): // https://en.wikipedia.org/wiki/Penryn_(microarchitecture) return INTEL_PNR; case CPUID(0x06, 0x1A): case CPUID(0x06, 0x1E): case CPUID(0x06, 0x1F): case CPUID(0x06, 0x2E): // https://en.wikipedia.org/wiki/Nehalem_(microarchitecture) return INTEL_NHM; case CPUID(0x06, 0x25): case CPUID(0x06, 0x2C): case CPUID(0x06, 0x2F): // https://en.wikipedia.org/wiki/Westmere_(microarchitecture) return INTEL_WSM; case CPUID(0x06, 0x2A): case CPUID(0x06, 0x2D): // https://en.wikipedia.org/wiki/Sandy_Bridge#Models_and_steppings return INTEL_SNB; case CPUID(0x06, 0x3A): case CPUID(0x06, 0x3E): // https://en.wikipedia.org/wiki/Ivy_Bridge_(microarchitecture)#Models_and_steppings return INTEL_IVB; case CPUID(0x06, 0x3C): case CPUID(0x06, 0x3F): case CPUID(0x06, 0x45): case CPUID(0x06, 0x46): // https://en.wikipedia.org/wiki/Haswell_(microarchitecture) return INTEL_HSW; case CPUID(0x06, 0x3D): case CPUID(0x06, 0x47): case CPUID(0x06, 0x4F): case CPUID(0x06, 0x56): // https://en.wikipedia.org/wiki/Broadwell_(microarchitecture) return INTEL_BDW; case CPUID(0x06, 0x4E): case CPUID(0x06, 0x55): case CPUID(0x06, 0x5E): // https://en.wikipedia.org/wiki/Skylake_(microarchitecture) return INTEL_SKL; case CPUID(0x06, 0x8E): case CPUID(0x06, 0x9E): // https://en.wikipedia.org/wiki/Kaby_Lake return INTEL_KBL; default: return X86_UNKNOWN; } } if (memcmp(info->vendor, "AuthenticAMD", sizeof(info->vendor)) == 0) { switch (info->family) { // https://en.wikipedia.org/wiki/List_of_AMD_CPU_microarchitectures case 0x0F: return AMD_HAMMER; case 0x10: return AMD_K10; case 0x14: return AMD_BOBCAT; case 0x15: return AMD_BULLDOZER; case 0x16: return AMD_JAGUAR; case 0x17: return AMD_ZEN; default: return X86_UNKNOWN; } } return X86_UNKNOWN; } static void SetString(const uint32_t max_cpuid_ext_leaf, const uint32_t leaf_id, char* buffer) { const Leaf leaf = SafeCpuId(max_cpuid_ext_leaf, leaf_id); // We allow calling memcpy from SetString which is only called when requesting // X86BrandString. memcpy(buffer, &leaf, sizeof(Leaf)); } void FillX86BrandString(char brand_string[49]) { const Leaf leaf_ext_0 = CpuId(0x80000000); const uint32_t max_cpuid_leaf_ext = leaf_ext_0.eax; SetString(max_cpuid_leaf_ext, 0x80000002, brand_string); SetString(max_cpuid_leaf_ext, 0x80000003, brand_string + 16); SetString(max_cpuid_leaf_ext, 0x80000004, brand_string + 32); brand_string[48] = '\0'; } //////////////////////////////////////////////////////////////////////////////// // Introspection functions int GetX86FeaturesEnumValue(const X86Features* features, X86FeaturesEnum value) { switch (value) { case X86_AES: return features->aes; case X86_ERMS: return features->erms; case X86_F16C: return features->f16c; case X86_FMA3: return features->fma3; case X86_VPCLMULQDQ: return features->vpclmulqdq; case X86_BMI1: return features->bmi1; case X86_BMI2: return features->bmi2; case X86_SSSE3: return features->ssse3; case X86_SSE4_1: return features->sse4_1; case X86_SSE4_2: return features->sse4_2; case X86_AVX: return features->avx; case X86_AVX2: return features->avx2; case X86_AVX512F: return features->avx512f; case X86_AVX512CD: return features->avx512cd; case X86_AVX512ER: return features->avx512er; case X86_AVX512PF: return features->avx512pf; case X86_AVX512BW: return features->avx512bw; case X86_AVX512DQ: return features->avx512dq; case X86_AVX512VL: return features->avx512vl; case X86_AVX512IFMA: return features->avx512ifma; case X86_AVX512VBMI: return features->avx512vbmi; case X86_AVX512VBMI2: return features->avx512vbmi2; case X86_AVX512VNNI: return features->avx512vnni; case X86_AVX512BITALG: return features->avx512bitalg; case X86_AVX512VPOPCNTDQ: return features->avx512vpopcntdq; case X86_AVX512_4VNNIW: return features->avx512_4vnniw; case X86_AVX512_4VBMI2: return features->avx512_4vbmi2; case X86_SMX: return features->smx; case X86_SGX: return features->sgx; case X86_CX16: return features->cx16; case X86_LAST_: break; } return false; } const char* GetX86FeaturesEnumName(X86FeaturesEnum value) { switch (value) { case X86_AES: return "aes"; case X86_ERMS: return "erms"; case X86_F16C: return "f16c"; case X86_FMA3: return "fma3"; case X86_VPCLMULQDQ: return "vpclmulqdq"; case X86_BMI1: return "bmi1"; case X86_BMI2: return "bmi2"; case X86_SSSE3: return "ssse3"; case X86_SSE4_1: return "sse4_1"; case X86_SSE4_2: return "sse4_2"; case X86_AVX: return "avx"; case X86_AVX2: return "avx2"; case X86_AVX512F: return "avx512f"; case X86_AVX512CD: return "avx512cd"; case X86_AVX512ER: return "avx512er"; case X86_AVX512PF: return "avx512pf"; case X86_AVX512BW: return "avx512bw"; case X86_AVX512DQ: return "avx512dq"; case X86_AVX512VL: return "avx512vl"; case X86_AVX512IFMA: return "avx512ifma"; case X86_AVX512VBMI: return "avx512vbmi"; case X86_AVX512VBMI2: return "avx512vbmi2"; case X86_AVX512VNNI: return "avx512vnni"; case X86_AVX512BITALG: return "avx512bitalg"; case X86_AVX512VPOPCNTDQ: return "avx512vpopcntdq"; case X86_AVX512_4VNNIW: return "avx512_4vnniw"; case X86_AVX512_4VBMI2: return "avx512_4vbmi2"; case X86_SMX: return "smx"; case X86_SGX: return "sgx"; case X86_CX16: return "cx16"; case X86_LAST_: break; } return "unknown_feature"; } const char* GetX86MicroarchitectureName(X86Microarchitecture uarch) { switch (uarch) { case X86_UNKNOWN: return "X86_UNKNOWN"; case INTEL_CORE: return "INTEL_CORE"; case INTEL_PNR: return "INTEL_PNR"; case INTEL_NHM: return "INTEL_NHM"; case INTEL_ATOM_BNL: return "INTEL_ATOM_BNL"; case INTEL_WSM: return "INTEL_WSM"; case INTEL_SNB: return "INTEL_SNB"; case INTEL_IVB: return "INTEL_IVB"; case INTEL_ATOM_SMT: return "INTEL_ATOM_SMT"; case INTEL_HSW: return "INTEL_HSW"; case INTEL_BDW: return "INTEL_BDW"; case INTEL_SKL: return "INTEL_SKL"; case INTEL_ATOM_GMT: return "INTEL_ATOM_GMT"; case INTEL_KBL: return "INTEL_KBL"; case INTEL_CFL: return "INTEL_CFL"; case INTEL_CNL: return "INTEL_CNL"; case AMD_HAMMER: return "AMD_HAMMER"; case AMD_K10: return "AMD_K10"; case AMD_BOBCAT: return "AMD_BOBCAT"; case AMD_BULLDOZER: return "AMD_BULLDOZER"; case AMD_JAGUAR: return "AMD_JAGUAR"; case AMD_ZEN: return "AMD_ZEN"; } return "unknown microarchitecture"; } anbox-0.0~git20191115/external/cpu_features/src/filesystem.c000066400000000000000000000031121356361734700236500ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "internal/filesystem.h" #include #include #include #include #if defined(_MSC_VER) #include int CpuFeatures_OpenFile(const char* filename) { return _open(filename, _O_RDONLY); } void CpuFeatures_CloseFile(int file_descriptor) { _close(file_descriptor); } int CpuFeatures_ReadFile(int file_descriptor, void* buffer, size_t buffer_size) { return _read(file_descriptor, buffer, buffer_size); } #else #include int CpuFeatures_OpenFile(const char* filename) { int result; do { result = open(filename, O_RDONLY); } while (result == -1L && errno == EINTR); return result; } void CpuFeatures_CloseFile(int file_descriptor) { close(file_descriptor); } int CpuFeatures_ReadFile(int file_descriptor, void* buffer, size_t buffer_size) { int result; do { result = read(file_descriptor, buffer, buffer_size); } while (result == -1L && errno == EINTR); return result; } #endif anbox-0.0~git20191115/external/cpu_features/src/hwcaps.c000066400000000000000000000141371356361734700227620ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include "cpu_features_macros.h" #include "internal/filesystem.h" #include "internal/hwcaps.h" #include "internal/string_view.h" #if defined(NDEBUG) #define D(...) #else #include #define D(...) \ do { \ printf(__VA_ARGS__); \ fflush(stdout); \ } while (0) #endif #if defined(CPU_FEATURES_ARCH_MIPS) || defined(CPU_FEATURES_ARCH_ANY_ARM) #define HWCAPS_ANDROID_MIPS_OR_ARM #endif #if defined(CPU_FEATURES_OS_LINUX_OR_ANDROID) && \ !defined(HWCAPS_ANDROID_MIPS_OR_ARM) #define HWCAPS_REGULAR_LINUX #endif #if defined(HWCAPS_ANDROID_MIPS_OR_ARM) || defined(HWCAPS_REGULAR_LINUX) #define HWCAPS_SUPPORTED #endif //////////////////////////////////////////////////////////////////////////////// // Implementation of GetElfHwcapFromGetauxval //////////////////////////////////////////////////////////////////////////////// // On Linux we simply use getauxval. #if defined(HWCAPS_REGULAR_LINUX) #include #include static unsigned long GetElfHwcapFromGetauxval(uint32_t hwcap_type) { return getauxval(hwcap_type); } #endif // defined(HWCAPS_REGULAR_LINUX) // On Android we probe the system's C library for a 'getauxval' function and // call it if it exits, or return 0 for failure. This function is available // since API level 20. // // This code does *NOT* check for '__ANDROID_API__ >= 20' to support the edge // case where some NDK developers use headers for a platform that is newer than // the one really targetted by their application. This is typically done to use // newer native APIs only when running on more recent Android versions, and // requires careful symbol management. // // Note that getauxval() can't really be re-implemented here, because its // implementation does not parse /proc/self/auxv. Instead it depends on values // that are passed by the kernel at process-init time to the C runtime // initialization layer. #if defined(HWCAPS_ANDROID_MIPS_OR_ARM) #include #define AT_HWCAP 16 #define AT_HWCAP2 26 #define AT_PLATFORM 15 #define AT_BASE_PLATFORM 24 typedef unsigned long getauxval_func_t(unsigned long); static uint32_t GetElfHwcapFromGetauxval(uint32_t hwcap_type) { uint32_t ret = 0; void* libc_handle = NULL; getauxval_func_t* func = NULL; dlerror(); // Cleaning error state before calling dlopen. libc_handle = dlopen("libc.so", RTLD_NOW); if (!libc_handle) { D("Could not dlopen() C library: %s\n", dlerror()); return 0; } func = (getauxval_func_t*)dlsym(libc_handle, "getauxval"); if (!func) { D("Could not find getauxval() in C library\n"); } else { // Note: getauxval() returns 0 on failure. Doesn't touch errno. ret = (uint32_t)(*func)(hwcap_type); } dlclose(libc_handle); return ret; } #endif // defined(HWCAPS_ANDROID_MIPS_OR_ARM) #if defined(HWCAPS_SUPPORTED) //////////////////////////////////////////////////////////////////////////////// // Implementation of GetHardwareCapabilities for Android and Linux //////////////////////////////////////////////////////////////////////////////// // Fallback when getauxval is not available, retrieves hwcaps from // "/proc/self/auxv". static uint32_t GetElfHwcapFromProcSelfAuxv(uint32_t hwcap_type) { struct { uint32_t tag; uint32_t value; } entry; uint32_t result = 0; const char filepath[] = "/proc/self/auxv"; const int fd = CpuFeatures_OpenFile(filepath); if (fd < 0) { D("Could not open %s\n", filepath); return 0; } for (;;) { const int ret = CpuFeatures_ReadFile(fd, (char*)&entry, sizeof entry); if (ret < 0) { D("Error while reading %s\n", filepath); break; } // Detect end of list. if (ret == 0 || (entry.tag == 0 && entry.value == 0)) { break; } if (entry.tag == hwcap_type) { result = entry.value; break; } } CpuFeatures_CloseFile(fd); return result; } // Retrieves hardware capabilities by first trying to call getauxval, if not // available falls back to reading "/proc/self/auxv". static unsigned long GetHardwareCapabilitiesFor(uint32_t type) { unsigned long hwcaps = GetElfHwcapFromGetauxval(type); if (!hwcaps) { D("Parsing /proc/self/auxv to extract ELF hwcaps!\n"); hwcaps = GetElfHwcapFromProcSelfAuxv(type); } return hwcaps; } HardwareCapabilities CpuFeatures_GetHardwareCapabilities(void) { HardwareCapabilities capabilities; capabilities.hwcaps = GetHardwareCapabilitiesFor(AT_HWCAP); capabilities.hwcaps2 = GetHardwareCapabilitiesFor(AT_HWCAP2); return capabilities; } PlatformType kEmptyPlatformType; PlatformType CpuFeatures_GetPlatformType(void) { PlatformType type = kEmptyPlatformType; char *platform = (char *)GetHardwareCapabilitiesFor(AT_PLATFORM); char *base_platform = (char *)GetHardwareCapabilitiesFor(AT_BASE_PLATFORM); if (platform != NULL) CpuFeatures_StringView_CopyString(str(platform), type.platform, sizeof(type.platform)); if (base_platform != NULL) CpuFeatures_StringView_CopyString(str(base_platform), type.base_platform, sizeof(type.base_platform)); return type; } #else // (defined(HWCAPS_SUPPORTED) //////////////////////////////////////////////////////////////////////////////// // Implementation of GetHardwareCapabilities for unsupported platforms. //////////////////////////////////////////////////////////////////////////////// const HardwareCapabilities kEmptyHardwareCapabilities; HardwareCapabilities CpuFeatures_GetHardwareCapabilities(void) { return kEmptyHardwareCapabilities; } #endif anbox-0.0~git20191115/external/cpu_features/src/linux_features_aggregator.c000066400000000000000000000036261356361734700267350ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "internal/linux_features_aggregator.h" #include "internal/string_view.h" void CpuFeatures_SetFromFlags(const size_t configs_size, const CapabilityConfig* configs, const StringView flags_line, void* const features) { size_t i = 0; for (; i < configs_size; ++i) { const CapabilityConfig config = configs[i]; config.set_bit(features, CpuFeatures_StringView_HasWord( flags_line, config.proc_cpuinfo_flag)); } } static bool IsSet(const uint32_t mask, const uint32_t value) { return (value & mask) == mask; } static bool IsHwCapsSet(const HardwareCapabilities hwcaps_mask, const HardwareCapabilities hwcaps) { return IsSet(hwcaps_mask.hwcaps, hwcaps.hwcaps) && IsSet(hwcaps_mask.hwcaps2, hwcaps.hwcaps2); } void CpuFeatures_OverrideFromHwCaps(const size_t configs_size, const CapabilityConfig* configs, const HardwareCapabilities hwcaps, void* const features) { size_t i = 0; for (; i < configs_size; ++i) { const CapabilityConfig* config = &configs[i]; if (IsHwCapsSet(config->hwcaps_mask, hwcaps)) { config->set_bit(features, true); } } } anbox-0.0~git20191115/external/cpu_features/src/stack_line_reader.c000066400000000000000000000100501356361734700251210ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "internal/stack_line_reader.h" #include "internal/filesystem.h" #include #include #include void StackLineReader_Initialize(StackLineReader* reader, int fd) { reader->view.ptr = reader->buffer; reader->view.size = 0; reader->skip_mode = false; reader->fd = fd; } // Replaces the content of buffer with bytes from the file. static int LoadFullBuffer(StackLineReader* reader) { const int read = CpuFeatures_ReadFile(reader->fd, reader->buffer, STACK_LINE_READER_BUFFER_SIZE); assert(read >= 0); reader->view.ptr = reader->buffer; reader->view.size = read; return read; } // Appends with bytes from the file to buffer, filling the remaining space. static int LoadMore(StackLineReader* reader) { char* const ptr = reader->buffer + reader->view.size; const size_t size_to_read = STACK_LINE_READER_BUFFER_SIZE - reader->view.size; const int read = CpuFeatures_ReadFile(reader->fd, ptr, size_to_read); assert(read >= 0); assert(read <= (int)size_to_read); reader->view.size += read; return read; } static int IndexOfEol(StackLineReader* reader) { return CpuFeatures_StringView_IndexOfChar(reader->view, '\n'); } // Relocate buffer's pending bytes at the beginning of the array and fills the // remaining space with bytes from the file. static int BringToFrontAndLoadMore(StackLineReader* reader) { if (reader->view.size && reader->view.ptr != reader->buffer) { memmove(reader->buffer, reader->view.ptr, reader->view.size); } reader->view.ptr = reader->buffer; return LoadMore(reader); } // Loads chunks of buffer size from disks until it contains a newline character // or end of file. static void SkipToNextLine(StackLineReader* reader) { for (;;) { const int read = LoadFullBuffer(reader); if (read == 0) { break; } else { const int eol_index = IndexOfEol(reader); if (eol_index >= 0) { reader->view = CpuFeatures_StringView_PopFront(reader->view, eol_index + 1); break; } } } } static LineResult CreateLineResult(bool eof, bool full_line, StringView view) { LineResult result; result.eof = eof; result.full_line = full_line; result.line = view; return result; } // Helper methods to provide clearer semantic in StackLineReader_NextLine. static LineResult CreateEOFLineResult(StringView view) { return CreateLineResult(true, true, view); } static LineResult CreateTruncatedLineResult(StringView view) { return CreateLineResult(false, false, view); } static LineResult CreateValidLineResult(StringView view) { return CreateLineResult(false, true, view); } LineResult StackLineReader_NextLine(StackLineReader* reader) { if (reader->skip_mode) { SkipToNextLine(reader); reader->skip_mode = false; } { const bool can_load_more = reader->view.size < STACK_LINE_READER_BUFFER_SIZE; int eol_index = IndexOfEol(reader); if (eol_index < 0 && can_load_more) { const int read = BringToFrontAndLoadMore(reader); if (read == 0) { return CreateEOFLineResult(reader->view); } eol_index = IndexOfEol(reader); } if (eol_index < 0) { reader->skip_mode = true; return CreateTruncatedLineResult(reader->view); } { StringView line = CpuFeatures_StringView_KeepFront(reader->view, eol_index); reader->view = CpuFeatures_StringView_PopFront(reader->view, eol_index + 1); return CreateValidLineResult(line); } } } anbox-0.0~git20191115/external/cpu_features/src/string_view.c000066400000000000000000000141641356361734700240350ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "internal/string_view.h" #include #include #include int CpuFeatures_StringView_IndexOfChar(const StringView view, char c) { if (view.ptr && view.size) { const char* const found = (const char*)memchr(view.ptr, c, view.size); if (found) { return found - view.ptr; } } return -1; } int CpuFeatures_StringView_IndexOf(const StringView view, const StringView sub_view) { if (sub_view.size) { StringView remainder = view; while (remainder.size >= sub_view.size) { const int found_index = CpuFeatures_StringView_IndexOfChar(remainder, sub_view.ptr[0]); if (found_index < 0) break; remainder = CpuFeatures_StringView_PopFront(remainder, found_index); if (CpuFeatures_StringView_StartsWith(remainder, sub_view)) { return remainder.ptr - view.ptr; } remainder = CpuFeatures_StringView_PopFront(remainder, 1); } } return -1; } bool CpuFeatures_StringView_IsEquals(const StringView a, const StringView b) { if (a.size == b.size) { return a.ptr == b.ptr || memcmp(a.ptr, b.ptr, b.size) == 0; } return false; } bool CpuFeatures_StringView_StartsWith(const StringView a, const StringView b) { return a.ptr && b.ptr && b.size && a.size >= b.size ? memcmp(a.ptr, b.ptr, b.size) == 0 : false; } StringView CpuFeatures_StringView_PopFront(const StringView str_view, size_t count) { if (count > str_view.size) { return kEmptyStringView; } return view(str_view.ptr + count, str_view.size - count); } StringView CpuFeatures_StringView_PopBack(const StringView str_view, size_t count) { if (count > str_view.size) { return kEmptyStringView; } return view(str_view.ptr, str_view.size - count); } StringView CpuFeatures_StringView_KeepFront(const StringView str_view, size_t count) { return count <= str_view.size ? view(str_view.ptr, count) : str_view; } char CpuFeatures_StringView_Front(const StringView view) { assert(view.size); assert(view.ptr); return view.ptr[0]; } char CpuFeatures_StringView_Back(const StringView view) { assert(view.size); return view.ptr[view.size - 1]; } StringView CpuFeatures_StringView_TrimWhitespace(StringView view) { while (view.size && isspace(CpuFeatures_StringView_Front(view))) view = CpuFeatures_StringView_PopFront(view, 1); while (view.size && isspace(CpuFeatures_StringView_Back(view))) view = CpuFeatures_StringView_PopBack(view, 1); return view; } static int HexValue(const char c) { if (c >= '0' && c <= '9') return c - '0'; if (c >= 'a' && c <= 'f') return c - 'a' + 10; if (c >= 'A' && c <= 'F') return c - 'A' + 10; return -1; } // Returns -1 if view contains non digits. static int ParsePositiveNumberWithBase(const StringView view, int base) { int result = 0; StringView remainder = view; for (; remainder.size; remainder = CpuFeatures_StringView_PopFront(remainder, 1)) { const int value = HexValue(CpuFeatures_StringView_Front(remainder)); if (value < 0 || value >= base) return -1; result = (result * base) + value; } return result; } int CpuFeatures_StringView_ParsePositiveNumber(const StringView view) { if (view.size) { const StringView hex_prefix = str("0x"); if (CpuFeatures_StringView_StartsWith(view, hex_prefix)) { const StringView span_no_prefix = CpuFeatures_StringView_PopFront(view, hex_prefix.size); return ParsePositiveNumberWithBase(span_no_prefix, 16); } return ParsePositiveNumberWithBase(view, 10); } return -1; } void CpuFeatures_StringView_CopyString(const StringView src, char* dst, size_t dst_size) { if (dst_size > 0) { const size_t max_copy_size = dst_size - 1; const size_t copy_size = src.size > max_copy_size ? max_copy_size : src.size; memcpy(dst, src.ptr, copy_size); dst[copy_size] = '\0'; } } bool CpuFeatures_StringView_HasWord(const StringView line, const char* const word_str) { const StringView word = str(word_str); StringView remainder = line; for (;;) { const int index_of_word = CpuFeatures_StringView_IndexOf(remainder, word); if (index_of_word < 0) { return false; } else { const StringView before = CpuFeatures_StringView_KeepFront(line, index_of_word); const StringView after = CpuFeatures_StringView_PopFront(line, index_of_word + word.size); const bool valid_before = before.size == 0 || CpuFeatures_StringView_Back(before) == ' '; const bool valid_after = after.size == 0 || CpuFeatures_StringView_Front(after) == ' '; if (valid_before && valid_after) return true; remainder = CpuFeatures_StringView_PopFront(remainder, index_of_word + word.size); } } return false; } bool CpuFeatures_StringView_GetAttributeKeyValue(const StringView line, StringView* key, StringView* value) { const StringView sep = str(": "); const int index_of_separator = CpuFeatures_StringView_IndexOf(line, sep); if (index_of_separator < 0) return false; *value = CpuFeatures_StringView_TrimWhitespace( CpuFeatures_StringView_PopFront(line, index_of_separator + sep.size)); *key = CpuFeatures_StringView_TrimWhitespace( CpuFeatures_StringView_KeepFront(line, index_of_separator)); return true; } anbox-0.0~git20191115/external/cpu_features/src/utils/000077500000000000000000000000001356361734700224635ustar00rootroot00000000000000anbox-0.0~git20191115/external/cpu_features/src/utils/list_cpu_features.c000066400000000000000000000202471356361734700263540ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "cpu_features_macros.h" #include "cpuinfo_aarch64.h" #include "cpuinfo_arm.h" #include "cpuinfo_mips.h" #include "cpuinfo_ppc.h" #include "cpuinfo_x86.h" static void PrintEscapedAscii(const char* str) { putchar('"'); for (; str && *str; ++str) { switch (*str) { case '\"': case '\\': case '/': case '\b': case '\f': case '\n': case '\r': case '\t': putchar('\\'); } putchar(*str); } putchar('"'); } static void PrintVoid(void) {} static void PrintComma(void) { putchar(','); } static void PrintLineFeed(void) { putchar('\n'); } static void PrintOpenBrace(void) { putchar('{'); } static void PrintCloseBrace(void) { putchar('}'); } static void PrintOpenBracket(void) { putchar('['); } static void PrintCloseBracket(void) { putchar(']'); } static void PrintString(const char* field) { printf("%s", field); } static void PrintAlignedHeader(const char* field) { printf("%-15s : ", field); } static void PrintIntValue(int value) { printf("%d", value); } static void PrintDecHexValue(int value) { printf("%3d (0x%02X)", value, value); } static void PrintJsonHeader(const char* field) { PrintEscapedAscii(field); putchar(':'); } typedef struct { void (*Start)(void); void (*ArrayStart)(void); void (*ArraySeparator)(void); void (*ArrayEnd)(void); void (*PrintString)(const char* value); void (*PrintValue)(int value); void (*EndField)(void); void (*StartField)(const char* field); void (*End)(void); } Printer; static Printer getJsonPrinter(void) { return (Printer){ .Start = &PrintOpenBrace, .ArrayStart = &PrintOpenBracket, .ArraySeparator = &PrintComma, .ArrayEnd = &PrintCloseBracket, .PrintString = &PrintEscapedAscii, .PrintValue = &PrintIntValue, .EndField = &PrintComma, .StartField = &PrintJsonHeader, .End = &PrintCloseBrace, }; } static Printer getTextPrinter(void) { return (Printer){ .Start = &PrintVoid, .ArrayStart = &PrintVoid, .ArraySeparator = &PrintComma, .ArrayEnd = &PrintVoid, .PrintString = &PrintString, .PrintValue = &PrintDecHexValue, .EndField = &PrintLineFeed, .StartField = &PrintAlignedHeader, .End = &PrintVoid, }; } // Prints a named numeric value in both decimal and hexadecimal. static void PrintN(const Printer p, const char* field, int value) { p.StartField(field); p.PrintValue(value); p.EndField(); } // Prints a named string. static void PrintS(const Printer p, const char* field, const char* value) { p.StartField(field); p.PrintString(value); p.EndField(); } static int cmp(const void* p1, const void* p2) { return strcmp(*(const char* const*)p1, *(const char* const*)p2); } #define DEFINE_PRINT_FLAGS(HasFeature, FeatureName, FeatureType, LastEnum) \ static void PrintFlags(const Printer p, const FeatureType* features) { \ size_t i; \ const char* ptrs[LastEnum] = {0}; \ size_t count = 0; \ for (i = 0; i < LastEnum; ++i) { \ if (HasFeature(features, i)) { \ ptrs[count] = FeatureName(i); \ ++count; \ } \ } \ qsort(ptrs, count, sizeof(char*), cmp); \ p.StartField("flags"); \ p.ArrayStart(); \ for (i = 0; i < count; ++i) { \ if (i > 0) p.ArraySeparator(); \ p.PrintString(ptrs[i]); \ } \ p.ArrayEnd(); \ } #if defined(CPU_FEATURES_ARCH_X86) DEFINE_PRINT_FLAGS(GetX86FeaturesEnumValue, GetX86FeaturesEnumName, X86Features, X86_LAST_) #elif defined(CPU_FEATURES_ARCH_ARM) DEFINE_PRINT_FLAGS(GetArmFeaturesEnumValue, GetArmFeaturesEnumName, ArmFeatures, ARM_LAST_) #elif defined(CPU_FEATURES_ARCH_AARCH64) DEFINE_PRINT_FLAGS(GetAarch64FeaturesEnumValue, GetAarch64FeaturesEnumName, Aarch64Features, AARCH64_LAST_) #elif defined(CPU_FEATURES_ARCH_MIPS) DEFINE_PRINT_FLAGS(GetMipsFeaturesEnumValue, GetMipsFeaturesEnumName, MipsFeatures, MIPS_LAST_) #elif defined(CPU_FEATURES_ARCH_PPC) DEFINE_PRINT_FLAGS(GetPPCFeaturesEnumValue, GetPPCFeaturesEnumName, PPCFeatures, PPC_LAST_) #endif static void PrintFeatures(const Printer printer) { #if defined(CPU_FEATURES_ARCH_X86) char brand_string[49]; const X86Info info = GetX86Info(); FillX86BrandString(brand_string); PrintS(printer, "arch", "x86"); PrintS(printer, "brand", brand_string); PrintN(printer, "family", info.family); PrintN(printer, "model", info.model); PrintN(printer, "stepping", info.stepping); PrintS(printer, "uarch", GetX86MicroarchitectureName(GetX86Microarchitecture(&info))); PrintFlags(printer, &info.features); #elif defined(CPU_FEATURES_ARCH_ARM) const ArmInfo info = GetArmInfo(); PrintS(printer, "arch", "ARM"); PrintN(printer, "implementer", info.implementer); PrintN(printer, "architecture", info.architecture); PrintN(printer, "variant", info.variant); PrintN(printer, "part", info.part); PrintN(printer, "revision", info.revision); PrintFlags(printer, &info.features); #elif defined(CPU_FEATURES_ARCH_AARCH64) const Aarch64Info info = GetAarch64Info(); PrintS(printer, "arch", "aarch64"); PrintN(printer, "implementer", info.implementer); PrintN(printer, "variant", info.variant); PrintN(printer, "part", info.part); PrintN(printer, "revision", info.revision); PrintFlags(printer, &info.features); #elif defined(CPU_FEATURES_ARCH_MIPS) const MipsInfo info = GetMipsInfo(); PrintS(printer, "arch", "mips"); PrintFlags(printer, &info.features); #elif defined(CPU_FEATURES_ARCH_PPC) const PPCInfo info = GetPPCInfo(); const PPCPlatformStrings strings = GetPPCPlatformStrings(); PrintS(printer, "arch", "ppc"); PrintS(printer, "platform", strings.platform); PrintS(printer, "model", strings.model); PrintS(printer, "machine", strings.machine); PrintS(printer, "cpu", strings.cpu); PrintS(printer, "instruction set", strings.type.platform); PrintS(printer, "microarchitecture", strings.type.base_platform); PrintFlags(printer, &info.features); #endif } static void showUsage(const char* name) { printf( "\n" "Usage: %s [options]\n" " Options:\n" " -h | --help Show help message.\n" " -j | --json Format output as json instead of plain text.\n" "\n", name); } int main(int argc, char** argv) { Printer printer = getTextPrinter(); int i = 1; for (; i < argc; ++i) { const char* arg = argv[i]; if (strcmp(arg, "-j") == 0 || strcmp(arg, "--json") == 0) { printer = getJsonPrinter(); } else { showUsage(argv[0]); if (strcmp(arg, "-h") == 0 || strcmp(arg, "--help") == 0) return EXIT_SUCCESS; return EXIT_FAILURE; } } printer.Start(); PrintFeatures(printer); printer.End(); PrintLineFeed(); return EXIT_SUCCESS; } anbox-0.0~git20191115/external/cpu_features/test/000077500000000000000000000000001356361734700215135ustar00rootroot00000000000000anbox-0.0~git20191115/external/cpu_features/test/CMakeLists.txt000066400000000000000000000101341356361734700242520ustar00rootroot00000000000000# # libraries for tests # set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) # prefer use of -std11 instead of -gnustd11 include_directories(../include) add_definitions(-DCPU_FEATURES_TEST) ##------------------------------------------------------------------------------ add_library(string_view ../src/string_view.c) ##------------------------------------------------------------------------------ add_library(filesystem_for_testing filesystem_for_testing.cc) ##------------------------------------------------------------------------------ add_library(hwcaps_for_testing hwcaps_for_testing.cc) target_link_libraries(hwcaps_for_testing filesystem_for_testing) ##------------------------------------------------------------------------------ add_library(stack_line_reader ../src/stack_line_reader.c) target_compile_definitions(stack_line_reader PUBLIC STACK_LINE_READER_BUFFER_SIZE=1024) target_link_libraries(stack_line_reader string_view) ##------------------------------------------------------------------------------ add_library(stack_line_reader_for_test ../src/stack_line_reader.c) target_compile_definitions(stack_line_reader_for_test PUBLIC STACK_LINE_READER_BUFFER_SIZE=16) target_link_libraries(stack_line_reader_for_test string_view filesystem_for_testing) ##------------------------------------------------------------------------------ add_library(all_libraries ../src/stack_line_reader.c ../src/linux_features_aggregator.c) target_link_libraries(all_libraries hwcaps_for_testing stack_line_reader string_view) # # tests # link_libraries(gtest gmock_main) ## bit_utils_test add_executable(bit_utils_test bit_utils_test.cc) target_link_libraries(bit_utils_test) add_test(NAME bit_utils_test COMMAND bit_utils_test) ##------------------------------------------------------------------------------ ## string_view_test add_executable(string_view_test string_view_test.cc ../src/string_view.c) target_link_libraries(string_view_test string_view) add_test(NAME string_view_test COMMAND string_view_test) ##------------------------------------------------------------------------------ ## stack_line_reader_test add_executable(stack_line_reader_test stack_line_reader_test.cc) target_link_libraries(stack_line_reader_test stack_line_reader_for_test) add_test(NAME stack_line_reader_test COMMAND stack_line_reader_test) ##------------------------------------------------------------------------------ ## linux_features_aggregator_test add_executable(linux_features_aggregator_test linux_features_aggregator_test.cc) target_link_libraries(linux_features_aggregator_test all_libraries) add_test(NAME linux_features_aggregator_test COMMAND linux_features_aggregator_test) ##------------------------------------------------------------------------------ ## cpuinfo_x86_test add_executable(cpuinfo_x86_test cpuinfo_x86_test.cc ../src/cpuinfo_x86.c) target_link_libraries(cpuinfo_x86_test all_libraries) add_test(NAME cpuinfo_x86_test COMMAND cpuinfo_x86_test) ##------------------------------------------------------------------------------ ## cpuinfo_arm_test add_executable(cpuinfo_arm_test cpuinfo_arm_test.cc ../src/cpuinfo_arm.c) target_link_libraries(cpuinfo_arm_test all_libraries) add_test(NAME cpuinfo_arm_test COMMAND cpuinfo_arm_test) ##------------------------------------------------------------------------------ ## cpuinfo_aarch64_test add_executable(cpuinfo_aarch64_test cpuinfo_aarch64_test.cc ../src/cpuinfo_aarch64.c) target_link_libraries(cpuinfo_aarch64_test all_libraries) add_test(NAME cpuinfo_aarch64_test COMMAND cpuinfo_aarch64_test) ##------------------------------------------------------------------------------ ## cpuinfo_mips_test add_executable(cpuinfo_mips_test cpuinfo_mips_test.cc ../src/cpuinfo_mips.c) target_link_libraries(cpuinfo_mips_test all_libraries) add_test(NAME cpuinfo_mips_test COMMAND cpuinfo_mips_test) ##------------------------------------------------------------------------------ ## cpuinfo_ppc_test add_executable(cpuinfo_ppc_test cpuinfo_ppc_test.cc ../src/cpuinfo_ppc.c) target_link_libraries(cpuinfo_ppc_test all_libraries) add_test(NAME cpuinfo_ppc_test COMMAND cpuinfo_ppc_test) anbox-0.0~git20191115/external/cpu_features/test/bit_utils_test.cc000066400000000000000000000030071356361734700250570ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "internal/bit_utils.h" #include "gtest/gtest.h" namespace cpu_features { namespace { TEST(UtilsTest, IsBitSet) { for (size_t bit_set = 0; bit_set < 32; ++bit_set) { const uint32_t value = 1UL << bit_set; for (size_t i = 0; i < 32; ++i) { EXPECT_EQ(IsBitSet(value, i), i == bit_set); } } // testing 0, all bits should be 0. for (size_t i = 0; i < 32; ++i) { EXPECT_FALSE(IsBitSet(0, i)); } // testing ~0, all bits should be 1. for (size_t i = 0; i < 32; ++i) { EXPECT_TRUE(IsBitSet(-1, i)); } } TEST(UtilsTest, ExtractBitRange) { // Extracting all bits gives the same number. EXPECT_EQ(ExtractBitRange(123, 31, 0), 123); // Extracting 1 bit gives parity. EXPECT_EQ(ExtractBitRange(123, 0, 0), 1); EXPECT_EQ(ExtractBitRange(122, 0, 0), 0); EXPECT_EQ(ExtractBitRange(0xF0, 7, 4), 0xF); EXPECT_EQ(ExtractBitRange(0x42 << 2, 10, 2), 0x42); } } // namespace } // namespace cpu_features anbox-0.0~git20191115/external/cpu_features/test/cpuinfo_aarch64_test.cc000066400000000000000000000043041356361734700260350ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "cpuinfo_aarch64.h" #include "filesystem_for_testing.h" #include "hwcaps_for_testing.h" #include "gtest/gtest.h" namespace cpu_features { namespace { void DisableHardwareCapabilities() { SetHardwareCapabilities(0, 0); } TEST(CpuinfoAarch64Test, FromHardwareCap) { SetHardwareCapabilities(AARCH64_HWCAP_FP | AARCH64_HWCAP_AES, 0); GetEmptyFilesystem(); // disabling /proc/cpuinfo const auto info = GetAarch64Info(); EXPECT_TRUE(info.features.fp); EXPECT_FALSE(info.features.asimd); EXPECT_TRUE(info.features.aes); EXPECT_FALSE(info.features.pmull); EXPECT_FALSE(info.features.sha1); EXPECT_FALSE(info.features.sha2); EXPECT_FALSE(info.features.crc32); } TEST(CpuinfoAarch64Test, ARMCortexA53) { DisableHardwareCapabilities(); auto& fs = GetEmptyFilesystem(); fs.CreateFile("/proc/cpuinfo", R"(Processor : AArch64 Processor rev 3 (aarch64) processor : 0 processor : 1 processor : 2 processor : 3 processor : 4 processor : 5 processor : 6 processor : 7 Features : fp asimd evtstrm aes pmull sha1 sha2 crc32 CPU implementer : 0x41 CPU architecture: AArch64 CPU variant : 0x0 CPU part : 0xd03 CPU revision : 3)"); const auto info = GetAarch64Info(); EXPECT_EQ(info.implementer, 0x41); EXPECT_EQ(info.variant, 0x0); EXPECT_EQ(info.part, 0xd03); EXPECT_EQ(info.revision, 3); EXPECT_TRUE(info.features.fp); EXPECT_TRUE(info.features.asimd); EXPECT_TRUE(info.features.aes); EXPECT_TRUE(info.features.pmull); EXPECT_TRUE(info.features.sha1); EXPECT_TRUE(info.features.sha2); EXPECT_TRUE(info.features.crc32); } } // namespace } // namespace cpu_features anbox-0.0~git20191115/external/cpu_features/test/cpuinfo_arm_test.cc000066400000000000000000000126161356361734700253710ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "cpuinfo_arm.h" #include "filesystem_for_testing.h" #include "hwcaps_for_testing.h" #include "gtest/gtest.h" namespace cpu_features { namespace { void DisableHardwareCapabilities() { SetHardwareCapabilities(0, 0); } TEST(CpuinfoArmTest, FromHardwareCap) { SetHardwareCapabilities(ARM_HWCAP_NEON, ARM_HWCAP2_AES | ARM_HWCAP2_CRC32); GetEmptyFilesystem(); // disabling /proc/cpuinfo const auto info = GetArmInfo(); EXPECT_TRUE(info.features.vfp); // triggered by vfpv3 EXPECT_TRUE(info.features.vfpv3); // triggered by neon EXPECT_TRUE(info.features.neon); EXPECT_TRUE(info.features.aes); EXPECT_TRUE(info.features.crc32); EXPECT_FALSE(info.features.vfpv4); EXPECT_FALSE(info.features.iwmmxt); EXPECT_FALSE(info.features.vfpv3d16); EXPECT_FALSE(info.features.idiva); EXPECT_FALSE(info.features.idivt); EXPECT_FALSE(info.features.pmull); EXPECT_FALSE(info.features.sha1); EXPECT_FALSE(info.features.sha2); } TEST(CpuinfoArmTest, ODroidFromCpuInfo) { DisableHardwareCapabilities(); auto& fs = GetEmptyFilesystem(); fs.CreateFile("/proc/cpuinfo", R"(processor : 0 model name : ARMv7 Processor rev 3 (v71) BogoMIPS : 120.00 Features : half thumb fastmult vfp edsp neon vfpv3 tls vfpv4 idiva idivt vfpd32 lpae CPU implementer : 0x41 CPU architecture: 7 CPU variant : 0x2 CPU part : 0xc0f CPU revision : 3)"); const auto info = GetArmInfo(); EXPECT_EQ(info.implementer, 0x41); EXPECT_EQ(info.variant, 0x2); EXPECT_EQ(info.part, 0xc0f); EXPECT_EQ(info.revision, 3); EXPECT_EQ(info.architecture, 7); EXPECT_TRUE(info.features.vfp); EXPECT_FALSE(info.features.iwmmxt); EXPECT_TRUE(info.features.neon); EXPECT_TRUE(info.features.vfpv3); EXPECT_FALSE(info.features.vfpv3d16); EXPECT_TRUE(info.features.vfpv4); EXPECT_TRUE(info.features.idiva); EXPECT_TRUE(info.features.idivt); EXPECT_FALSE(info.features.aes); EXPECT_FALSE(info.features.pmull); EXPECT_FALSE(info.features.sha1); EXPECT_FALSE(info.features.sha2); EXPECT_FALSE(info.features.crc32); } // http://code.google.com/p/android/issues/detail?id=10812 TEST(CpuinfoArmTest, InvalidArmv7) { DisableHardwareCapabilities(); auto& fs = GetEmptyFilesystem(); fs.CreateFile("/proc/cpuinfo", R"(Processor : ARMv6-compatible processor rev 6 (v6l) BogoMIPS : 199.47 Features : swp half thumb fastmult vfp edsp java CPU implementer : 0x41 CPU architecture: 7 CPU variant : 0x0 CPU part : 0xb76 CPU revision : 6 Hardware : SPICA Revision : 0020 Serial : 33323613546d00ec )"); const auto info = GetArmInfo(); EXPECT_EQ(info.architecture, 6); } // https://crbug.com/341598. TEST(CpuinfoArmTest, InvalidNeon) { auto& fs = GetEmptyFilesystem(); fs.CreateFile("/proc/cpuinfo", R"(Processor: ARMv7 Processory rev 0 (v71) processor: 0 BogoMIPS: 13.50 Processor: 1 BogoMIPS: 13.50 Features: swp half thumb fastmult vfp edsp neon vfpv3 tls vfpv4 idiva idivt CPU implementer : 0x51 CPU architecture: 7 CPU variant: 0x1 CPU part: 0x04d CPU revision: 0 Hardware: SAMSUNG M2 Revision: 0010 Serial: 00001e030000354e)"); const auto info = GetArmInfo(); EXPECT_FALSE(info.features.neon); } // The Nexus 4 (Qualcomm Krait) kernel configuration forgets to report IDIV // support. TEST(CpuinfoArmTest, Nexus4_0x510006f2) { DisableHardwareCapabilities(); auto& fs = GetEmptyFilesystem(); fs.CreateFile("/proc/cpuinfo", R"(CPU implementer : 0x51 CPU architecture: 7 CPU variant : 0x0 CPU part : 0x6f CPU revision : 2)"); const auto info = GetArmInfo(); EXPECT_TRUE(info.features.idiva); EXPECT_TRUE(info.features.idivt); } // The Nexus 4 (Qualcomm Krait) kernel configuration forgets to report IDIV // support. TEST(CpuinfoArmTest, Nexus4_0x510006f3) { DisableHardwareCapabilities(); auto& fs = GetEmptyFilesystem(); fs.CreateFile("/proc/cpuinfo", R"(CPU implementer : 0x51 CPU architecture: 7 CPU variant : 0x0 CPU part : 0x6f CPU revision : 3)"); const auto info = GetArmInfo(); EXPECT_TRUE(info.features.idiva); EXPECT_TRUE(info.features.idivt); } // The emulator-specific Android 4.2 kernel fails to report support for the // 32-bit ARM IDIV instruction. Technically, this is a feature of the virtual // CPU implemented by the emulator. TEST(CpuinfoArmTest, EmulatorSpecificIdiv) { DisableHardwareCapabilities(); auto& fs = GetEmptyFilesystem(); fs.CreateFile("/proc/cpuinfo", R"(Processor : ARMv7 Processor rev 0 (v7l) BogoMIPS : 629.14 Features : swp half thumb fastmult vfp edsp neon vfpv3 CPU implementer : 0x41 CPU architecture: 7 CPU variant : 0x0 CPU part : 0xc08 CPU revision : 0 Hardware : Goldfish Revision : 0000 Serial : 0000000000000000)"); const auto info = GetArmInfo(); EXPECT_TRUE(info.features.idiva); } } // namespace } // namespace cpu_features anbox-0.0~git20191115/external/cpu_features/test/cpuinfo_mips_test.cc000066400000000000000000000073411356361734700255610ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "cpuinfo_mips.h" #include "filesystem_for_testing.h" #include "hwcaps_for_testing.h" #include "internal/stack_line_reader.h" #include "internal/string_view.h" #include "gtest/gtest.h" namespace cpu_features { namespace { void DisableHardwareCapabilities() { SetHardwareCapabilities(0, 0); } TEST(CpuinfoMipsTest, FromHardwareCapBoth) { SetHardwareCapabilities(MIPS_HWCAP_EVA | MIPS_HWCAP_MSA, 0); GetEmptyFilesystem(); // disabling /proc/cpuinfo const auto info = GetMipsInfo(); EXPECT_TRUE(info.features.msa); EXPECT_TRUE(info.features.eva); } TEST(CpuinfoMipsTest, FromHardwareCapOnlyOne) { SetHardwareCapabilities(MIPS_HWCAP_MSA, 0); GetEmptyFilesystem(); // disabling /proc/cpuinfo const auto info = GetMipsInfo(); EXPECT_TRUE(info.features.msa); EXPECT_FALSE(info.features.eva); } TEST(CpuinfoMipsTest, Ci40) { DisableHardwareCapabilities(); auto& fs = GetEmptyFilesystem(); fs.CreateFile("/proc/cpuinfo", R"(system type : IMG Pistachio SoC (B0) machine : IMG Marduk – Ci40 with cc2520 processor : 0 cpu model : MIPS interAptiv (multi) V2.0 FPU V0.0 BogoMIPS : 363.72 wait instruction : yes microsecond timers : yes tlb_entries : 64 extra interrupt vector : yes hardware watchpoint : yes, count: 4, address/irw mask: [0x0ffc, 0x0ffc, 0x0ffb, 0x0ffb] isa : mips1 mips2 mips32r1 mips32r2 ASEs implemented : mips16 dsp mt eva shadow register sets : 1 kscratch registers : 0 package : 0 core : 0 VCED exceptions : not available VCEI exceptions : not available VPE : 0 )"); const auto info = GetMipsInfo(); EXPECT_FALSE(info.features.msa); EXPECT_TRUE(info.features.eva); } TEST(CpuinfoMipsTest, AR7161) { DisableHardwareCapabilities(); auto& fs = GetEmptyFilesystem(); fs.CreateFile("/proc/cpuinfo", R"(system type : Atheros AR7161 rev 2 machine : NETGEAR WNDR3700/WNDR3800/WNDRMAC processor : 0 cpu model : MIPS 24Kc V7.4 BogoMIPS : 452.19 wait instruction : yes microsecond timers : yes tlb_entries : 16 extra interrupt vector : yes hardware watchpoint : yes, count: 4, address/irw mask: [0x0000, 0x0f98, 0x0f78, 0x0df8] ASEs implemented : mips16 shadow register sets : 1 kscratch registers : 0 core : 0 VCED exceptions : not available VCEI exceptions : not available )"); const auto info = GetMipsInfo(); EXPECT_FALSE(info.features.msa); EXPECT_FALSE(info.features.eva); } TEST(CpuinfoMipsTest, Goldfish) { DisableHardwareCapabilities(); auto& fs = GetEmptyFilesystem(); fs.CreateFile("/proc/cpuinfo", R"(system type : MIPS-Goldfish Hardware : goldfish Revison : 1 processor : 0 cpu model : MIPS 24Kc V0.0 FPU V0.0 BogoMIPS : 1042.02 wait instruction : yes microsecond timers : yes tlb_entries : 16 extra interrupt vector : yes hardware watchpoint : yes, count: 1, address/irw mask: [0x0ff8] ASEs implemented : shadow register sets : 1 core : 0 VCED exceptions : not available VCEI exceptions : not available )"); const auto info = GetMipsInfo(); EXPECT_FALSE(info.features.msa); EXPECT_FALSE(info.features.eva); } } // namespace } // namespace cpu_features anbox-0.0~git20191115/external/cpu_features/test/cpuinfo_ppc_test.cc000066400000000000000000000076511356361734700253770ustar00rootroot00000000000000// Copyright 2018 IBM. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "cpuinfo_ppc.h" #include "filesystem_for_testing.h" #include "hwcaps_for_testing.h" #include "internal/string_view.h" #include "gtest/gtest.h" namespace cpu_features { namespace { void DisableHardwareCapabilities() { SetHardwareCapabilities(0, 0); } TEST(CpustringsPPCTest, FromHardwareCap) { SetHardwareCapabilities(PPC_FEATURE_HAS_FPU | PPC_FEATURE_HAS_VSX, PPC_FEATURE2_ARCH_3_00); GetEmptyFilesystem(); // disabling /proc/cpuinfo const auto info = GetPPCInfo(); EXPECT_TRUE(info.features.fpu); EXPECT_FALSE(info.features.mmu); EXPECT_TRUE(info.features.vsx); EXPECT_TRUE(info.features.arch300); EXPECT_FALSE(info.features.power4); EXPECT_FALSE(info.features.altivec); EXPECT_FALSE(info.features.vcrypto); EXPECT_FALSE(info.features.htm); } TEST(CpustringsPPCTest, Blade) { DisableHardwareCapabilities(); auto& fs = GetEmptyFilesystem(); fs.CreateFile("/proc/cpuinfo", R"(processor : 14 cpu : POWER7 (architected), altivec supported clock : 3000.000000MHz revision : 2.1 (pvr 003f 0201) processor : 15 cpu : POWER7 (architected), altivec supported clock : 3000.000000MHz revision : 2.1 (pvr 003f 0201) timebase : 512000000 platform : pSeries model : IBM,8406-70Y machine : CHRP IBM,8406-70Y)"); SetPlatformTypes("power7", "power8"); const auto strings = GetPPCPlatformStrings(); ASSERT_STREQ(strings.platform, "pSeries"); ASSERT_STREQ(strings.model, "IBM,8406-70Y"); ASSERT_STREQ(strings.machine, "CHRP IBM,8406-70Y"); ASSERT_STREQ(strings.cpu, "POWER7 (architected), altivec supported"); ASSERT_STREQ(strings.type.platform, "power7"); ASSERT_STREQ(strings.type.base_platform, "power8"); } TEST(CpustringsPPCTest, Firestone) { DisableHardwareCapabilities(); auto& fs = GetEmptyFilesystem(); fs.CreateFile("/proc/cpuinfo", R"(processor : 126 cpu : POWER8 (raw), altivec supported clock : 2061.000000MHz revision : 2.0 (pvr 004d 0200) processor : 127 cpu : POWER8 (raw), altivec supported clock : 2061.000000MHz revision : 2.0 (pvr 004d 0200) timebase : 512000000 platform : PowerNV model : 8335-GTA machine : PowerNV 8335-GTA firmware : OPAL v3)"); const auto strings = GetPPCPlatformStrings(); ASSERT_STREQ(strings.platform, "PowerNV"); ASSERT_STREQ(strings.model, "8335-GTA"); ASSERT_STREQ(strings.machine, "PowerNV 8335-GTA"); ASSERT_STREQ(strings.cpu, "POWER8 (raw), altivec supported"); } TEST(CpustringsPPCTest, w8) { DisableHardwareCapabilities(); auto& fs = GetEmptyFilesystem(); fs.CreateFile("/proc/cpuinfo", R"(processor : 143 cpu : POWER9, altivec supported clock : 2300.000000MHz revision : 2.2 (pvr 004e 1202) timebase : 512000000 platform : PowerNV model : 0000000000000000 machine : PowerNV 0000000000000000 firmware : OPAL MMU : Radix)"); const auto strings = GetPPCPlatformStrings(); ASSERT_STREQ(strings.platform, "PowerNV"); ASSERT_STREQ(strings.model, "0000000000000000"); ASSERT_STREQ(strings.machine, "PowerNV 0000000000000000"); ASSERT_STREQ(strings.cpu, "POWER9, altivec supported"); } } // namespace } // namespace cpu_features anbox-0.0~git20191115/external/cpu_features/test/cpuinfo_x86_test.cc000066400000000000000000000144171356361734700252400ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "gtest/gtest.h" #include "cpuinfo_x86.h" #include "internal/cpuid_x86.h" namespace cpu_features { class FakeCpu { public: Leaf CpuId(uint32_t leaf_id) const { const auto itr = cpuid_leaves_.find(leaf_id); EXPECT_TRUE(itr != cpuid_leaves_.end()) << "Missing leaf " << leaf_id; return itr->second; } uint32_t GetXCR0Eax() const { return xcr0_eax_; } void SetLeaves(std::map configuration) { cpuid_leaves_ = std::move(configuration); } void SetOsBackupsExtendedRegisters(bool os_backups_extended_registers) { xcr0_eax_ = os_backups_extended_registers ? -1 : 0; } private: std::map cpuid_leaves_; uint32_t xcr0_eax_; }; auto* g_fake_cpu = new FakeCpu(); extern "C" Leaf CpuId(uint32_t leaf_id) { return g_fake_cpu->CpuId(leaf_id); } extern "C" uint32_t GetXCR0Eax(void) { return g_fake_cpu->GetXCR0Eax(); } namespace { TEST(CpuidX86Test, SandyBridge) { g_fake_cpu->SetOsBackupsExtendedRegisters(true); g_fake_cpu->SetLeaves({ {0x00000000, Leaf{0x0000000D, 0x756E6547, 0x6C65746E, 0x49656E69}}, {0x00000001, Leaf{0x000206A6, 0x00100800, 0x1F9AE3BF, 0xBFEBFBFF}}, {0x00000007, Leaf{0x00000000, 0x00000000, 0x00000000, 0x00000000}}, }); const auto info = GetX86Info(); EXPECT_STREQ(info.vendor, "GenuineIntel"); EXPECT_EQ(info.family, 0x06); EXPECT_EQ(info.model, 0x02A); EXPECT_EQ(info.stepping, 0x06); // Leaf 7 is zeroed out so none of the Leaf 7 flags are set. const auto features = info.features; EXPECT_FALSE(features.erms); EXPECT_FALSE(features.avx2); EXPECT_FALSE(features.avx512f); EXPECT_FALSE(features.avx512cd); EXPECT_FALSE(features.avx512er); EXPECT_FALSE(features.avx512pf); EXPECT_FALSE(features.avx512bw); EXPECT_FALSE(features.avx512dq); EXPECT_FALSE(features.avx512vl); EXPECT_FALSE(features.avx512ifma); EXPECT_FALSE(features.avx512vbmi); EXPECT_FALSE(features.avx512vbmi2); EXPECT_FALSE(features.avx512vnni); EXPECT_FALSE(features.avx512bitalg); EXPECT_FALSE(features.avx512vpopcntdq); EXPECT_FALSE(features.avx512_4vnniw); EXPECT_FALSE(features.avx512_4vbmi2); // All old cpu features should be set. EXPECT_TRUE(features.aes); EXPECT_TRUE(features.ssse3); EXPECT_TRUE(features.sse4_1); EXPECT_TRUE(features.sse4_2); EXPECT_TRUE(features.avx); } TEST(CpuidX86Test, SandyBridgeTestOsSupport) { g_fake_cpu->SetLeaves({ {0x00000000, Leaf{0x0000000D, 0x756E6547, 0x6C65746E, 0x49656E69}}, {0x00000001, Leaf{0x000206A6, 0x00100800, 0x1F9AE3BF, 0xBFEBFBFF}}, {0x00000007, Leaf{0x00000000, 0x00000000, 0x00000000, 0x00000000}}, }); // avx is disabled if os does not support backing up ymm registers. g_fake_cpu->SetOsBackupsExtendedRegisters(false); EXPECT_FALSE(GetX86Info().features.avx); // avx is disabled if os does not support backing up ymm registers. g_fake_cpu->SetOsBackupsExtendedRegisters(true); EXPECT_TRUE(GetX86Info().features.avx); } TEST(CpuidX86Test, SkyLake) { g_fake_cpu->SetOsBackupsExtendedRegisters(true); g_fake_cpu->SetLeaves({ {0x00000000, Leaf{0x00000016, 0x756E6547, 0x6C65746E, 0x49656E69}}, {0x00000001, Leaf{0x000406E3, 0x00100800, 0x7FFAFBBF, 0xBFEBFBFF}}, {0x00000007, Leaf{0x00000000, 0x029C67AF, 0x00000000, 0x00000000}}, }); const auto info = GetX86Info(); EXPECT_STREQ(info.vendor, "GenuineIntel"); EXPECT_EQ(info.family, 0x06); EXPECT_EQ(info.model, 0x04E); EXPECT_EQ(info.stepping, 0x03); EXPECT_EQ(GetX86Microarchitecture(&info), X86Microarchitecture::INTEL_SKL); } TEST(CpuidX86Test, Branding) { g_fake_cpu->SetLeaves({ {0x00000000, Leaf{0x00000016, 0x756E6547, 0x6C65746E, 0x49656E69}}, {0x00000001, Leaf{0x000406E3, 0x00100800, 0x7FFAFBBF, 0xBFEBFBFF}}, {0x00000007, Leaf{0x00000000, 0x029C67AF, 0x00000000, 0x00000000}}, {0x80000000, Leaf{0x80000008, 0x00000000, 0x00000000, 0x00000000}}, {0x80000001, Leaf{0x00000000, 0x00000000, 0x00000121, 0x2C100000}}, {0x80000002, Leaf{0x65746E49, 0x2952286C, 0x726F4320, 0x4D542865}}, {0x80000003, Leaf{0x37692029, 0x3035362D, 0x43205530, 0x40205550}}, {0x80000004, Leaf{0x352E3220, 0x7A484730, 0x00000000, 0x00000000}}, }); char brand_string[49]; FillX86BrandString(brand_string); EXPECT_STREQ(brand_string, "Intel(R) Core(TM) i7-6500U CPU @ 2.50GHz"); } // http://users.atw.hu/instlatx64/AuthenticAMD0630F81_K15_Godavari_CPUID.txt TEST(CpuidX86Test, AMD_K15) { g_fake_cpu->SetLeaves({ {0x00000000, Leaf{0x0000000D, 0x68747541, 0x444D4163, 0x69746E65}}, {0x00000001, Leaf{0x00630F81, 0x00040800, 0x3E98320B, 0x178BFBFF}}, {0x00000007, Leaf{0x00000000, 0x00000000, 0x00000000, 0x00000000}}, {0x80000000, Leaf{0x8000001E, 0x68747541, 0x444D4163, 0x69746E65}}, {0x80000001, Leaf{0x00630F81, 0x10000000, 0x0FEBBFFF, 0x2FD3FBFF}}, {0x80000002, Leaf{0x20444D41, 0x372D3841, 0x4B303736, 0x64615220}}, {0x80000003, Leaf{0x206E6F65, 0x202C3752, 0x43203031, 0x75706D6F}}, {0x80000004, Leaf{0x43206574, 0x7365726F, 0x2B433420, 0x00204736}}, {0x80000005, Leaf{0xFF40FF18, 0xFF40FF30, 0x10040140, 0x60030140}}, }); const auto info = GetX86Info(); EXPECT_STREQ(info.vendor, "AuthenticAMD"); EXPECT_EQ(info.family, 0x15); EXPECT_EQ(info.model, 0x38); EXPECT_EQ(info.stepping, 0x01); EXPECT_EQ(GetX86Microarchitecture(&info), X86Microarchitecture::AMD_BULLDOZER); char brand_string[49]; FillX86BrandString(brand_string); EXPECT_STREQ(brand_string, "AMD A8-7670K Radeon R7, 10 Compute Cores 4C+6G "); } // TODO(user): test what happens when xsave/osxsave are not present. // TODO(user): test what happens when xmm/ymm/zmm os support are not // present. } // namespace } // namespace cpu_features anbox-0.0~git20191115/external/cpu_features/test/filesystem_for_testing.cc000066400000000000000000000056321356361734700266170ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "filesystem_for_testing.h" #include #include #include #include #include namespace cpu_features { FakeFile::FakeFile(int file_descriptor, const char* content) : file_descriptor_(file_descriptor), content_(content) {} FakeFile::~FakeFile() { assert(!opened_); } void FakeFile::Open() { assert(!opened_); opened_ = true; } void FakeFile::Close() { assert(opened_); opened_ = false; } int FakeFile::Read(int fd, void* buf, size_t count) { assert(count < INT_MAX); assert(fd == file_descriptor_); const size_t remainder = content_.size() - head_index_; const size_t read = count > remainder ? remainder : count; memcpy(buf, content_.data() + head_index_, read); head_index_ += read; assert(read < INT_MAX); return read; } void FakeFilesystem::Reset() { files_.clear(); } FakeFile* FakeFilesystem::CreateFile(const std::string& filename, const char* content) { auto& file = files_[filename]; file = std::unique_ptr(new FakeFile(next_file_descriptor_++, content)); return file.get(); } FakeFile* FakeFilesystem::FindFileOrNull(const std::string& filename) const { const auto itr = files_.find(filename); return itr == files_.end() ? nullptr : itr->second.get(); } FakeFile* FakeFilesystem::FindFileOrDie(const int file_descriptor) const { for (const auto& filename_file_pair : files_) { FakeFile* const file_ptr = filename_file_pair.second.get(); if (file_ptr->GetFileDescriptor() == file_descriptor) { return file_ptr; } } assert(false); return nullptr; } static FakeFilesystem* kFilesystem = new FakeFilesystem(); FakeFilesystem& GetEmptyFilesystem() { kFilesystem->Reset(); return *kFilesystem; } extern "C" int CpuFeatures_OpenFile(const char* filename) { auto* const file = kFilesystem->FindFileOrNull(filename); if (file) { file->Open(); return file->GetFileDescriptor(); } return -1; } extern "C" void CpuFeatures_CloseFile(int file_descriptor) { kFilesystem->FindFileOrDie(file_descriptor)->Close(); } extern "C" int CpuFeatures_ReadFile(int file_descriptor, void* buffer, size_t buffer_size) { return kFilesystem->FindFileOrDie(file_descriptor) ->Read(file_descriptor, buffer, buffer_size); } } // namespace cpu_features anbox-0.0~git20191115/external/cpu_features/test/filesystem_for_testing.h000066400000000000000000000032731356361734700264600ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Implements a fake filesystem, useful for tests. #ifndef CPU_FEATURES_TEST_FILESYSTEM_FOR_TESTING_H_ #define CPU_FEATURES_TEST_FILESYSTEM_FOR_TESTING_H_ #include #include #include #include "internal/filesystem.h" namespace cpu_features { class FakeFile { public: explicit FakeFile(int file_descriptor, const char* content); ~FakeFile(); void Open(); void Close(); int Read(int fd, void* buf, size_t count); int GetFileDescriptor() const { return file_descriptor_; } private: const int file_descriptor_; const std::string content_; bool opened_ = false; size_t head_index_ = 0; }; class FakeFilesystem { public: void Reset(); FakeFile* CreateFile(const std::string& filename, const char* content); FakeFile* FindFileOrDie(const int file_descriptor) const; FakeFile* FindFileOrNull(const std::string& filename) const; private: size_t next_file_descriptor_ = 0; std::unordered_map> files_; }; FakeFilesystem& GetEmptyFilesystem(); } // namespace cpu_features #endif // CPU_FEATURES_TEST_FILESYSTEM_FOR_TESTING_H_ anbox-0.0~git20191115/external/cpu_features/test/hwcaps_for_testing.cc000066400000000000000000000031751356361734700257200ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "hwcaps_for_testing.h" #include "internal/string_view.h" namespace cpu_features { namespace { static auto* const g_hardware_capabilities = new HardwareCapabilities(); static auto* const g_platform_types = new PlatformType(); } // namespace void SetHardwareCapabilities(uint32_t hwcaps, uint32_t hwcaps2) { g_hardware_capabilities->hwcaps = hwcaps; g_hardware_capabilities->hwcaps2 = hwcaps2; } HardwareCapabilities CpuFeatures_GetHardwareCapabilities(void) { return *g_hardware_capabilities; } void SetPlatformTypes(const char* platform, const char* base_platform) { CpuFeatures_StringView_CopyString(str(platform), g_platform_types->platform, sizeof(g_platform_types->platform)); CpuFeatures_StringView_CopyString(str(base_platform), g_platform_types->base_platform, sizeof(g_platform_types->base_platform)); } PlatformType CpuFeatures_GetPlatformType(void) { return *g_platform_types; } } // namespace cpu_features anbox-0.0~git20191115/external/cpu_features/test/hwcaps_for_testing.h000066400000000000000000000017001356361734700255520ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef CPU_FEATURES_TEST_HWCAPS_FOR_TESTING_H_ #define CPU_FEATURES_TEST_HWCAPS_FOR_TESTING_H_ #include "internal/hwcaps.h" namespace cpu_features { void SetHardwareCapabilities(uint32_t hwcaps, uint32_t hwcaps2); void SetPlatformTypes(const char *platform, const char *base_platform); } // namespace cpu_features #endif // CPU_FEATURES_TEST_HWCAPS_FOR_TESTING_H_ anbox-0.0~git20191115/external/cpu_features/test/linux_features_aggregator_test.cc000066400000000000000000000053701356361734700303250ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include "internal/linux_features_aggregator.h" #include "gtest/gtest.h" namespace cpu_features { namespace { struct Features { bool a = false; bool b = false; bool c = false; }; DECLARE_SETTER(Features, a) DECLARE_SETTER(Features, b) DECLARE_SETTER(Features, c) class LinuxFeatureAggregatorTest : public testing::Test { public: const std::array kConfigs = { {{{0b0001, 0b0000}, "a", &set_a}, {{0b0010, 0b0000}, "b", &set_b}, {{0b0000, 0b1100}, "c", &set_c}}}; }; TEST_F(LinuxFeatureAggregatorTest, FromFlagsEmpty) { Features features; CpuFeatures_SetFromFlags(kConfigs.size(), kConfigs.data(), str(""), &features); EXPECT_FALSE(features.a); EXPECT_FALSE(features.b); EXPECT_FALSE(features.c); } TEST_F(LinuxFeatureAggregatorTest, FromFlagsAllSet) { Features features; CpuFeatures_SetFromFlags(kConfigs.size(), kConfigs.data(), str("a c b"), &features); EXPECT_TRUE(features.a); EXPECT_TRUE(features.b); EXPECT_TRUE(features.c); } TEST_F(LinuxFeatureAggregatorTest, FromFlagsOnlyA) { Features features; CpuFeatures_SetFromFlags(kConfigs.size(), kConfigs.data(), str("a"), &features); EXPECT_TRUE(features.a); EXPECT_FALSE(features.b); EXPECT_FALSE(features.c); } TEST_F(LinuxFeatureAggregatorTest, FromHwcapsNone) { HardwareCapabilities capability; capability.hwcaps = 0; // matches none capability.hwcaps2 = 0; // matches none Features features; CpuFeatures_OverrideFromHwCaps(kConfigs.size(), kConfigs.data(), capability, &features); EXPECT_FALSE(features.a); EXPECT_FALSE(features.b); EXPECT_FALSE(features.c); } TEST_F(LinuxFeatureAggregatorTest, FromHwcapsSet) { HardwareCapabilities capability; capability.hwcaps = 0b0010; // matches b but not a capability.hwcaps2 = 0b1111; // matches c Features features; CpuFeatures_OverrideFromHwCaps(kConfigs.size(), kConfigs.data(), capability, &features); EXPECT_FALSE(features.a); EXPECT_TRUE(features.b); EXPECT_TRUE(features.c); } } // namespace } // namespace cpu_features anbox-0.0~git20191115/external/cpu_features/test/stack_line_reader_test.cc000066400000000000000000000075041356361734700265250ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "internal/stack_line_reader.h" #include "filesystem_for_testing.h" #include "gtest/gtest.h" namespace cpu_features { bool operator==(const StringView& a, const StringView& b) { return CpuFeatures_StringView_IsEquals(a, b); } namespace { std::string ToString(StringView view) { return {view.ptr, view.size}; } TEST(StackLineReaderTest, Empty) { auto& fs = GetEmptyFilesystem(); auto* file = fs.CreateFile("/proc/cpuinfo", ""); StackLineReader reader; StackLineReader_Initialize(&reader, file->GetFileDescriptor()); { const auto result = StackLineReader_NextLine(&reader); EXPECT_TRUE(result.eof); EXPECT_TRUE(result.full_line); EXPECT_EQ(result.line, str("")); } } TEST(StackLineReaderTest, ManySmallLines) { auto& fs = GetEmptyFilesystem(); auto* file = fs.CreateFile("/proc/cpuinfo", "a\nb\nc"); StackLineReader reader; StackLineReader_Initialize(&reader, file->GetFileDescriptor()); { const auto result = StackLineReader_NextLine(&reader); EXPECT_FALSE(result.eof); EXPECT_TRUE(result.full_line); EXPECT_EQ(result.line, str("a")); } { const auto result = StackLineReader_NextLine(&reader); EXPECT_FALSE(result.eof); EXPECT_TRUE(result.full_line); EXPECT_EQ(result.line, str("b")); } { const auto result = StackLineReader_NextLine(&reader); EXPECT_TRUE(result.eof); EXPECT_TRUE(result.full_line); EXPECT_EQ(result.line, str("c")); } } TEST(StackLineReaderTest, TruncatedLine) { auto& fs = GetEmptyFilesystem(); auto* file = fs.CreateFile("/proc/cpuinfo", R"(First Second More than 16 characters, this will be truncated. last)"); StackLineReader reader; StackLineReader_Initialize(&reader, file->GetFileDescriptor()); { const auto result = StackLineReader_NextLine(&reader); EXPECT_FALSE(result.eof); EXPECT_TRUE(result.full_line); EXPECT_EQ(result.line, str("First")); } { const auto result = StackLineReader_NextLine(&reader); EXPECT_FALSE(result.eof); EXPECT_TRUE(result.full_line); EXPECT_EQ(result.line, str("Second")); } { const auto result = StackLineReader_NextLine(&reader); EXPECT_FALSE(result.eof); EXPECT_FALSE(result.full_line); EXPECT_EQ(result.line, str("More than 16 cha")); } { const auto result = StackLineReader_NextLine(&reader); EXPECT_TRUE(result.eof); EXPECT_TRUE(result.full_line); EXPECT_EQ(result.line, str("last")); } } TEST(StackLineReaderTest, TruncatedLines) { auto& fs = GetEmptyFilesystem(); auto* file = fs.CreateFile("/proc/cpuinfo", R"(More than 16 characters Another line that is too long)"); StackLineReader reader; StackLineReader_Initialize(&reader, file->GetFileDescriptor()); { const auto result = StackLineReader_NextLine(&reader); EXPECT_FALSE(result.eof); EXPECT_FALSE(result.full_line); EXPECT_EQ(result.line, str("More than 16 cha")); } { const auto result = StackLineReader_NextLine(&reader); EXPECT_FALSE(result.eof); EXPECT_FALSE(result.full_line); EXPECT_EQ(result.line, str("Another line tha")); } { const auto result = StackLineReader_NextLine(&reader); EXPECT_TRUE(result.eof); EXPECT_TRUE(result.full_line); EXPECT_EQ(result.line, str("")); } } } // namespace } // namespace cpu_features anbox-0.0~git20191115/external/cpu_features/test/string_view_test.cc000066400000000000000000000123211356361734700254200ustar00rootroot00000000000000// Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "internal/string_view.h" #include "gtest/gtest.h" namespace cpu_features { bool operator==(const StringView& a, const StringView& b) { return CpuFeatures_StringView_IsEquals(a, b); } namespace { TEST(StringViewTest, Empty) { EXPECT_EQ(kEmptyStringView.ptr, nullptr); EXPECT_EQ(kEmptyStringView.size, 0); } TEST(StringViewTest, Build) { const auto view = str("test"); EXPECT_EQ(view.ptr[0], 't'); EXPECT_EQ(view.size, 4); } TEST(StringViewTest, CpuFeatures_StringView_IndexOfChar) { // Found. EXPECT_EQ(CpuFeatures_StringView_IndexOfChar(str("test"), 'e'), 1); // Not found. EXPECT_EQ(CpuFeatures_StringView_IndexOfChar(str("test"), 'z'), -1); // Empty. EXPECT_EQ(CpuFeatures_StringView_IndexOfChar(kEmptyStringView, 'z'), -1); } TEST(StringViewTest, CpuFeatures_StringView_IndexOf) { // Found. EXPECT_EQ(CpuFeatures_StringView_IndexOf(str("test"), str("es")), 1); // Not found. EXPECT_EQ(CpuFeatures_StringView_IndexOf(str("test"), str("aa")), -1); // Empty. EXPECT_EQ(CpuFeatures_StringView_IndexOf(kEmptyStringView, str("aa")), -1); EXPECT_EQ(CpuFeatures_StringView_IndexOf(str("aa"), kEmptyStringView), -1); } TEST(StringViewTest, CpuFeatures_StringView_StartsWith) { EXPECT_TRUE(CpuFeatures_StringView_StartsWith(str("test"), str("te"))); EXPECT_FALSE(CpuFeatures_StringView_StartsWith(str("test"), str(""))); EXPECT_FALSE( CpuFeatures_StringView_StartsWith(str("test"), kEmptyStringView)); EXPECT_FALSE( CpuFeatures_StringView_StartsWith(kEmptyStringView, str("test"))); } TEST(StringViewTest, CpuFeatures_StringView_IsEquals) { EXPECT_TRUE( CpuFeatures_StringView_IsEquals(kEmptyStringView, kEmptyStringView)); EXPECT_TRUE(CpuFeatures_StringView_IsEquals(kEmptyStringView, str(""))); EXPECT_TRUE(CpuFeatures_StringView_IsEquals(str(""), kEmptyStringView)); EXPECT_TRUE(CpuFeatures_StringView_IsEquals(str("a"), str("a"))); EXPECT_FALSE(CpuFeatures_StringView_IsEquals(str("a"), str("b"))); EXPECT_FALSE(CpuFeatures_StringView_IsEquals(str("a"), kEmptyStringView)); EXPECT_FALSE(CpuFeatures_StringView_IsEquals(kEmptyStringView, str("a"))); } TEST(StringViewTest, CpuFeatures_StringView_PopFront) { EXPECT_EQ(CpuFeatures_StringView_PopFront(str("test"), 2), str("st")); EXPECT_EQ(CpuFeatures_StringView_PopFront(str("test"), 0), str("test")); EXPECT_EQ(CpuFeatures_StringView_PopFront(str("test"), 4), str("")); EXPECT_EQ(CpuFeatures_StringView_PopFront(str("test"), 100), str("")); } TEST(StringViewTest, CpuFeatures_StringView_ParsePositiveNumber) { EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("42")), 42); EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("0x2a")), 42); EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("0x2A")), 42); EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("-0x2A")), -1); EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("abc")), -1); EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("")), -1); } TEST(StringViewTest, CpuFeatures_StringView_CopyString) { char buf[4]; buf[0] = 'X'; // Empty CpuFeatures_StringView_CopyString(str(""), buf, sizeof(buf)); EXPECT_STREQ(buf, ""); // Less CpuFeatures_StringView_CopyString(str("a"), buf, sizeof(buf)); EXPECT_STREQ(buf, "a"); // exact CpuFeatures_StringView_CopyString(str("abc"), buf, sizeof(buf)); EXPECT_STREQ(buf, "abc"); // More CpuFeatures_StringView_CopyString(str("abcd"), buf, sizeof(buf)); EXPECT_STREQ(buf, "abc"); } TEST(StringViewTest, CpuFeatures_StringView_HasWord) { // Find flags at beginning, middle and end. EXPECT_TRUE( CpuFeatures_StringView_HasWord(str("first middle last"), "first")); EXPECT_TRUE( CpuFeatures_StringView_HasWord(str("first middle last"), "middle")); EXPECT_TRUE(CpuFeatures_StringView_HasWord(str("first middle last"), "last")); // Do not match partial flags EXPECT_FALSE( CpuFeatures_StringView_HasWord(str("first middle last"), "irst")); EXPECT_FALSE(CpuFeatures_StringView_HasWord(str("first middle last"), "mid")); EXPECT_FALSE(CpuFeatures_StringView_HasWord(str("first middle last"), "las")); } TEST(StringViewTest, CpuFeatures_StringView_GetAttributeKeyValue) { const StringView line = str(" key : first middle last "); StringView key, value; EXPECT_TRUE(CpuFeatures_StringView_GetAttributeKeyValue(line, &key, &value)); EXPECT_EQ(key, str("key")); EXPECT_EQ(value, str("first middle last")); } TEST(StringViewTest, FailingGetAttributeKeyValue) { const StringView line = str("key first middle last"); StringView key, value; EXPECT_FALSE(CpuFeatures_StringView_GetAttributeKeyValue(line, &key, &value)); } } // namespace } // namespace cpu_features anbox-0.0~git20191115/external/glm/000077500000000000000000000000001356361734700166265ustar00rootroot00000000000000anbox-0.0~git20191115/external/glm/.gitignore000066400000000000000000000010061356361734700206130ustar00rootroot00000000000000# Compiled Object files *.slo *.lo *.o *.obj # Precompiled Headers *.gch *.pch # Compiled Dynamic libraries *.so *.dylib *.dll # Fortran module files *.mod # Compiled Static libraries *.lai *.la *.a *.lib # Executables *.exe *.out *.app # CMake CMakeCache.txt CMakeFiles Makefile cmake_install.cmake install_manifest.txt *.cmake # ^ May need to add future .cmake files as exceptions # Test logs Testing/* # Test input test/gtc/*.dds # Project Files *.cbp *.user anbox-0.0~git20191115/external/glm/CMakeLists.txt000066400000000000000000000141121356361734700213650ustar00rootroot00000000000000cmake_minimum_required(VERSION 2.6 FATAL_ERROR) project(glm) set(GLM_VERSION "0.9.7") list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake") include(GNUInstallDirs) include(CMakePackageConfigHelpers) enable_testing() add_definitions(-D_CRT_SECURE_NO_WARNINGS) option(GLM_TEST_ENABLE "GLM test" OFF) if(NOT GLM_TEST_ENABLE) message(STATUS "GLM is a header only library, no need to build it. Set the option GLM_TEST_ENABLE with ON to build and run the test bench") endif() if(("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") OR ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") OR (("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel") AND UNIX)) option(GLM_TEST_ENABLE_CXX_98 "Enable C++ 98" OFF) option(GLM_TEST_ENABLE_CXX_0X "Enable C++ 0x" OFF) option(GLM_TEST_ENABLE_CXX_11 "Enable C++ 11" OFF) option(GLM_TEST_ENABLE_CXX_1Y "Enable C++ 1y" OFF) option(GLM_TEST_ENABLE_CXX_14 "Enable C++ 14" OFF) option(GLM_TEST_ENABLE_CXX_1Z "Enable C++ 1z" OFF) if(GLM_TEST_ENABLE_CXX_1Z) set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++1z") set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++") set(CMAKE_CXX_FLAGS "-std=c++1Z") elseif(GLM_TEST_ENABLE_CXX_14) set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++14") set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++") set(CMAKE_CXX_FLAGS "-std=c++14") elseif(GLM_TEST_ENABLE_CXX_1Y) set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++1y") set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++") set(CMAKE_CXX_FLAGS "-std=c++1y") elseif(GLM_TEST_ENABLE_CXX_11) set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++11") set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++") set(CMAKE_CXX_FLAGS "-std=c++11") elseif(GLM_TEST_ENABLE_CXX_0X) set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++0x") set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++") set(CMAKE_CXX_FLAGS "-std=c++0x") elseif(GLM_TEST_ENABLE_CXX_98) set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++98") set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++") set(CMAKE_CXX_FLAGS "-std=c++98") endif() endif() option(GLM_TEST_ENABLE_MS_EXTENSIONS "Enable MS extensions" OFF) if(GLM_TEST_ENABLE_MS_EXTENSIONS) if(("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") OR ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")) add_definitions(-Wgnu-anonymous-struct) add_definitions(-Wnested-anon-types) endif() else() if(("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") OR (("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel") AND WIN32)) add_definitions(/Za) elseif(("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") OR ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")) add_definitions(-pedantic) endif() endif() option(GLM_TEST_ENABLE_SIMD_SSE2 "Enable SSE2 optimizations" OFF) option(GLM_TEST_ENABLE_SIMD_SSE3 "Enable SSE3 optimizations" OFF) option(GLM_TEST_ENABLE_SIMD_AVX "Enable AVX optimizations" OFF) option(GLM_TEST_ENABLE_SIMD_AVX2 "Enable AVX2 optimizations" OFF) option(GLM_TEST_FORCE_PURE "Force 'pure' instructions" OFF) if(GLM_TEST_FORCE_PURE) add_definitions(-DGLM_FORCE_PURE) if(CMAKE_COMPILER_IS_GNUCXX) add_definitions(-mfpmath=387) endif() elseif(GLM_TEST_ENABLE_SIMD_AVX2) if(CMAKE_COMPILER_IS_GNUCXX) add_definitions(-mavx2) elseif(GLM_USE_INTEL) add_definitions(/QxAVX2) elseif(MSVC) add_definitions(/arch:AVX2) endif() elseif(GLM_TEST_ENABLE_SIMD_AVX) if(CMAKE_COMPILER_IS_GNUCXX) add_definitions(-mavx) elseif(GLM_USE_INTEL) add_definitions(/QxAVX) elseif(MSVC) add_definitions(/arch:AVX) endif() elseif(GLM_TEST_ENABLE_SIMD_SSE3) if(CMAKE_COMPILER_IS_GNUCXX) add_definitions(-msse3) elseif(GLM_USE_INTEL) add_definitions(/QxSSE3) elseif(MSVC) add_definitions(/arch:SSE2) # VC doesn't support /arch:SSE3 endif() elseif(GLM_TEST_ENABLE_SIMD_SSE2) if(CMAKE_COMPILER_IS_GNUCXX) add_definitions(-msse2) elseif(GLM_USE_INTEL) add_definitions(/QxSSE2) elseif(MSVC) if(NOT CMAKE_CL_64) add_definitions(/arch:SSE2) endif() endif() endif() option(GLM_TEST_ENABLE_FAST_MATH "Enable fast math optimizations" OFF) if(GLM_TEST_ENABLE_FAST_MATH) if(CMAKE_COMPILER_IS_GNUCXX) add_definitions(-ffast-math) endif() if(MSVC) add_definitions(/fp:fast) endif() elseif(NOT GLM_TEST_ENABLE_FAST_MATH) if(MSVC) add_definitions(/fp:precise) endif() endif() if(CMAKE_COMPILER_IS_GNUCXX) #add_definitions(-S) #add_definitions(-s) add_definitions(-O2) #add_definitions(-fprofile-arcs -ftest-coverage) gcov #ctest_enable_coverage() endif() include_directories("${PROJECT_SOURCE_DIR}") include_directories("${PROJECT_SOURCE_DIR}/test/external") add_subdirectory(glm) add_subdirectory(test) set(GLM_INSTALL_CONFIGDIR "${CMAKE_INSTALL_LIBDIR}/cmake/glm") install(DIRECTORY glm DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) write_basic_package_version_file( "${CMAKE_CURRENT_BINARY_DIR}/glmVersion.cmake" VERSION ${GLM_VERSION} COMPATIBILITY AnyNewerVersion ) # build tree package config configure_file( cmake/glmBuildConfig.cmake.in glmConfig.cmake @ONLY ) # install tree package config configure_package_config_file( cmake/glmConfig.cmake.in ${GLM_INSTALL_CONFIGDIR}/glmConfig.cmake INSTALL_DESTINATION ${GLM_INSTALL_CONFIGDIR} PATH_VARS CMAKE_INSTALL_INCLUDEDIR NO_CHECK_REQUIRED_COMPONENTS_MACRO ) install( FILES "${CMAKE_CURRENT_BINARY_DIR}/${GLM_INSTALL_CONFIGDIR}/glmConfig.cmake" "${CMAKE_CURRENT_BINARY_DIR}/glmVersion.cmake" DESTINATION ${GLM_INSTALL_CONFIGDIR} ) if (NOT CMAKE_VERSION VERSION_LESS "3.0") add_library(glm INTERFACE) target_include_directories(glm INTERFACE $ $ ) install(TARGETS glm EXPORT glmTargets) export( EXPORT glmTargets FILE "${CMAKE_CURRENT_BINARY_DIR}/glmTargets.cmake" ) install( EXPORT glmTargets FILE glmTargets.cmake DESTINATION ${GLM_INSTALL_CONFIGDIR} ) endif() export(PACKAGE glm) anbox-0.0~git20191115/external/glm/cmake/000077500000000000000000000000001356361734700177065ustar00rootroot00000000000000anbox-0.0~git20191115/external/glm/cmake/glmBuildConfig.cmake.in000066400000000000000000000003071356361734700242020ustar00rootroot00000000000000set(GLM_VERSION "@GLM_VERSION@") set(GLM_INCLUDE_DIRS "@CMAKE_CURRENT_SOURCE_DIR@") if (NOT CMAKE_VERSION VERSION_LESS "3.0") include("${CMAKE_CURRENT_LIST_DIR}/glmTargets.cmake") endif() anbox-0.0~git20191115/external/glm/cmake/glmConfig.cmake.in000066400000000000000000000003551356361734700232250ustar00rootroot00000000000000set(GLM_VERSION "@GLM_VERSION@") @PACKAGE_INIT@ set_and_check(GLM_INCLUDE_DIRS "@PACKAGE_CMAKE_INSTALL_INCLUDEDIR@") if (NOT CMAKE_VERSION VERSION_LESS "3.0") include("${CMAKE_CURRENT_LIST_DIR}/glmTargets.cmake") endif() anbox-0.0~git20191115/external/glm/copying.txt000066400000000000000000000056461356361734700210520ustar00rootroot00000000000000================================================================================ OpenGL Mathematics (GLM) -------------------------------------------------------------------------------- GLM can be distributed and/or modified under the terms of either a) The Happy Bunny License, or b) the MIT License. ================================================================================ The Happy Bunny License (Modified MIT License) -------------------------------------------------------------------------------- Copyright (c) 2005 - 2015 G-Truc Creation Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ================================================================================ The MIT License -------------------------------------------------------------------------------- Copyright (c) 2005 - 2015 G-Truc Creation Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. anbox-0.0~git20191115/external/glm/doc/000077500000000000000000000000001356361734700173735ustar00rootroot00000000000000anbox-0.0~git20191115/external/glm/doc/api/000077500000000000000000000000001356361734700201445ustar00rootroot00000000000000anbox-0.0~git20191115/external/glm/doc/api/a00001.html000066400000000000000000000103411356361734700216320ustar00rootroot00000000000000 0.9.7: _features.hpp File Reference
_features.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-02-20 / 2013-02-20
Author
Christophe Riccio

Definition in file _features.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00001_source.html000066400000000000000000001610461356361734700232230ustar00rootroot00000000000000 0.9.7: _features.hpp Source File
_features.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 // #define GLM_CXX98_EXCEPTIONS
36 // #define GLM_CXX98_RTTI
37 
38 // #define GLM_CXX11_RVALUE_REFERENCES
39 // Rvalue references - GCC 4.3
40 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2118.html
41 
42 // GLM_CXX11_TRAILING_RETURN
43 // Rvalue references for *this - GCC not supported
44 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2439.htm
45 
46 // GLM_CXX11_NONSTATIC_MEMBER_INIT
47 // Initialization of class objects by rvalues - GCC any
48 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1610.html
49 
50 // GLM_CXX11_NONSTATIC_MEMBER_INIT
51 // Non-static data member initializers - GCC 4.7
52 // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2756.htm
53 
54 // #define GLM_CXX11_VARIADIC_TEMPLATE
55 // Variadic templates - GCC 4.3
56 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2242.pdf
57 
58 //
59 // Extending variadic template template parameters - GCC 4.4
60 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2555.pdf
61 
62 // #define GLM_CXX11_GENERALIZED_INITIALIZERS
63 // Initializer lists - GCC 4.4
64 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2672.htm
65 
66 // #define GLM_CXX11_STATIC_ASSERT
67 // Static assertions - GCC 4.3
68 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1720.html
69 
70 // #define GLM_CXX11_AUTO_TYPE
71 // auto-typed variables - GCC 4.4
72 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1984.pdf
73 
74 // #define GLM_CXX11_AUTO_TYPE
75 // Multi-declarator auto - GCC 4.4
76 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1737.pdf
77 
78 // #define GLM_CXX11_AUTO_TYPE
79 // Removal of auto as a storage-class specifier - GCC 4.4
80 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2546.htm
81 
82 // #define GLM_CXX11_AUTO_TYPE
83 // New function declarator syntax - GCC 4.4
84 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2541.htm
85 
86 // #define GLM_CXX11_LAMBDAS
87 // New wording for C++0x lambdas - GCC 4.5
88 // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2927.pdf
89 
90 // #define GLM_CXX11_DECLTYPE
91 // Declared type of an expression - GCC 4.3
92 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2343.pdf
93 
94 //
95 // Right angle brackets - GCC 4.3
96 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1757.html
97 
98 //
99 // Default template arguments for function templates DR226 GCC 4.3
100 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#226
101 
102 //
103 // Solving the SFINAE problem for expressions DR339 GCC 4.4
104 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2634.html
105 
106 // #define GLM_CXX11_ALIAS_TEMPLATE
107 // Template aliases N2258 GCC 4.7
108 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf
109 
110 //
111 // Extern templates N1987 Yes
112 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1987.htm
113 
114 // #define GLM_CXX11_NULLPTR
115 // Null pointer constant N2431 GCC 4.6
116 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2431.pdf
117 
118 // #define GLM_CXX11_STRONG_ENUMS
119 // Strongly-typed enums N2347 GCC 4.4
120 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf
121 
122 //
123 // Forward declarations for enums N2764 GCC 4.6
124 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2764.pdf
125 
126 //
127 // Generalized attributes N2761 GCC 4.8
128 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf
129 
130 //
131 // Generalized constant expressions N2235 GCC 4.6
132 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf
133 
134 //
135 // Alignment support N2341 GCC 4.8
136 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf
137 
138 // #define GLM_CXX11_DELEGATING_CONSTRUCTORS
139 // Delegating constructors N1986 GCC 4.7
140 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1986.pdf
141 
142 //
143 // Inheriting constructors N2540 GCC 4.8
144 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2540.htm
145 
146 // #define GLM_CXX11_EXPLICIT_CONVERSIONS
147 // Explicit conversion operators N2437 GCC 4.5
148 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf
149 
150 //
151 // New character types N2249 GCC 4.4
152 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2249.html
153 
154 //
155 // Unicode string literals N2442 GCC 4.5
156 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm
157 
158 //
159 // Raw string literals N2442 GCC 4.5
160 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm
161 
162 //
163 // Universal character name literals N2170 GCC 4.5
164 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2170.html
165 
166 // #define GLM_CXX11_USER_LITERALS
167 // User-defined literals N2765 GCC 4.7
168 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2765.pdf
169 
170 //
171 // Standard Layout Types N2342 GCC 4.5
172 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2342.htm
173 
174 // #define GLM_CXX11_DEFAULTED_FUNCTIONS
175 // #define GLM_CXX11_DELETED_FUNCTIONS
176 // Defaulted and deleted functions N2346 GCC 4.4
177 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2346.htm
178 
179 //
180 // Extended friend declarations N1791 GCC 4.7
181 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1791.pdf
182 
183 //
184 // Extending sizeof N2253 GCC 4.4
185 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2253.html
186 
187 // #define GLM_CXX11_INLINE_NAMESPACES
188 // Inline namespaces N2535 GCC 4.4
189 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2535.htm
190 
191 // #define GLM_CXX11_UNRESTRICTED_UNIONS
192 // Unrestricted unions N2544 GCC 4.6
193 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf
194 
195 // #define GLM_CXX11_LOCAL_TYPE_TEMPLATE_ARGS
196 // Local and unnamed types as template arguments N2657 GCC 4.5
197 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm
198 
199 // #define GLM_CXX11_RANGE_FOR
200 // Range-based for N2930 GCC 4.6
201 // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2930.html
202 
203 // #define GLM_CXX11_OVERRIDE_CONTROL
204 // Explicit virtual overrides N2928 N3206 N3272 GCC 4.7
205 // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2928.htm
206 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3206.htm
207 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3272.htm
208 
209 //
210 // Minimal support for garbage collection and reachability-based leak detection N2670 No
211 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2670.htm
212 
213 // #define GLM_CXX11_NOEXCEPT
214 // Allowing move constructors to throw [noexcept] N3050 GCC 4.6 (core language only)
215 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3050.html
216 
217 //
218 // Defining move special member functions N3053 GCC 4.6
219 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3053.html
220 
221 //
222 // Sequence points N2239 Yes
223 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2239.html
224 
225 //
226 // Atomic operations N2427 GCC 4.4
227 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2239.html
228 
229 //
230 // Strong Compare and Exchange N2748 GCC 4.5
231 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html
232 
233 //
234 // Bidirectional Fences N2752 GCC 4.8
235 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2752.htm
236 
237 //
238 // Memory model N2429 GCC 4.8
239 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2429.htm
240 
241 //
242 // Data-dependency ordering: atomics and memory model N2664 GCC 4.4
243 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2664.htm
244 
245 //
246 // Propagating exceptions N2179 GCC 4.4
247 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2179.html
248 
249 //
250 // Abandoning a process and at_quick_exit N2440 GCC 4.8
251 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2440.htm
252 
253 //
254 // Allow atomics use in signal handlers N2547 Yes
255 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2547.htm
256 
257 //
258 // Thread-local storage N2659 GCC 4.8
259 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2659.htm
260 
261 //
262 // Dynamic initialization and destruction with concurrency N2660 GCC 4.3
263 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2660.htm
264 
265 //
266 // __func__ predefined identifier N2340 GCC 4.3
267 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2340.htm
268 
269 //
270 // C99 preprocessor N1653 GCC 4.3
271 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1653.htm
272 
273 //
274 // long long N1811 GCC 4.3
275 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1811.pdf
276 
277 //
278 // Extended integral types N1988 Yes
279 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1988.pdf
280 
281 #if(GLM_COMPILER & GLM_COMPILER_GCC)
282 
283 # if(GLM_COMPILER >= GLM_COMPILER_GCC43)
284 # define GLM_CXX11_STATIC_ASSERT
285 # endif
286 
287 #elif(GLM_COMPILER & (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM))
288 # if(__has_feature(cxx_exceptions))
289 # define GLM_CXX98_EXCEPTIONS
290 # endif
291 
292 # if(__has_feature(cxx_rtti))
293 # define GLM_CXX98_RTTI
294 # endif
295 
296 # if(__has_feature(cxx_access_control_sfinae))
297 # define GLM_CXX11_ACCESS_CONTROL_SFINAE
298 # endif
299 
300 # if(__has_feature(cxx_alias_templates))
301 # define GLM_CXX11_ALIAS_TEMPLATE
302 # endif
303 
304 # if(__has_feature(cxx_alignas))
305 # define GLM_CXX11_ALIGNAS
306 # endif
307 
308 # if(__has_feature(cxx_attributes))
309 # define GLM_CXX11_ATTRIBUTES
310 # endif
311 
312 # if(__has_feature(cxx_constexpr))
313 # define GLM_CXX11_CONSTEXPR
314 # endif
315 
316 # if(__has_feature(cxx_decltype))
317 # define GLM_CXX11_DECLTYPE
318 # endif
319 
320 # if(__has_feature(cxx_default_function_template_args))
321 # define GLM_CXX11_DEFAULT_FUNCTION_TEMPLATE_ARGS
322 # endif
323 
324 # if(__has_feature(cxx_defaulted_functions))
325 # define GLM_CXX11_DEFAULTED_FUNCTIONS
326 # endif
327 
328 # if(__has_feature(cxx_delegating_constructors))
329 # define GLM_CXX11_DELEGATING_CONSTRUCTORS
330 # endif
331 
332 # if(__has_feature(cxx_deleted_functions))
333 # define GLM_CXX11_DELETED_FUNCTIONS
334 # endif
335 
336 # if(__has_feature(cxx_explicit_conversions))
337 # define GLM_CXX11_EXPLICIT_CONVERSIONS
338 # endif
339 
340 # if(__has_feature(cxx_generalized_initializers))
341 # define GLM_CXX11_GENERALIZED_INITIALIZERS
342 # endif
343 
344 # if(__has_feature(cxx_implicit_moves))
345 # define GLM_CXX11_IMPLICIT_MOVES
346 # endif
347 
348 # if(__has_feature(cxx_inheriting_constructors))
349 # define GLM_CXX11_INHERITING_CONSTRUCTORS
350 # endif
351 
352 # if(__has_feature(cxx_inline_namespaces))
353 # define GLM_CXX11_INLINE_NAMESPACES
354 # endif
355 
356 # if(__has_feature(cxx_lambdas))
357 # define GLM_CXX11_LAMBDAS
358 # endif
359 
360 # if(__has_feature(cxx_local_type_template_args))
361 # define GLM_CXX11_LOCAL_TYPE_TEMPLATE_ARGS
362 # endif
363 
364 # if(__has_feature(cxx_noexcept))
365 # define GLM_CXX11_NOEXCEPT
366 # endif
367 
368 # if(__has_feature(cxx_nonstatic_member_init))
369 # define GLM_CXX11_NONSTATIC_MEMBER_INIT
370 # endif
371 
372 # if(__has_feature(cxx_nullptr))
373 # define GLM_CXX11_NULLPTR
374 # endif
375 
376 # if(__has_feature(cxx_override_control))
377 # define GLM_CXX11_OVERRIDE_CONTROL
378 # endif
379 
380 # if(__has_feature(cxx_reference_qualified_functions))
381 # define GLM_CXX11_REFERENCE_QUALIFIED_FUNCTIONS
382 # endif
383 
384 # if(__has_feature(cxx_range_for))
385 # define GLM_CXX11_RANGE_FOR
386 # endif
387 
388 # if(__has_feature(cxx_raw_string_literals))
389 # define GLM_CXX11_RAW_STRING_LITERALS
390 # endif
391 
392 # if(__has_feature(cxx_rvalue_references))
393 # define GLM_CXX11_RVALUE_REFERENCES
394 # endif
395 
396 # if(__has_feature(cxx_static_assert))
397 # define GLM_CXX11_STATIC_ASSERT
398 # endif
399 
400 # if(__has_feature(cxx_auto_type))
401 # define GLM_CXX11_AUTO_TYPE
402 # endif
403 
404 # if(__has_feature(cxx_strong_enums))
405 # define GLM_CXX11_STRONG_ENUMS
406 # endif
407 
408 # if(__has_feature(cxx_trailing_return))
409 # define GLM_CXX11_TRAILING_RETURN
410 # endif
411 
412 # if(__has_feature(cxx_unicode_literals))
413 # define GLM_CXX11_UNICODE_LITERALS
414 # endif
415 
416 # if(__has_feature(cxx_unrestricted_unions))
417 # define GLM_CXX11_UNRESTRICTED_UNIONS
418 # endif
419 
420 # if(__has_feature(cxx_user_literals))
421 # define GLM_CXX11_USER_LITERALS
422 # endif
423 
424 # if(__has_feature(cxx_variadic_templates))
425 # define GLM_CXX11_VARIADIC_TEMPLATES
426 # endif
427 
428 #endif//(GLM_COMPILER & (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM))
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00002.html000066400000000000000000000103301356361734700216310ustar00rootroot00000000000000 0.9.7: _fixes.hpp File Reference
_fixes.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2011-02-21 / 2011-11-22
Author
Christophe Riccio

Definition in file _fixes.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00002_source.html000066400000000000000000000123211356361734700232130ustar00rootroot00000000000000 0.9.7: _fixes.hpp Source File
_fixes.hpp
Go to the documentation of this file.
1 
33 #include <cmath>
34 
36 #ifdef max
37 #undef max
38 #endif
39 
41 #ifdef min
42 #undef min
43 #endif
44 
46 #ifdef isnan
47 #undef isnan
48 #endif
49 
51 #ifdef isinf
52 #undef isinf
53 #endif
54 
56 #ifdef log2
57 #undef log2
58 #endif
59 
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00003.html000066400000000000000000000103301356361734700216320ustar00rootroot00000000000000 0.9.7: _noise.hpp File Reference
_noise.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-12-24 / 2013-12-24
Author
Christophe Riccio

Definition in file _noise.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00003_source.html000066400000000000000000000437601356361734700232270ustar00rootroot00000000000000 0.9.7: _noise.hpp Source File
_noise.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "../vec2.hpp"
36 #include "../vec3.hpp"
37 #include "../vec4.hpp"
38 #include "../common.hpp"
39 
40 namespace glm{
41 namespace detail
42 {
43  template <typename T>
44  GLM_FUNC_QUALIFIER T mod289(T const & x)
45  {
46  return x - floor(x * static_cast<T>(1.0) / static_cast<T>(289.0)) * static_cast<T>(289.0);
47  }
48 
49  template <typename T>
50  GLM_FUNC_QUALIFIER T permute(T const & x)
51  {
52  return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
53  }
54 
55  template <typename T, precision P>
56  GLM_FUNC_QUALIFIER tvec2<T, P> permute(tvec2<T, P> const & x)
57  {
58  return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
59  }
60 
61  template <typename T, precision P>
62  GLM_FUNC_QUALIFIER tvec3<T, P> permute(tvec3<T, P> const & x)
63  {
64  return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
65  }
66 
67  template <typename T, precision P>
68  GLM_FUNC_QUALIFIER tvec4<T, P> permute(tvec4<T, P> const & x)
69  {
70  return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
71  }
72 /*
73  template <typename T, precision P, template<typename> class vecType>
74  GLM_FUNC_QUALIFIER vecType<T, P> permute(vecType<T, P> const & x)
75  {
76  return mod289(((x * T(34)) + T(1)) * x);
77  }
78 */
79  template <typename T>
80  GLM_FUNC_QUALIFIER T taylorInvSqrt(T const & r)
81  {
82  return T(1.79284291400159) - T(0.85373472095314) * r;
83  }
84 
85  template <typename T, precision P>
86  GLM_FUNC_QUALIFIER tvec2<T, P> taylorInvSqrt(tvec2<T, P> const & r)
87  {
88  return T(1.79284291400159) - T(0.85373472095314) * r;
89  }
90 
91  template <typename T, precision P>
92  GLM_FUNC_QUALIFIER tvec3<T, P> taylorInvSqrt(tvec3<T, P> const & r)
93  {
94  return T(1.79284291400159) - T(0.85373472095314) * r;
95  }
96 
97  template <typename T, precision P>
98  GLM_FUNC_QUALIFIER tvec4<T, P> taylorInvSqrt(tvec4<T, P> const & r)
99  {
100  return T(1.79284291400159) - T(0.85373472095314) * r;
101  }
102 /*
103  template <typename T, precision P, template<typename> class vecType>
104  GLM_FUNC_QUALIFIER vecType<T, P> taylorInvSqrt(vecType<T, P> const & r)
105  {
106  return T(1.79284291400159) - T(0.85373472095314) * r;
107  }
108 */
109 
110  template <typename T, precision P>
111  GLM_FUNC_QUALIFIER tvec2<T, P> fade(tvec2<T, P> const & t)
112  {
113  return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
114  }
115 
116  template <typename T, precision P>
117  GLM_FUNC_QUALIFIER tvec3<T, P> fade(tvec3<T, P> const & t)
118  {
119  return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
120  }
121 
122  template <typename T, precision P>
123  GLM_FUNC_QUALIFIER tvec4<T, P> fade(tvec4<T, P> const & t)
124  {
125  return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
126  }
127 /*
128  template <typename T, precision P, template <typename> class vecType>
129  GLM_FUNC_QUALIFIER vecType<T, P> fade(vecType<T, P> const & t)
130  {
131  return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
132  }
133 */
134 }//namespace detail
135 }//namespace glm
136 
glm::floor
GLM_FUNC_DECL vecType< T, P > floor(vecType< T, P > const &x)
Returns a value equal to the nearest integer that is less then or equal to x.
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00004.html000066400000000000000000000103361356361734700216410ustar00rootroot00000000000000 0.9.7: _swizzle.hpp File Reference
_swizzle.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2006-04-20 / 2011-02-16
Author
Christophe Riccio

Definition in file _swizzle.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00004_source.html000066400000000000000000004753631356361734700232400ustar00rootroot00000000000000 0.9.7: _swizzle.hpp Source File
_swizzle.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 namespace glm{
36 namespace detail
37 {
38  // Internal class for implementing swizzle operators
39  template <typename T, int N>
40  struct _swizzle_base0
41  {
42  typedef T value_type;
43 
44  protected:
45  GLM_FUNC_QUALIFIER value_type& elem (size_t i) { return (reinterpret_cast<value_type*>(_buffer))[i]; }
46  GLM_FUNC_QUALIFIER const value_type& elem (size_t i) const { return (reinterpret_cast<const value_type*>(_buffer))[i]; }
47 
48  // Use an opaque buffer to *ensure* the compiler doesn't call a constructor.
49  // The size 1 buffer is assumed to aligned to the actual members so that the
50  // elem()
51  char _buffer[1];
52  };
53 
54  template <typename T, precision P, typename V, int E0, int E1, int E2, int E3, int N>
55  struct _swizzle_base1 : public _swizzle_base0<T, N>
56  {
57  };
58 
59  template <typename T, precision P, typename V, int E0, int E1>
60  struct _swizzle_base1<T, P, V,E0,E1,-1,-2,2> : public _swizzle_base0<T, 2>
61  {
62  GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0), this->elem(E1)); }
63  };
64 
65  template <typename T, precision P, typename V, int E0, int E1, int E2>
66  struct _swizzle_base1<T, P, V,E0,E1,E2,-1,3> : public _swizzle_base0<T, 3>
67  {
68  GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0), this->elem(E1), this->elem(E2)); }
69  };
70 
71  template <typename T, precision P, typename V, int E0, int E1, int E2, int E3>
72  struct _swizzle_base1<T, P, V,E0,E1,E2,E3,4> : public _swizzle_base0<T, 4>
73  {
74  GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0), this->elem(E1), this->elem(E2), this->elem(E3)); }
75  };
76 
77  // Internal class for implementing swizzle operators
78  /*
79  Template parameters:
80 
81  ValueType = type of scalar values (e.g. float, double)
82  VecType = class the swizzle is applies to (e.g. tvec3<float>)
83  N = number of components in the vector (e.g. 3)
84  E0...3 = what index the n-th element of this swizzle refers to in the unswizzled vec
85 
86  DUPLICATE_ELEMENTS = 1 if there is a repeated element, 0 otherwise (used to specialize swizzles
87  containing duplicate elements so that they cannot be used as r-values).
88  */
89  template <typename ValueType, precision P, typename VecType, int N, int E0, int E1, int E2, int E3, int DUPLICATE_ELEMENTS>
90  struct _swizzle_base2 : public _swizzle_base1<ValueType, P, VecType,E0,E1,E2,E3,N>
91  {
92  typedef VecType vec_type;
93  typedef ValueType value_type;
94 
95  GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const ValueType& t)
96  {
97  for (int i = 0; i < N; ++i)
98  (*this)[i] = t;
99  return *this;
100  }
101 
102  GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const VecType& that)
103  {
104  struct op {
105  GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e = t; }
106  };
107  _apply_op(that, op());
108  return *this;
109  }
110 
111  GLM_FUNC_QUALIFIER void operator -= (const VecType& that)
112  {
113  struct op {
114  GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e -= t; }
115  };
116  _apply_op(that, op());
117  }
118 
119  GLM_FUNC_QUALIFIER void operator += (const VecType& that)
120  {
121  struct op {
122  GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e += t; }
123  };
124  _apply_op(that, op());
125  }
126 
127  GLM_FUNC_QUALIFIER void operator *= (const VecType& that)
128  {
129  struct op {
130  GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e *= t; }
131  };
132  _apply_op(that, op());
133  }
134 
135  GLM_FUNC_QUALIFIER void operator /= (const VecType& that)
136  {
137  struct op {
138  GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e /= t; }
139  };
140  _apply_op(that, op());
141  }
142 
143  GLM_FUNC_QUALIFIER value_type& operator[] (size_t i)
144  {
145  const int offset_dst[4] = { E0, E1, E2, E3 };
146  return this->elem(offset_dst[i]);
147  }
148  GLM_FUNC_QUALIFIER value_type operator[] (size_t i) const
149  {
150  const int offset_dst[4] = { E0, E1, E2, E3 };
151  return this->elem(offset_dst[i]);
152  }
153 
154  protected:
155  template <typename T>
156  GLM_FUNC_QUALIFIER void _apply_op(const VecType& that, T op)
157  {
158  // Make a copy of the data in this == &that.
159  // The copier should optimize out the copy in cases where the function is
160  // properly inlined and the copy is not necessary.
161  ValueType t[N];
162  for (int i = 0; i < N; ++i)
163  t[i] = that[i];
164  for (int i = 0; i < N; ++i)
165  op( (*this)[i], t[i] );
166  }
167  };
168 
169  // Specialization for swizzles containing duplicate elements. These cannot be modified.
170  template <typename ValueType, precision P, typename VecType, int N, int E0, int E1, int E2, int E3>
171  struct _swizzle_base2<ValueType, P, VecType,N,E0,E1,E2,E3,1> : public _swizzle_base1<ValueType, P, VecType,E0,E1,E2,E3,N>
172  {
173  typedef VecType vec_type;
174  typedef ValueType value_type;
175 
176  struct Stub {};
177  GLM_FUNC_QUALIFIER _swizzle_base2& operator= (Stub const &) { return *this; }
178 
179  GLM_FUNC_QUALIFIER value_type operator[] (size_t i) const
180  {
181  const int offset_dst[4] = { E0, E1, E2, E3 };
182  return this->elem(offset_dst[i]);
183  }
184  };
185 
186  template <int N,typename ValueType, precision P, typename VecType, int E0,int E1,int E2,int E3>
187  struct _swizzle : public _swizzle_base2<ValueType, P, VecType, N, E0, E1, E2, E3, (E0==E1||E0==E2||E0==E3||E1==E2||E1==E3||E2==E3)>
188  {
189  typedef _swizzle_base2<ValueType, P, VecType,N,E0,E1,E2,E3,(E0==E1||E0==E2||E0==E3||E1==E2||E1==E3||E2==E3)> base_type;
190 
191  using base_type::operator=;
192 
193  GLM_FUNC_QUALIFIER operator VecType () const { return (*this)(); }
194  };
195 
196 //
197 // To prevent the C++ syntax from getting entirely overwhelming, define some alias macros
198 //
199 #define _GLM_SWIZZLE_TEMPLATE1 template <int N, typename T, precision P, typename V, int E0, int E1, int E2, int E3>
200 #define _GLM_SWIZZLE_TEMPLATE2 template <int N, typename T, precision P, typename V, int E0, int E1, int E2, int E3, int F0, int F1, int F2, int F3>
201 #define _GLM_SWIZZLE_TYPE1 _swizzle<N, T, P, V, E0, E1, E2, E3>
202 #define _GLM_SWIZZLE_TYPE2 _swizzle<N, T, P, V, F0, F1, F2, F3>
203 
204 //
205 // Wrapper for a binary operator (e.g. u.yy + v.zy)
206 //
207 #define _GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \
208  _GLM_SWIZZLE_TEMPLATE2 \
209  GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b) \
210  { \
211  return a() OPERAND b(); \
212  } \
213  _GLM_SWIZZLE_TEMPLATE1 \
214  GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const V& b) \
215  { \
216  return a() OPERAND b; \
217  } \
218  _GLM_SWIZZLE_TEMPLATE1 \
219  GLM_FUNC_QUALIFIER V operator OPERAND ( const V& a, const _GLM_SWIZZLE_TYPE1& b) \
220  { \
221  return a OPERAND b(); \
222  }
223 
224 //
225 // Wrapper for a operand between a swizzle and a binary (e.g. 1.0f - u.xyz)
226 //
227 #define _GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \
228  _GLM_SWIZZLE_TEMPLATE1 \
229  GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const T& b) \
230  { \
231  return a() OPERAND b; \
232  } \
233  _GLM_SWIZZLE_TEMPLATE1 \
234  GLM_FUNC_QUALIFIER V operator OPERAND ( const T& a, const _GLM_SWIZZLE_TYPE1& b) \
235  { \
236  return a OPERAND b(); \
237  }
238 
239 //
240 // Macro for wrapping a function taking one argument (e.g. abs())
241 //
242 #define _GLM_SWIZZLE_FUNCTION_1_ARGS(RETURN_TYPE,FUNCTION) \
243  _GLM_SWIZZLE_TEMPLATE1 \
244  GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a) \
245  { \
246  return FUNCTION(a()); \
247  }
248 
249 //
250 // Macro for wrapping a function taking two vector arguments (e.g. dot()).
251 //
252 #define _GLM_SWIZZLE_FUNCTION_2_ARGS(RETURN_TYPE,FUNCTION) \
253  _GLM_SWIZZLE_TEMPLATE2 \
254  GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b) \
255  { \
256  return FUNCTION(a(), b()); \
257  } \
258  _GLM_SWIZZLE_TEMPLATE1 \
259  GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b) \
260  { \
261  return FUNCTION(a(), b()); \
262  } \
263  _GLM_SWIZZLE_TEMPLATE1 \
264  GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename V& b) \
265  { \
266  return FUNCTION(a(), b); \
267  } \
268  _GLM_SWIZZLE_TEMPLATE1 \
269  GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const V& a, const _GLM_SWIZZLE_TYPE1& b) \
270  { \
271  return FUNCTION(a, b()); \
272  }
273 
274 //
275 // Macro for wrapping a function take 2 vec arguments followed by a scalar (e.g. mix()).
276 //
277 #define _GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(RETURN_TYPE,FUNCTION) \
278  _GLM_SWIZZLE_TEMPLATE2 \
279  GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b, const T& c) \
280  { \
281  return FUNCTION(a(), b(), c); \
282  } \
283  _GLM_SWIZZLE_TEMPLATE1 \
284  GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b, const T& c) \
285  { \
286  return FUNCTION(a(), b(), c); \
287  } \
288  _GLM_SWIZZLE_TEMPLATE1 \
289  GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename S0::vec_type& b, const T& c)\
290  { \
291  return FUNCTION(a(), b, c); \
292  } \
293  _GLM_SWIZZLE_TEMPLATE1 \
294  GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const typename V& a, const _GLM_SWIZZLE_TYPE1& b, const T& c) \
295  { \
296  return FUNCTION(a, b(), c); \
297  }
298 
299 }//namespace detail
300 }//namespace glm
301 
302 namespace glm
303 {
304  namespace detail
305  {
306  _GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(-)
307  _GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(*)
308  _GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(+)
309  _GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(-)
310  _GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(*)
311  _GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(/)
312  }
313 
314  //
315  // Swizzles are distinct types from the unswizzled type. The below macros will
316  // provide template specializations for the swizzle types for the given functions
317  // so that the compiler does not have any ambiguity to choosing how to handle
318  // the function.
319  //
320  // The alternative is to use the operator()() when calling the function in order
321  // to explicitly convert the swizzled type to the unswizzled type.
322  //
323 
324  //_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, abs);
325  //_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, acos);
326  //_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, acosh);
327  //_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, all);
328  //_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, any);
329 
330  //_GLM_SWIZZLE_FUNCTION_2_ARGS(value_type, dot);
331  //_GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type, cross);
332  //_GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type, step);
333  //_GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(vec_type, mix);
334 }
335 
336 #define _GLM_SWIZZLE2_2_MEMBERS(T, P, V, E0,E1) \
337  struct { detail::_swizzle<2, T, P, V<T, P>, 0,0,-1,-2> E0 ## E0; }; \
338  struct { detail::_swizzle<2, T, P, V<T, P>, 0,1,-1,-2> E0 ## E1; }; \
339  struct { detail::_swizzle<2, T, P, V<T, P>, 1,0,-1,-2> E1 ## E0; }; \
340  struct { detail::_swizzle<2, T, P, V<T, P>, 1,1,-1,-2> E1 ## E1; };
341 
342 #define _GLM_SWIZZLE2_3_MEMBERS(T, P, V, E0,E1) \
343  struct { detail::_swizzle<3,T, P, V<T, P>, 0,0,0,-1> E0 ## E0 ## E0; }; \
344  struct { detail::_swizzle<3,T, P, V<T, P>, 0,0,1,-1> E0 ## E0 ## E1; }; \
345  struct { detail::_swizzle<3,T, P, V<T, P>, 0,1,0,-1> E0 ## E1 ## E0; }; \
346  struct { detail::_swizzle<3,T, P, V<T, P>, 0,1,1,-1> E0 ## E1 ## E1; }; \
347  struct { detail::_swizzle<3,T, P, V<T, P>, 1,0,0,-1> E1 ## E0 ## E0; }; \
348  struct { detail::_swizzle<3,T, P, V<T, P>, 1,0,1,-1> E1 ## E0 ## E1; }; \
349  struct { detail::_swizzle<3,T, P, V<T, P>, 1,1,0,-1> E1 ## E1 ## E0; }; \
350  struct { detail::_swizzle<3,T, P, V<T, P>, 1,1,1,-1> E1 ## E1 ## E1; };
351 
352 #define _GLM_SWIZZLE2_4_MEMBERS(T, P, V, E0,E1) \
353  struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
354  struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
355  struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
356  struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
357  struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
358  struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
359  struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
360  struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
361  struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
362  struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
363  struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
364  struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
365  struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
366  struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
367  struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
368  struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,1,1> E1 ## E1 ## E1 ## E1; };
369 
370 #define _GLM_SWIZZLE3_2_MEMBERS(T, P, V, E0,E1,E2) \
371  struct { detail::_swizzle<2,T, P, V<T, P>, 0,0,-1,-2> E0 ## E0; }; \
372  struct { detail::_swizzle<2,T, P, V<T, P>, 0,1,-1,-2> E0 ## E1; }; \
373  struct { detail::_swizzle<2,T, P, V<T, P>, 0,2,-1,-2> E0 ## E2; }; \
374  struct { detail::_swizzle<2,T, P, V<T, P>, 1,0,-1,-2> E1 ## E0; }; \
375  struct { detail::_swizzle<2,T, P, V<T, P>, 1,1,-1,-2> E1 ## E1; }; \
376  struct { detail::_swizzle<2,T, P, V<T, P>, 1,2,-1,-2> E1 ## E2; }; \
377  struct { detail::_swizzle<2,T, P, V<T, P>, 2,0,-1,-2> E2 ## E0; }; \
378  struct { detail::_swizzle<2,T, P, V<T, P>, 2,1,-1,-2> E2 ## E1; }; \
379  struct { detail::_swizzle<2,T, P, V<T, P>, 2,2,-1,-2> E2 ## E2; };
380 
381 #define _GLM_SWIZZLE3_3_MEMBERS(T, P, V ,E0,E1,E2) \
382  struct { detail::_swizzle<3,T,P, V<T, P>, 0,0,0,-1> E0 ## E0 ## E0; }; \
383  struct { detail::_swizzle<3,T,P, V<T, P>, 0,0,1,-1> E0 ## E0 ## E1; }; \
384  struct { detail::_swizzle<3,T,P, V<T, P>, 0,0,2,-1> E0 ## E0 ## E2; }; \
385  struct { detail::_swizzle<3,T,P, V<T, P>, 0,1,0,-1> E0 ## E1 ## E0; }; \
386  struct { detail::_swizzle<3,T,P, V<T, P>, 0,1,1,-1> E0 ## E1 ## E1; }; \
387  struct { detail::_swizzle<3,T,P, V<T, P>, 0,1,2,-1> E0 ## E1 ## E2; }; \
388  struct { detail::_swizzle<3,T,P, V<T, P>, 0,2,0,-1> E0 ## E2 ## E0; }; \
389  struct { detail::_swizzle<3,T,P, V<T, P>, 0,2,1,-1> E0 ## E2 ## E1; }; \
390  struct { detail::_swizzle<3,T,P, V<T, P>, 0,2,2,-1> E0 ## E2 ## E2; }; \
391  struct { detail::_swizzle<3,T,P, V<T, P>, 1,0,0,-1> E1 ## E0 ## E0; }; \
392  struct { detail::_swizzle<3,T,P, V<T, P>, 1,0,1,-1> E1 ## E0 ## E1; }; \
393  struct { detail::_swizzle<3,T,P, V<T, P>, 1,0,2,-1> E1 ## E0 ## E2; }; \
394  struct { detail::_swizzle<3,T,P, V<T, P>, 1,1,0,-1> E1 ## E1 ## E0; }; \
395  struct { detail::_swizzle<3,T,P, V<T, P>, 1,1,1,-1> E1 ## E1 ## E1; }; \
396  struct { detail::_swizzle<3,T,P, V<T, P>, 1,1,2,-1> E1 ## E1 ## E2; }; \
397  struct { detail::_swizzle<3,T,P, V<T, P>, 1,2,0,-1> E1 ## E2 ## E0; }; \
398  struct { detail::_swizzle<3,T,P, V<T, P>, 1,2,1,-1> E1 ## E2 ## E1; }; \
399  struct { detail::_swizzle<3,T,P, V<T, P>, 1,2,2,-1> E1 ## E2 ## E2; }; \
400  struct { detail::_swizzle<3,T,P, V<T, P>, 2,0,0,-1> E2 ## E0 ## E0; }; \
401  struct { detail::_swizzle<3,T,P, V<T, P>, 2,0,1,-1> E2 ## E0 ## E1; }; \
402  struct { detail::_swizzle<3,T,P, V<T, P>, 2,0,2,-1> E2 ## E0 ## E2; }; \
403  struct { detail::_swizzle<3,T,P, V<T, P>, 2,1,0,-1> E2 ## E1 ## E0; }; \
404  struct { detail::_swizzle<3,T,P, V<T, P>, 2,1,1,-1> E2 ## E1 ## E1; }; \
405  struct { detail::_swizzle<3,T,P, V<T, P>, 2,1,2,-1> E2 ## E1 ## E2; }; \
406  struct { detail::_swizzle<3,T,P, V<T, P>, 2,2,0,-1> E2 ## E2 ## E0; }; \
407  struct { detail::_swizzle<3,T,P, V<T, P>, 2,2,1,-1> E2 ## E2 ## E1; }; \
408  struct { detail::_swizzle<3,T,P, V<T, P>, 2,2,2,-1> E2 ## E2 ## E2; };
409 
410 #define _GLM_SWIZZLE3_4_MEMBERS(T, P, V, E0,E1,E2) \
411  struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
412  struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
413  struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
414  struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
415  struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
416  struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
417  struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
418  struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
419  struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
420  struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
421  struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
422  struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
423  struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
424  struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
425  struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
426  struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
427  struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
428  struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
429  struct { detail::_swizzle<4,T, P, V<T, P>, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
430  struct { detail::_swizzle<4,T, P, V<T, P>, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
431  struct { detail::_swizzle<4,T, P, V<T, P>, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
432  struct { detail::_swizzle<4,T, P, V<T, P>, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
433  struct { detail::_swizzle<4,T, P, V<T, P>, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
434  struct { detail::_swizzle<4,T, P, V<T, P>, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
435  struct { detail::_swizzle<4,T, P, V<T, P>, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
436  struct { detail::_swizzle<4,T, P, V<T, P>, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
437  struct { detail::_swizzle<4,T, P, V<T, P>, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
438  struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
439  struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
440  struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
441  struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
442  struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
443  struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
444  struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
445  struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
446  struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
447  struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
448  struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
449  struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
450  struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
451  struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
452  struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
453  struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
454  struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
455  struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
456  struct { detail::_swizzle<4,T, P, V<T, P>, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
457  struct { detail::_swizzle<4,T, P, V<T, P>, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
458  struct { detail::_swizzle<4,T, P, V<T, P>, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
459  struct { detail::_swizzle<4,T, P, V<T, P>, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
460  struct { detail::_swizzle<4,T, P, V<T, P>, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
461  struct { detail::_swizzle<4,T, P, V<T, P>, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
462  struct { detail::_swizzle<4,T, P, V<T, P>, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
463  struct { detail::_swizzle<4,T, P, V<T, P>, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
464  struct { detail::_swizzle<4,T, P, V<T, P>, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
465  struct { detail::_swizzle<4,T, P, V<T, P>, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
466  struct { detail::_swizzle<4,T, P, V<T, P>, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
467  struct { detail::_swizzle<4,T, P, V<T, P>, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
468  struct { detail::_swizzle<4,T, P, V<T, P>, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
469  struct { detail::_swizzle<4,T, P, V<T, P>, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
470  struct { detail::_swizzle<4,T, P, V<T, P>, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
471  struct { detail::_swizzle<4,T, P, V<T, P>, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
472  struct { detail::_swizzle<4,T, P, V<T, P>, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
473  struct { detail::_swizzle<4,T, P, V<T, P>, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
474  struct { detail::_swizzle<4,T, P, V<T, P>, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
475  struct { detail::_swizzle<4,T, P, V<T, P>, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
476  struct { detail::_swizzle<4,T, P, V<T, P>, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
477  struct { detail::_swizzle<4,T, P, V<T, P>, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
478  struct { detail::_swizzle<4,T, P, V<T, P>, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
479  struct { detail::_swizzle<4,T, P, V<T, P>, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
480  struct { detail::_swizzle<4,T, P, V<T, P>, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
481  struct { detail::_swizzle<4,T, P, V<T, P>, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
482  struct { detail::_swizzle<4,T, P, V<T, P>, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
483  struct { detail::_swizzle<4,T, P, V<T, P>, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
484  struct { detail::_swizzle<4,T, P, V<T, P>, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
485  struct { detail::_swizzle<4,T, P, V<T, P>, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
486  struct { detail::_swizzle<4,T, P, V<T, P>, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
487  struct { detail::_swizzle<4,T, P, V<T, P>, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
488  struct { detail::_swizzle<4,T, P, V<T, P>, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
489  struct { detail::_swizzle<4,T, P, V<T, P>, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
490  struct { detail::_swizzle<4,T, P, V<T, P>, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
491  struct { detail::_swizzle<4,T, P, V<T, P>, 2,2,2,2> E2 ## E2 ## E2 ## E2; };
492 
493 #define _GLM_SWIZZLE4_2_MEMBERS(T, P, V, E0,E1,E2,E3) \
494  struct { detail::_swizzle<2,T, P, V<T, P>, 0,0,-1,-2> E0 ## E0; }; \
495  struct { detail::_swizzle<2,T, P, V<T, P>, 0,1,-1,-2> E0 ## E1; }; \
496  struct { detail::_swizzle<2,T, P, V<T, P>, 0,2,-1,-2> E0 ## E2; }; \
497  struct { detail::_swizzle<2,T, P, V<T, P>, 0,3,-1,-2> E0 ## E3; }; \
498  struct { detail::_swizzle<2,T, P, V<T, P>, 1,0,-1,-2> E1 ## E0; }; \
499  struct { detail::_swizzle<2,T, P, V<T, P>, 1,1,-1,-2> E1 ## E1; }; \
500  struct { detail::_swizzle<2,T, P, V<T, P>, 1,2,-1,-2> E1 ## E2; }; \
501  struct { detail::_swizzle<2,T, P, V<T, P>, 1,3,-1,-2> E1 ## E3; }; \
502  struct { detail::_swizzle<2,T, P, V<T, P>, 2,0,-1,-2> E2 ## E0; }; \
503  struct { detail::_swizzle<2,T, P, V<T, P>, 2,1,-1,-2> E2 ## E1; }; \
504  struct { detail::_swizzle<2,T, P, V<T, P>, 2,2,-1,-2> E2 ## E2; }; \
505  struct { detail::_swizzle<2,T, P, V<T, P>, 2,3,-1,-2> E2 ## E3; }; \
506  struct { detail::_swizzle<2,T, P, V<T, P>, 3,0,-1,-2> E3 ## E0; }; \
507  struct { detail::_swizzle<2,T, P, V<T, P>, 3,1,-1,-2> E3 ## E1; }; \
508  struct { detail::_swizzle<2,T, P, V<T, P>, 3,2,-1,-2> E3 ## E2; }; \
509  struct { detail::_swizzle<2,T, P, V<T, P>, 3,3,-1,-2> E3 ## E3; };
510 
511 #define _GLM_SWIZZLE4_3_MEMBERS(T,P, V, E0,E1,E2,E3) \
512  struct { detail::_swizzle<3,T,P, V<T, P>, 0,0,0,-1> E0 ## E0 ## E0; }; \
513  struct { detail::_swizzle<3,T,P, V<T, P>, 0,0,1,-1> E0 ## E0 ## E1; }; \
514  struct { detail::_swizzle<3,T,P, V<T, P>, 0,0,2,-1> E0 ## E0 ## E2; }; \
515  struct { detail::_swizzle<3,T,P, V<T, P>, 0,0,3,-1> E0 ## E0 ## E3; }; \
516  struct { detail::_swizzle<3,T,P, V<T, P>, 0,1,0,-1> E0 ## E1 ## E0; }; \
517  struct { detail::_swizzle<3,T,P, V<T, P>, 0,1,1,-1> E0 ## E1 ## E1; }; \
518  struct { detail::_swizzle<3,T,P, V<T, P>, 0,1,2,-1> E0 ## E1 ## E2; }; \
519  struct { detail::_swizzle<3,T,P, V<T, P>, 0,1,3,-1> E0 ## E1 ## E3; }; \
520  struct { detail::_swizzle<3,T,P, V<T, P>, 0,2,0,-1> E0 ## E2 ## E0; }; \
521  struct { detail::_swizzle<3,T,P, V<T, P>, 0,2,1,-1> E0 ## E2 ## E1; }; \
522  struct { detail::_swizzle<3,T,P, V<T, P>, 0,2,2,-1> E0 ## E2 ## E2; }; \
523  struct { detail::_swizzle<3,T,P, V<T, P>, 0,2,3,-1> E0 ## E2 ## E3; }; \
524  struct { detail::_swizzle<3,T,P, V<T, P>, 0,3,0,-1> E0 ## E3 ## E0; }; \
525  struct { detail::_swizzle<3,T,P, V<T, P>, 0,3,1,-1> E0 ## E3 ## E1; }; \
526  struct { detail::_swizzle<3,T,P, V<T, P>, 0,3,2,-1> E0 ## E3 ## E2; }; \
527  struct { detail::_swizzle<3,T,P, V<T, P>, 0,3,3,-1> E0 ## E3 ## E3; }; \
528  struct { detail::_swizzle<3,T,P, V<T, P>, 1,0,0,-1> E1 ## E0 ## E0; }; \
529  struct { detail::_swizzle<3,T,P, V<T, P>, 1,0,1,-1> E1 ## E0 ## E1; }; \
530  struct { detail::_swizzle<3,T,P, V<T, P>, 1,0,2,-1> E1 ## E0 ## E2; }; \
531  struct { detail::_swizzle<3,T,P, V<T, P>, 1,0,3,-1> E1 ## E0 ## E3; }; \
532  struct { detail::_swizzle<3,T,P, V<T, P>, 1,1,0,-1> E1 ## E1 ## E0; }; \
533  struct { detail::_swizzle<3,T,P, V<T, P>, 1,1,1,-1> E1 ## E1 ## E1; }; \
534  struct { detail::_swizzle<3,T,P, V<T, P>, 1,1,2,-1> E1 ## E1 ## E2; }; \
535  struct { detail::_swizzle<3,T,P, V<T, P>, 1,1,3,-1> E1 ## E1 ## E3; }; \
536  struct { detail::_swizzle<3,T,P, V<T, P>, 1,2,0,-1> E1 ## E2 ## E0; }; \
537  struct { detail::_swizzle<3,T,P, V<T, P>, 1,2,1,-1> E1 ## E2 ## E1; }; \
538  struct { detail::_swizzle<3,T,P, V<T, P>, 1,2,2,-1> E1 ## E2 ## E2; }; \
539  struct { detail::_swizzle<3,T,P, V<T, P>, 1,2,3,-1> E1 ## E2 ## E3; }; \
540  struct { detail::_swizzle<3,T,P, V<T, P>, 1,3,0,-1> E1 ## E3 ## E0; }; \
541  struct { detail::_swizzle<3,T,P, V<T, P>, 1,3,1,-1> E1 ## E3 ## E1; }; \
542  struct { detail::_swizzle<3,T,P, V<T, P>, 1,3,2,-1> E1 ## E3 ## E2; }; \
543  struct { detail::_swizzle<3,T,P, V<T, P>, 1,3,3,-1> E1 ## E3 ## E3; }; \
544  struct { detail::_swizzle<3,T,P, V<T, P>, 2,0,0,-1> E2 ## E0 ## E0; }; \
545  struct { detail::_swizzle<3,T,P, V<T, P>, 2,0,1,-1> E2 ## E0 ## E1; }; \
546  struct { detail::_swizzle<3,T,P, V<T, P>, 2,0,2,-1> E2 ## E0 ## E2; }; \
547  struct { detail::_swizzle<3,T,P, V<T, P>, 2,0,3,-1> E2 ## E0 ## E3; }; \
548  struct { detail::_swizzle<3,T,P, V<T, P>, 2,1,0,-1> E2 ## E1 ## E0; }; \
549  struct { detail::_swizzle<3,T,P, V<T, P>, 2,1,1,-1> E2 ## E1 ## E1; }; \
550  struct { detail::_swizzle<3,T,P, V<T, P>, 2,1,2,-1> E2 ## E1 ## E2; }; \
551  struct { detail::_swizzle<3,T,P, V<T, P>, 2,1,3,-1> E2 ## E1 ## E3; }; \
552  struct { detail::_swizzle<3,T,P, V<T, P>, 2,2,0,-1> E2 ## E2 ## E0; }; \
553  struct { detail::_swizzle<3,T,P, V<T, P>, 2,2,1,-1> E2 ## E2 ## E1; }; \
554  struct { detail::_swizzle<3,T,P, V<T, P>, 2,2,2,-1> E2 ## E2 ## E2; }; \
555  struct { detail::_swizzle<3,T,P, V<T, P>, 2,2,3,-1> E2 ## E2 ## E3; }; \
556  struct { detail::_swizzle<3,T,P, V<T, P>, 2,3,0,-1> E2 ## E3 ## E0; }; \
557  struct { detail::_swizzle<3,T,P, V<T, P>, 2,3,1,-1> E2 ## E3 ## E1; }; \
558  struct { detail::_swizzle<3,T,P, V<T, P>, 2,3,2,-1> E2 ## E3 ## E2; }; \
559  struct { detail::_swizzle<3,T,P, V<T, P>, 2,3,3,-1> E2 ## E3 ## E3; }; \
560  struct { detail::_swizzle<3,T,P, V<T, P>, 3,0,0,-1> E3 ## E0 ## E0; }; \
561  struct { detail::_swizzle<3,T,P, V<T, P>, 3,0,1,-1> E3 ## E0 ## E1; }; \
562  struct { detail::_swizzle<3,T,P, V<T, P>, 3,0,2,-1> E3 ## E0 ## E2; }; \
563  struct { detail::_swizzle<3,T,P, V<T, P>, 3,0,3,-1> E3 ## E0 ## E3; }; \
564  struct { detail::_swizzle<3,T,P, V<T, P>, 3,1,0,-1> E3 ## E1 ## E0; }; \
565  struct { detail::_swizzle<3,T,P, V<T, P>, 3,1,1,-1> E3 ## E1 ## E1; }; \
566  struct { detail::_swizzle<3,T,P, V<T, P>, 3,1,2,-1> E3 ## E1 ## E2; }; \
567  struct { detail::_swizzle<3,T,P, V<T, P>, 3,1,3,-1> E3 ## E1 ## E3; }; \
568  struct { detail::_swizzle<3,T,P, V<T, P>, 3,2,0,-1> E3 ## E2 ## E0; }; \
569  struct { detail::_swizzle<3,T,P, V<T, P>, 3,2,1,-1> E3 ## E2 ## E1; }; \
570  struct { detail::_swizzle<3,T,P, V<T, P>, 3,2,2,-1> E3 ## E2 ## E2; }; \
571  struct { detail::_swizzle<3,T,P, V<T, P>, 3,2,3,-1> E3 ## E2 ## E3; }; \
572  struct { detail::_swizzle<3,T,P, V<T, P>, 3,3,0,-1> E3 ## E3 ## E0; }; \
573  struct { detail::_swizzle<3,T,P, V<T, P>, 3,3,1,-1> E3 ## E3 ## E1; }; \
574  struct { detail::_swizzle<3,T,P, V<T, P>, 3,3,2,-1> E3 ## E3 ## E2; }; \
575  struct { detail::_swizzle<3,T,P, V<T, P>, 3,3,3,-1> E3 ## E3 ## E3; };
576 
577 #define _GLM_SWIZZLE4_4_MEMBERS(T, P, V, E0,E1,E2,E3) \
578  struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
579  struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
580  struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
581  struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,0,3> E0 ## E0 ## E0 ## E3; }; \
582  struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
583  struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
584  struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
585  struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,1,3> E0 ## E0 ## E1 ## E3; }; \
586  struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
587  struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
588  struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
589  struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,2,3> E0 ## E0 ## E2 ## E3; }; \
590  struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,3,0> E0 ## E0 ## E3 ## E0; }; \
591  struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,3,1> E0 ## E0 ## E3 ## E1; }; \
592  struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,3,2> E0 ## E0 ## E3 ## E2; }; \
593  struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,3,3> E0 ## E0 ## E3 ## E3; }; \
594  struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
595  struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
596  struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
597  struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,0,3> E0 ## E1 ## E0 ## E3; }; \
598  struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
599  struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
600  struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
601  struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,1,3> E0 ## E1 ## E1 ## E3; }; \
602  struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
603  struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
604  struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
605  struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,2,3> E0 ## E1 ## E2 ## E3; }; \
606  struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,3,0> E0 ## E1 ## E3 ## E0; }; \
607  struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,3,1> E0 ## E1 ## E3 ## E1; }; \
608  struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,3,2> E0 ## E1 ## E3 ## E2; }; \
609  struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,3,3> E0 ## E1 ## E3 ## E3; }; \
610  struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
611  struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
612  struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
613  struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,0,3> E0 ## E2 ## E0 ## E3; }; \
614  struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
615  struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
616  struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
617  struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,1,3> E0 ## E2 ## E1 ## E3; }; \
618  struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
619  struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
620  struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
621  struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,2,3> E0 ## E2 ## E2 ## E3; }; \
622  struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,3,0> E0 ## E2 ## E3 ## E0; }; \
623  struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,3,1> E0 ## E2 ## E3 ## E1; }; \
624  struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,3,2> E0 ## E2 ## E3 ## E2; }; \
625  struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,3,3> E0 ## E2 ## E3 ## E3; }; \
626  struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,0,0> E0 ## E3 ## E0 ## E0; }; \
627  struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,0,1> E0 ## E3 ## E0 ## E1; }; \
628  struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,0,2> E0 ## E3 ## E0 ## E2; }; \
629  struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,0,3> E0 ## E3 ## E0 ## E3; }; \
630  struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,1,0> E0 ## E3 ## E1 ## E0; }; \
631  struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,1,1> E0 ## E3 ## E1 ## E1; }; \
632  struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,1,2> E0 ## E3 ## E1 ## E2; }; \
633  struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,1,3> E0 ## E3 ## E1 ## E3; }; \
634  struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,2,0> E0 ## E3 ## E2 ## E0; }; \
635  struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,2,1> E0 ## E3 ## E2 ## E1; }; \
636  struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,2,2> E0 ## E3 ## E2 ## E2; }; \
637  struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,2,3> E0 ## E3 ## E2 ## E3; }; \
638  struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,3,0> E0 ## E3 ## E3 ## E0; }; \
639  struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,3,1> E0 ## E3 ## E3 ## E1; }; \
640  struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,3,2> E0 ## E3 ## E3 ## E2; }; \
641  struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,3,3> E0 ## E3 ## E3 ## E3; }; \
642  struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
643  struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
644  struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
645  struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,0,3> E1 ## E0 ## E0 ## E3; }; \
646  struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
647  struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
648  struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
649  struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,1,3> E1 ## E0 ## E1 ## E3; }; \
650  struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
651  struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
652  struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
653  struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,2,3> E1 ## E0 ## E2 ## E3; }; \
654  struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,3,0> E1 ## E0 ## E3 ## E0; }; \
655  struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,3,1> E1 ## E0 ## E3 ## E1; }; \
656  struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,3,2> E1 ## E0 ## E3 ## E2; }; \
657  struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,3,3> E1 ## E0 ## E3 ## E3; }; \
658  struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
659  struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
660  struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
661  struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,0,3> E1 ## E1 ## E0 ## E3; }; \
662  struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
663  struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
664  struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
665  struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,1,3> E1 ## E1 ## E1 ## E3; }; \
666  struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
667  struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
668  struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
669  struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,2,3> E1 ## E1 ## E2 ## E3; }; \
670  struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,3,0> E1 ## E1 ## E3 ## E0; }; \
671  struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,3,1> E1 ## E1 ## E3 ## E1; }; \
672  struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,3,2> E1 ## E1 ## E3 ## E2; }; \
673  struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,3,3> E1 ## E1 ## E3 ## E3; }; \
674  struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
675  struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
676  struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
677  struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,0,3> E1 ## E2 ## E0 ## E3; }; \
678  struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
679  struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
680  struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
681  struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,1,3> E1 ## E2 ## E1 ## E3; }; \
682  struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
683  struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
684  struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
685  struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,2,3> E1 ## E2 ## E2 ## E3; }; \
686  struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,3,0> E1 ## E2 ## E3 ## E0; }; \
687  struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,3,1> E1 ## E2 ## E3 ## E1; }; \
688  struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,3,2> E1 ## E2 ## E3 ## E2; }; \
689  struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,3,3> E1 ## E2 ## E3 ## E3; }; \
690  struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,0,0> E1 ## E3 ## E0 ## E0; }; \
691  struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,0,1> E1 ## E3 ## E0 ## E1; }; \
692  struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,0,2> E1 ## E3 ## E0 ## E2; }; \
693  struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,0,3> E1 ## E3 ## E0 ## E3; }; \
694  struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,1,0> E1 ## E3 ## E1 ## E0; }; \
695  struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,1,1> E1 ## E3 ## E1 ## E1; }; \
696  struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,1,2> E1 ## E3 ## E1 ## E2; }; \
697  struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,1,3> E1 ## E3 ## E1 ## E3; }; \
698  struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,2,0> E1 ## E3 ## E2 ## E0; }; \
699  struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,2,1> E1 ## E3 ## E2 ## E1; }; \
700  struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,2,2> E1 ## E3 ## E2 ## E2; }; \
701  struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,2,3> E1 ## E3 ## E2 ## E3; }; \
702  struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,3,0> E1 ## E3 ## E3 ## E0; }; \
703  struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,3,1> E1 ## E3 ## E3 ## E1; }; \
704  struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,3,2> E1 ## E3 ## E3 ## E2; }; \
705  struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,3,3> E1 ## E3 ## E3 ## E3; }; \
706  struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
707  struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
708  struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
709  struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,0,3> E2 ## E0 ## E0 ## E3; }; \
710  struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
711  struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
712  struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
713  struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,1,3> E2 ## E0 ## E1 ## E3; }; \
714  struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
715  struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
716  struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
717  struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,2,3> E2 ## E0 ## E2 ## E3; }; \
718  struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,3,0> E2 ## E0 ## E3 ## E0; }; \
719  struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,3,1> E2 ## E0 ## E3 ## E1; }; \
720  struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,3,2> E2 ## E0 ## E3 ## E2; }; \
721  struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,3,3> E2 ## E0 ## E3 ## E3; }; \
722  struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
723  struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
724  struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
725  struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,0,3> E2 ## E1 ## E0 ## E3; }; \
726  struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
727  struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
728  struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
729  struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,1,3> E2 ## E1 ## E1 ## E3; }; \
730  struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
731  struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
732  struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
733  struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,2,3> E2 ## E1 ## E2 ## E3; }; \
734  struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,3,0> E2 ## E1 ## E3 ## E0; }; \
735  struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,3,1> E2 ## E1 ## E3 ## E1; }; \
736  struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,3,2> E2 ## E1 ## E3 ## E2; }; \
737  struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,3,3> E2 ## E1 ## E3 ## E3; }; \
738  struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
739  struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
740  struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
741  struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,0,3> E2 ## E2 ## E0 ## E3; }; \
742  struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
743  struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
744  struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
745  struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,1,3> E2 ## E2 ## E1 ## E3; }; \
746  struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
747  struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
748  struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,2,2> E2 ## E2 ## E2 ## E2; }; \
749  struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,2,3> E2 ## E2 ## E2 ## E3; }; \
750  struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,3,0> E2 ## E2 ## E3 ## E0; }; \
751  struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,3,1> E2 ## E2 ## E3 ## E1; }; \
752  struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,3,2> E2 ## E2 ## E3 ## E2; }; \
753  struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,3,3> E2 ## E2 ## E3 ## E3; }; \
754  struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,0,0> E2 ## E3 ## E0 ## E0; }; \
755  struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,0,1> E2 ## E3 ## E0 ## E1; }; \
756  struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,0,2> E2 ## E3 ## E0 ## E2; }; \
757  struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,0,3> E2 ## E3 ## E0 ## E3; }; \
758  struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,1,0> E2 ## E3 ## E1 ## E0; }; \
759  struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,1,1> E2 ## E3 ## E1 ## E1; }; \
760  struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,1,2> E2 ## E3 ## E1 ## E2; }; \
761  struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,1,3> E2 ## E3 ## E1 ## E3; }; \
762  struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,2,0> E2 ## E3 ## E2 ## E0; }; \
763  struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,2,1> E2 ## E3 ## E2 ## E1; }; \
764  struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,2,2> E2 ## E3 ## E2 ## E2; }; \
765  struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,2,3> E2 ## E3 ## E2 ## E3; }; \
766  struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,3,0> E2 ## E3 ## E3 ## E0; }; \
767  struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,3,1> E2 ## E3 ## E3 ## E1; }; \
768  struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,3,2> E2 ## E3 ## E3 ## E2; }; \
769  struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,3,3> E2 ## E3 ## E3 ## E3; }; \
770  struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,0,0> E3 ## E0 ## E0 ## E0; }; \
771  struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,0,1> E3 ## E0 ## E0 ## E1; }; \
772  struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,0,2> E3 ## E0 ## E0 ## E2; }; \
773  struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,0,3> E3 ## E0 ## E0 ## E3; }; \
774  struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,1,0> E3 ## E0 ## E1 ## E0; }; \
775  struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,1,1> E3 ## E0 ## E1 ## E1; }; \
776  struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,1,2> E3 ## E0 ## E1 ## E2; }; \
777  struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,1,3> E3 ## E0 ## E1 ## E3; }; \
778  struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,2,0> E3 ## E0 ## E2 ## E0; }; \
779  struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,2,1> E3 ## E0 ## E2 ## E1; }; \
780  struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,2,2> E3 ## E0 ## E2 ## E2; }; \
781  struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,2,3> E3 ## E0 ## E2 ## E3; }; \
782  struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,3,0> E3 ## E0 ## E3 ## E0; }; \
783  struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,3,1> E3 ## E0 ## E3 ## E1; }; \
784  struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,3,2> E3 ## E0 ## E3 ## E2; }; \
785  struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,3,3> E3 ## E0 ## E3 ## E3; }; \
786  struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,0,0> E3 ## E1 ## E0 ## E0; }; \
787  struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,0,1> E3 ## E1 ## E0 ## E1; }; \
788  struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,0,2> E3 ## E1 ## E0 ## E2; }; \
789  struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,0,3> E3 ## E1 ## E0 ## E3; }; \
790  struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,1,0> E3 ## E1 ## E1 ## E0; }; \
791  struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,1,1> E3 ## E1 ## E1 ## E1; }; \
792  struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,1,2> E3 ## E1 ## E1 ## E2; }; \
793  struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,1,3> E3 ## E1 ## E1 ## E3; }; \
794  struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,2,0> E3 ## E1 ## E2 ## E0; }; \
795  struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,2,1> E3 ## E1 ## E2 ## E1; }; \
796  struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,2,2> E3 ## E1 ## E2 ## E2; }; \
797  struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,2,3> E3 ## E1 ## E2 ## E3; }; \
798  struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,3,0> E3 ## E1 ## E3 ## E0; }; \
799  struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,3,1> E3 ## E1 ## E3 ## E1; }; \
800  struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,3,2> E3 ## E1 ## E3 ## E2; }; \
801  struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,3,3> E3 ## E1 ## E3 ## E3; }; \
802  struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,0,0> E3 ## E2 ## E0 ## E0; }; \
803  struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,0,1> E3 ## E2 ## E0 ## E1; }; \
804  struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,0,2> E3 ## E2 ## E0 ## E2; }; \
805  struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,0,3> E3 ## E2 ## E0 ## E3; }; \
806  struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,1,0> E3 ## E2 ## E1 ## E0; }; \
807  struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,1,1> E3 ## E2 ## E1 ## E1; }; \
808  struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,1,2> E3 ## E2 ## E1 ## E2; }; \
809  struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,1,3> E3 ## E2 ## E1 ## E3; }; \
810  struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,2,0> E3 ## E2 ## E2 ## E0; }; \
811  struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,2,1> E3 ## E2 ## E2 ## E1; }; \
812  struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,2,2> E3 ## E2 ## E2 ## E2; }; \
813  struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,2,3> E3 ## E2 ## E2 ## E3; }; \
814  struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,3,0> E3 ## E2 ## E3 ## E0; }; \
815  struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,3,1> E3 ## E2 ## E3 ## E1; }; \
816  struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,3,2> E3 ## E2 ## E3 ## E2; }; \
817  struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,3,3> E3 ## E2 ## E3 ## E3; }; \
818  struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,0,0> E3 ## E3 ## E0 ## E0; }; \
819  struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,0,1> E3 ## E3 ## E0 ## E1; }; \
820  struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,0,2> E3 ## E3 ## E0 ## E2; }; \
821  struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,0,3> E3 ## E3 ## E0 ## E3; }; \
822  struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,1,0> E3 ## E3 ## E1 ## E0; }; \
823  struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,1,1> E3 ## E3 ## E1 ## E1; }; \
824  struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,1,2> E3 ## E3 ## E1 ## E2; }; \
825  struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,1,3> E3 ## E3 ## E1 ## E3; }; \
826  struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,2,0> E3 ## E3 ## E2 ## E0; }; \
827  struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,2,1> E3 ## E3 ## E2 ## E1; }; \
828  struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,2,2> E3 ## E3 ## E2 ## E2; }; \
829  struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,2,3> E3 ## E3 ## E2 ## E3; }; \
830  struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,3,0> E3 ## E3 ## E3 ## E0; }; \
831  struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,3,1> E3 ## E3 ## E3 ## E1; }; \
832  struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,3,2> E3 ## E3 ## E3 ## E2; }; \
833  struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,3,3> E3 ## E3 ## E3 ## E3; };
glm::e
GLM_FUNC_DECL genType e()
Return e constant.
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00005.html000066400000000000000000000103551356361734700216430ustar00rootroot00000000000000 0.9.7: _swizzle_func.hpp File Reference
_swizzle_func.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2011-10-16 / 2011-10-16
Author
Christophe Riccio

Definition in file _swizzle_func.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00005_source.html000066400000000000000000004524001356361734700232240ustar00rootroot00000000000000 0.9.7: _swizzle_func.hpp Source File
_swizzle_func.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #define GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B) \
36  SWIZZLED_TYPE<TMPL_TYPE, PRECISION> A ## B() CONST \
37  { \
38  return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B); \
39  }
40 
41 #define GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C) \
42  SWIZZLED_TYPE<TMPL_TYPE, PRECISION> A ## B ## C() CONST \
43  { \
44  return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B, this->C); \
45  }
46 
47 #define GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C, D) \
48  SWIZZLED_TYPE<TMPL_TYPE, PRECISION> A ## B ## C ## D() CONST \
49  { \
50  return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B, this->C, this->D); \
51  }
52 
53 #define GLM_SWIZZLE_GEN_VEC2_ENTRY_DEF(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B) \
54  template <typename TMPL_TYPE> \
55  SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE, PRECISION>::A ## B() CONST \
56  { \
57  return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B); \
58  }
59 
60 #define GLM_SWIZZLE_GEN_VEC3_ENTRY_DEF(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C) \
61  template <typename TMPL_TYPE> \
62  SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE, PRECISION>::A ## B ## C() CONST \
63  { \
64  return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B, this->C); \
65  }
66 
67 #define GLM_SWIZZLE_GEN_VEC4_ENTRY_DEF(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C, D) \
68  template <typename TMPL_TYPE> \
69  SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE, PRECISION>::A ## B ## C ## D() CONST \
70  { \
71  return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B, this->C, this->D); \
72  }
73 
74 #define GLM_MUTABLE
75 
76 #define GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
77  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
78  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A)
79 
80 #define GLM_SWIZZLE_GEN_REF_FROM_VEC2(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE) \
81  GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, x, y) \
82  GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, r, g) \
83  GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, s, t)
84 
85 //GLM_SWIZZLE_GEN_REF_FROM_VEC2(valType, detail::vec2, detail::ref2)
86 
87 #define GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
88  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
89  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C) \
90  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A) \
91  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C) \
92  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A) \
93  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B)
94 
95 #define GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
96  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B, C) \
97  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C, B) \
98  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A, C) \
99  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C, A) \
100  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A, B) \
101  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B, A)
102 
103 #define GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
104  GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
105  GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C)
106 
107 #define GLM_SWIZZLE_GEN_REF_FROM_VEC3(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE) \
108  GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, x, y, z) \
109  GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, r, g, b) \
110  GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, s, t, p)
111 
112 //GLM_SWIZZLE_GEN_REF_FROM_VEC3(valType, detail::vec3, detail::ref2, detail::ref3)
113 
114 #define GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
115  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
116  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C) \
117  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, D) \
118  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A) \
119  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C) \
120  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, D) \
121  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A) \
122  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B) \
123  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, D) \
124  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, A) \
125  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, B) \
126  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, C)
127 
128 #define GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
129  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, C) \
130  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, D) \
131  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, B) \
132  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, D) \
133  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, B) \
134  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, C) \
135  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, C) \
136  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, D) \
137  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, A) \
138  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, D) \
139  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, A) \
140  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, C) \
141  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, B) \
142  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, D) \
143  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, A) \
144  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, D) \
145  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, A) \
146  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, B) \
147  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, B) \
148  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, C) \
149  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, A) \
150  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, C) \
151  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, A) \
152  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, B)
153 
154 #define GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
155  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, B, D) \
156  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, D, B) \
157  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, B, C) \
158  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, C, B) \
159  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, D, C) \
160  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, C, D) \
161  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, A, D) \
162  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, D, A) \
163  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, A, C) \
164  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, C, A) \
165  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, D, C) \
166  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, C, D) \
167  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, A, D) \
168  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, D, A) \
169  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, A, B) \
170  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, B, A) \
171  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, D, B) \
172  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, B, D) \
173  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, B, A) \
174  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, A, B) \
175  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, B, C) \
176  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, C, B) \
177  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, A, C) \
178  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, C, A)
179 
180 #define GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D) \
181  GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C, D) \
182  GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C, D) \
183  GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D)
184 
185 #define GLM_SWIZZLE_GEN_REF_FROM_VEC4(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
186  GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z, w) \
187  GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b, a) \
188  GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, p, q)
189 
190 //GLM_SWIZZLE_GEN_REF_FROM_VEC4(valType, detail::vec4, detail::ref2, detail::ref3, detail::ref4)
191 
192 #define GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
193  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
194  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
195  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
196  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B)
197 
198 #define GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
199  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
200  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
201  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
202  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
203  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
204  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
205  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
206  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B)
207 
208 #define GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
209  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
210  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
211  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
212  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
213  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
214  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
215  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
216  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
217  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
218  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
219  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
220  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
221  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
222  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
223  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
224  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B)
225 
226 #define GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B) \
227  GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B) \
228  GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B) \
229  GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B)
230 
231 #define GLM_SWIZZLE_GEN_VEC_FROM_VEC2(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
232  GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y) \
233  GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g) \
234  GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t)
235 
236 //GLM_SWIZZLE_GEN_VEC_FROM_VEC2(valType, detail::vec2, detail::vec2, detail::vec3, detail::vec4)
237 
238 #define GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
239  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
240  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
241  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C) \
242  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
243  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B) \
244  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C) \
245  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A) \
246  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B) \
247  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C)
248 
249 #define GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
250  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
251  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
252  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C) \
253  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
254  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
255  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C) \
256  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A) \
257  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B) \
258  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C) \
259  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
260  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
261  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C) \
262  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
263  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B) \
264  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C) \
265  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A) \
266  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B) \
267  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C) \
268  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A) \
269  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B) \
270  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C) \
271  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A) \
272  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B) \
273  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C) \
274  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A) \
275  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B) \
276  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C)
277 
278 #define GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
279  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
280  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
281  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, C) \
282  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
283  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
284  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, C) \
285  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, A) \
286  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, B) \
287  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, C) \
288  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
289  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
290  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, C) \
291  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
292  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
293  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, C) \
294  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, A) \
295  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, B) \
296  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, C) \
297  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, A) \
298  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, B) \
299  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, C) \
300  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, A) \
301  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, B) \
302  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, C) \
303  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, A) \
304  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, B) \
305  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, C) \
306  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
307  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
308  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, C) \
309  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
310  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
311  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, C) \
312  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, A) \
313  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, B) \
314  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, C) \
315  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
316  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
317  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, C) \
318  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
319  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B) \
320  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, C) \
321  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, A) \
322  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, B) \
323  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, C) \
324  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, A) \
325  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, B) \
326  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, C) \
327  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, A) \
328  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, B) \
329  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, C) \
330  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, A) \
331  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, B) \
332  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, C) \
333  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, A) \
334  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, B) \
335  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, C) \
336  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, A) \
337  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, B) \
338  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, C) \
339  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, A) \
340  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, B) \
341  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, C) \
342  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, A) \
343  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, B) \
344  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, C) \
345  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, A) \
346  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, B) \
347  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, C) \
348  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, A) \
349  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, B) \
350  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, C) \
351  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, A) \
352  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, B) \
353  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, C) \
354  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, A) \
355  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, B) \
356  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, C) \
357  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, A) \
358  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, B) \
359  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, C)
360 
361 #define GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C) \
362  GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C) \
363  GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
364  GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C)
365 
366 #define GLM_SWIZZLE_GEN_VEC_FROM_VEC3(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
367  GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z) \
368  GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b) \
369  GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, p)
370 
371 //GLM_SWIZZLE_GEN_VEC_FROM_VEC3(valType, detail::vec3, detail::vec2, detail::vec3, detail::vec4)
372 
373 #define GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
374  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
375  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
376  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C) \
377  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D) \
378  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
379  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B) \
380  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C) \
381  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D) \
382  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A) \
383  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B) \
384  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C) \
385  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D) \
386  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A) \
387  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B) \
388  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C) \
389  GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D)
390 
391 #define GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
392  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
393  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
394  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C) \
395  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D) \
396  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
397  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
398  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C) \
399  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D) \
400  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A) \
401  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B) \
402  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C) \
403  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D) \
404  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A) \
405  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B) \
406  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C) \
407  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D) \
408  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
409  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
410  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C) \
411  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D) \
412  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
413  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B) \
414  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C) \
415  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D) \
416  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A) \
417  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B) \
418  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C) \
419  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D) \
420  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A) \
421  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B) \
422  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C) \
423  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D) \
424  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A) \
425  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B) \
426  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C) \
427  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D) \
428  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A) \
429  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B) \
430  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C) \
431  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D) \
432  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A) \
433  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B) \
434  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C) \
435  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D) \
436  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A) \
437  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B) \
438  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C) \
439  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D) \
440  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A) \
441  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B) \
442  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C) \
443  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D) \
444  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A) \
445  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B) \
446  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C) \
447  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D) \
448  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A) \
449  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B) \
450  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C) \
451  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D) \
452  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A) \
453  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B) \
454  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C) \
455  GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D)
456 
457 #define GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
458  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
459  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
460  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, C) \
461  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, D) \
462  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
463  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
464  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, C) \
465  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, D) \
466  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, A) \
467  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, B) \
468  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, C) \
469  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, D) \
470  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, A) \
471  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, B) \
472  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, C) \
473  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, D) \
474  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
475  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
476  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, C) \
477  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, D) \
478  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
479  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
480  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, C) \
481  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, D) \
482  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, A) \
483  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, B) \
484  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, C) \
485  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, D) \
486  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, A) \
487  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, B) \
488  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, C) \
489  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, D) \
490  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, A) \
491  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, B) \
492  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, C) \
493  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, D) \
494  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, A) \
495  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, B) \
496  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, C) \
497  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, D) \
498  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, A) \
499  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, B) \
500  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, C) \
501  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, D) \
502  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, A) \
503  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, B) \
504  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, C) \
505  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, D) \
506  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, A) \
507  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, B) \
508  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, C) \
509  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, D) \
510  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, A) \
511  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, B) \
512  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, C) \
513  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, D) \
514  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, A) \
515  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, B) \
516  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, C) \
517  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, D) \
518  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, A) \
519  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, B) \
520  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, C) \
521  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, D) \
522  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
523  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
524  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, C) \
525  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, D) \
526  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
527  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
528  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, C) \
529  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, D) \
530  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, A) \
531  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, B) \
532  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, C) \
533  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, D) \
534  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, A) \
535  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, B) \
536  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, C) \
537  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, D) \
538  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
539  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
540  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, C) \
541  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, D) \
542  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
543  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B) \
544  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, C) \
545  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, D) \
546  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, A) \
547  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, B) \
548  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, C) \
549  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, D) \
550  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, A) \
551  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, B) \
552  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, C) \
553  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, D) \
554  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, A) \
555  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, B) \
556  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, C) \
557  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, D) \
558  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, A) \
559  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, B) \
560  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, C) \
561  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, D) \
562  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, A) \
563  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, B) \
564  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, C) \
565  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, D) \
566  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, A) \
567  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, B) \
568  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, C) \
569  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, D) \
570  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, A) \
571  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, B) \
572  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, C) \
573  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, D) \
574  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, A) \
575  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, B) \
576  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, C) \
577  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, D) \
578  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, A) \
579  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, B) \
580  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, C) \
581  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, D) \
582  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, A) \
583  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, B) \
584  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, C) \
585  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, D) \
586  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, A) \
587  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, B) \
588  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, C) \
589  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, D) \
590  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, A) \
591  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, B) \
592  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, C) \
593  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, D) \
594  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, A) \
595  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, B) \
596  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, C) \
597  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, D) \
598  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, A) \
599  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, B) \
600  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, C) \
601  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, D) \
602  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, A) \
603  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, B) \
604  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, C) \
605  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, D) \
606  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, A) \
607  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, B) \
608  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, C) \
609  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, D) \
610  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, A) \
611  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, B) \
612  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, C) \
613  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, D) \
614  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, A) \
615  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, B) \
616  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, C) \
617  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, D) \
618  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, A) \
619  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, B) \
620  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, C) \
621  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, D) \
622  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, A) \
623  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, B) \
624  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, C) \
625  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, D) \
626  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, A) \
627  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, B) \
628  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, C) \
629  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, D) \
630  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, A) \
631  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, B) \
632  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, C) \
633  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, D) \
634  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, A) \
635  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, B) \
636  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, C) \
637  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, D) \
638  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, A) \
639  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, B) \
640  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, C) \
641  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, D) \
642  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, A) \
643  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, B) \
644  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, C) \
645  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, D) \
646  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, A) \
647  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, B) \
648  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, C) \
649  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, D) \
650  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, A) \
651  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, B) \
652  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, C) \
653  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, D) \
654  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, A) \
655  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, B) \
656  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, C) \
657  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, D) \
658  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, A) \
659  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, B) \
660  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, C) \
661  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, D) \
662  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, A) \
663  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, B) \
664  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, C) \
665  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, D) \
666  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, A) \
667  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, B) \
668  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, C) \
669  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, D) \
670  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, A) \
671  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, B) \
672  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, C) \
673  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, D) \
674  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, A) \
675  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, B) \
676  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, C) \
677  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, D) \
678  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, A) \
679  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, B) \
680  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, C) \
681  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, D) \
682  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, A) \
683  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, B) \
684  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, C) \
685  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, D) \
686  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, A) \
687  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, B) \
688  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, C) \
689  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, D) \
690  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, A) \
691  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, B) \
692  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, C) \
693  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, D) \
694  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, A) \
695  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, B) \
696  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, C) \
697  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, D) \
698  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, A) \
699  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, B) \
700  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, C) \
701  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, D) \
702  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, A) \
703  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, B) \
704  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, C) \
705  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, D) \
706  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, A) \
707  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, B) \
708  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, C) \
709  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, D) \
710  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, A) \
711  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, B) \
712  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, C) \
713  GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, D)
714 
715 #define GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D) \
716  GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C, D) \
717  GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C, D) \
718  GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D)
719 
720 #define GLM_SWIZZLE_GEN_VEC_FROM_VEC4(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
721  GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z, w) \
722  GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b, a) \
723  GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, p, q)
724 
725 //GLM_SWIZZLE_GEN_VEC_FROM_VEC4(valType, detail::vec4, detail::vec2, detail::vec3, detail::vec4)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00006.html000066400000000000000000000103441356361734700216420ustar00rootroot00000000000000 0.9.7: _vectorize.hpp File Reference
_vectorize.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2011-10-14 / 2011-10-14
Author
Christophe Riccio

Definition in file _vectorize.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00006_source.html000066400000000000000000000545401356361734700232300ustar00rootroot00000000000000 0.9.7: _vectorize.hpp Source File
_vectorize.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "type_vec1.hpp"
36 #include "type_vec2.hpp"
37 #include "type_vec3.hpp"
38 #include "type_vec4.hpp"
39 
40 namespace glm{
41 namespace detail
42 {
43  template <typename R, typename T, precision P, template <typename, precision> class vecType>
44  struct functor1{};
45 
46  template <typename R, typename T, precision P>
47  struct functor1<R, T, P, tvec1>
48  {
49  GLM_FUNC_QUALIFIER static tvec1<R, P> call(R (*Func) (T x), tvec1<T, P> const & v)
50  {
51  return tvec1<R, P>(Func(v.x));
52  }
53  };
54 
55  template <typename R, typename T, precision P>
56  struct functor1<R, T, P, tvec2>
57  {
58  GLM_FUNC_QUALIFIER static tvec2<R, P> call(R (*Func) (T x), tvec2<T, P> const & v)
59  {
60  return tvec2<R, P>(Func(v.x), Func(v.y));
61  }
62  };
63 
64  template <typename R, typename T, precision P>
65  struct functor1<R, T, P, tvec3>
66  {
67  GLM_FUNC_QUALIFIER static tvec3<R, P> call(R (*Func) (T x), tvec3<T, P> const & v)
68  {
69  return tvec3<R, P>(Func(v.x), Func(v.y), Func(v.z));
70  }
71  };
72 
73  template <typename R, typename T, precision P>
74  struct functor1<R, T, P, tvec4>
75  {
76  GLM_FUNC_QUALIFIER static tvec4<R, P> call(R (*Func) (T x), tvec4<T, P> const & v)
77  {
78  return tvec4<R, P>(Func(v.x), Func(v.y), Func(v.z), Func(v.w));
79  }
80  };
81 
82  template <typename T, precision P, template <typename, precision> class vecType>
83  struct functor2{};
84 
85  template <typename T, precision P>
86  struct functor2<T, P, tvec1>
87  {
88  GLM_FUNC_QUALIFIER static tvec1<T, P> call(T (*Func) (T x, T y), tvec1<T, P> const & a, tvec1<T, P> const & b)
89  {
90  return tvec1<T, P>(Func(a.x, b.x));
91  }
92  };
93 
94  template <typename T, precision P>
95  struct functor2<T, P, tvec2>
96  {
97  GLM_FUNC_QUALIFIER static tvec2<T, P> call(T (*Func) (T x, T y), tvec2<T, P> const & a, tvec2<T, P> const & b)
98  {
99  return tvec2<T, P>(Func(a.x, b.x), Func(a.y, b.y));
100  }
101  };
102 
103  template <typename T, precision P>
104  struct functor2<T, P, tvec3>
105  {
106  GLM_FUNC_QUALIFIER static tvec3<T, P> call(T (*Func) (T x, T y), tvec3<T, P> const & a, tvec3<T, P> const & b)
107  {
108  return tvec3<T, P>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z));
109  }
110  };
111 
112  template <typename T, precision P>
113  struct functor2<T, P, tvec4>
114  {
115  GLM_FUNC_QUALIFIER static tvec4<T, P> call(T (*Func) (T x, T y), tvec4<T, P> const & a, tvec4<T, P> const & b)
116  {
117  return tvec4<T, P>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z), Func(a.w, b.w));
118  }
119  };
120 
121  template <typename T, precision P, template <typename, precision> class vecType>
122  struct functor2_vec_sca{};
123 
124  template <typename T, precision P>
125  struct functor2_vec_sca<T, P, tvec1>
126  {
127  GLM_FUNC_QUALIFIER static tvec1<T, P> call(T (*Func) (T x, T y), tvec1<T, P> const & a, T b)
128  {
129  return tvec1<T, P>(Func(a.x, b));
130  }
131  };
132 
133  template <typename T, precision P>
134  struct functor2_vec_sca<T, P, tvec2>
135  {
136  GLM_FUNC_QUALIFIER static tvec2<T, P> call(T (*Func) (T x, T y), tvec2<T, P> const & a, T b)
137  {
138  return tvec2<T, P>(Func(a.x, b), Func(a.y, b));
139  }
140  };
141 
142  template <typename T, precision P>
143  struct functor2_vec_sca<T, P, tvec3>
144  {
145  GLM_FUNC_QUALIFIER static tvec3<T, P> call(T (*Func) (T x, T y), tvec3<T, P> const & a, T b)
146  {
147  return tvec3<T, P>(Func(a.x, b), Func(a.y, b), Func(a.z, b));
148  }
149  };
150 
151  template <typename T, precision P>
152  struct functor2_vec_sca<T, P, tvec4>
153  {
154  GLM_FUNC_QUALIFIER static tvec4<T, P> call(T (*Func) (T x, T y), tvec4<T, P> const & a, T b)
155  {
156  return tvec4<T, P>(Func(a.x, b), Func(a.y, b), Func(a.z, b), Func(a.w, b));
157  }
158  };
159 }//namespace detail
160 }//namespace glm
type_vec3.hpp
OpenGL Mathematics (glm.g-truc.net)
glm
Definition: _noise.hpp:40
type_vec2.hpp
OpenGL Mathematics (glm.g-truc.net)
type_vec1.hpp
OpenGL Mathematics (glm.g-truc.net)
type_vec4.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00007.html000066400000000000000000000505621356361734700216510ustar00rootroot00000000000000 0.9.7: associated_min_max.hpp File Reference
Functions
associated_min_max.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , typename U >
GLM_FUNC_DECL U associatedMax (T x, U a, T y, U b)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL tvec2< U, P > associatedMax (vecType< T, P > const &x, vecType< U, P > const &a, vecType< T, P > const &y, vecType< U, P > const &b)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > associatedMax (T x, vecType< U, P > const &a, T y, vecType< U, P > const &b)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMax (vecType< T, P > const &x, U a, vecType< T, P > const &y, U b)
 
template<typename T , typename U >
GLM_FUNC_DECL U associatedMax (T x, U a, T y, U b, T z, U c)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMax (vecType< T, P > const &x, vecType< U, P > const &a, vecType< T, P > const &y, vecType< U, P > const &b, vecType< T, P > const &z, vecType< U, P > const &c)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > associatedMax (T x, vecType< U, P > const &a, T y, vecType< U, P > const &b, T z, vecType< U, P > const &c)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMax (vecType< T, P > const &x, U a, vecType< T, P > const &y, U b, vecType< T, P > const &z, U c)
 
template<typename T , typename U >
GLM_FUNC_DECL U associatedMax (T x, U a, T y, U b, T z, U c, T w, U d)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMax (vecType< T, P > const &x, vecType< U, P > const &a, vecType< T, P > const &y, vecType< U, P > const &b, vecType< T, P > const &z, vecType< U, P > const &c, vecType< T, P > const &w, vecType< U, P > const &d)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMax (T x, vecType< U, P > const &a, T y, vecType< U, P > const &b, T z, vecType< U, P > const &c, T w, vecType< U, P > const &d)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMax (vecType< T, P > const &x, U a, vecType< T, P > const &y, U b, vecType< T, P > const &z, U c, vecType< T, P > const &w, U d)
 
template<typename T , typename U , precision P>
GLM_FUNC_DECL U associatedMin (T x, U a, T y, U b)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL tvec2< U, P > associatedMin (vecType< T, P > const &x, vecType< U, P > const &a, vecType< T, P > const &y, vecType< U, P > const &b)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMin (T x, const vecType< U, P > &a, T y, const vecType< U, P > &b)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMin (vecType< T, P > const &x, U a, vecType< T, P > const &y, U b)
 
template<typename T , typename U >
GLM_FUNC_DECL U associatedMin (T x, U a, T y, U b, T z, U c)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMin (vecType< T, P > const &x, vecType< U, P > const &a, vecType< T, P > const &y, vecType< U, P > const &b, vecType< T, P > const &z, vecType< U, P > const &c)
 
template<typename T , typename U >
GLM_FUNC_DECL U associatedMin (T x, U a, T y, U b, T z, U c, T w, U d)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMin (vecType< T, P > const &x, vecType< U, P > const &a, vecType< T, P > const &y, vecType< U, P > const &b, vecType< T, P > const &z, vecType< U, P > const &c, vecType< T, P > const &w, vecType< U, P > const &d)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMin (T x, vecType< U, P > const &a, T y, vecType< U, P > const &b, T z, vecType< U, P > const &c, T w, vecType< U, P > const &d)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMin (vecType< T, P > const &x, U a, vecType< T, P > const &y, U b, vecType< T, P > const &z, U c, vecType< T, P > const &w, U d)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_associated_min_max

Date
2008-03-10 / 2014-10-11
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTX_extented_min_max (dependence)

Definition in file associated_min_max.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00007_source.html000066400000000000000000000733141356361734700232310ustar00rootroot00000000000000 0.9.7: associated_min_max.hpp Source File
associated_min_max.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../glm.hpp"
46 
47 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
48 # pragma message("GLM: GLM_GTX_associated_min_max extension included")
49 #endif
50 
51 namespace glm
52 {
55 
58  template<typename T, typename U, precision P>
59  GLM_FUNC_DECL U associatedMin(T x, U a, T y, U b);
60 
63  template<typename T, typename U, precision P, template <typename, precision> class vecType>
64  GLM_FUNC_DECL tvec2<U, P> associatedMin(
65  vecType<T, P> const & x, vecType<U, P> const & a,
66  vecType<T, P> const & y, vecType<U, P> const & b);
67 
70  template<typename T, typename U, precision P, template <typename, precision> class vecType>
71  GLM_FUNC_DECL vecType<U, P> associatedMin(
72  T x, const vecType<U, P>& a,
73  T y, const vecType<U, P>& b);
74 
77  template<typename T, typename U, precision P, template <typename, precision> class vecType>
78  GLM_FUNC_DECL vecType<U, P> associatedMin(
79  vecType<T, P> const & x, U a,
80  vecType<T, P> const & y, U b);
81 
84  template<typename T, typename U>
85  GLM_FUNC_DECL U associatedMin(
86  T x, U a,
87  T y, U b,
88  T z, U c);
89 
92  template<typename T, typename U, precision P, template <typename, precision> class vecType>
93  GLM_FUNC_DECL vecType<U, P> associatedMin(
94  vecType<T, P> const & x, vecType<U, P> const & a,
95  vecType<T, P> const & y, vecType<U, P> const & b,
96  vecType<T, P> const & z, vecType<U, P> const & c);
97 
100  template<typename T, typename U>
101  GLM_FUNC_DECL U associatedMin(
102  T x, U a,
103  T y, U b,
104  T z, U c,
105  T w, U d);
106 
109  template<typename T, typename U, precision P, template <typename, precision> class vecType>
110  GLM_FUNC_DECL vecType<U, P> associatedMin(
111  vecType<T, P> const & x, vecType<U, P> const & a,
112  vecType<T, P> const & y, vecType<U, P> const & b,
113  vecType<T, P> const & z, vecType<U, P> const & c,
114  vecType<T, P> const & w, vecType<U, P> const & d);
115 
118  template<typename T, typename U, precision P, template <typename, precision> class vecType>
119  GLM_FUNC_DECL vecType<U, P> associatedMin(
120  T x, vecType<U, P> const & a,
121  T y, vecType<U, P> const & b,
122  T z, vecType<U, P> const & c,
123  T w, vecType<U, P> const & d);
124 
127  template<typename T, typename U, precision P, template <typename, precision> class vecType>
128  GLM_FUNC_DECL vecType<U, P> associatedMin(
129  vecType<T, P> const & x, U a,
130  vecType<T, P> const & y, U b,
131  vecType<T, P> const & z, U c,
132  vecType<T, P> const & w, U d);
133 
136  template<typename T, typename U>
137  GLM_FUNC_DECL U associatedMax(T x, U a, T y, U b);
138 
141  template<typename T, typename U, precision P, template <typename, precision> class vecType>
142  GLM_FUNC_DECL tvec2<U, P> associatedMax(
143  vecType<T, P> const & x, vecType<U, P> const & a,
144  vecType<T, P> const & y, vecType<U, P> const & b);
145 
148  template<typename T, typename U, precision P, template <typename, precision> class vecType>
149  GLM_FUNC_DECL vecType<T, P> associatedMax(
150  T x, vecType<U, P> const & a,
151  T y, vecType<U, P> const & b);
152 
155  template<typename T, typename U, precision P, template <typename, precision> class vecType>
156  GLM_FUNC_DECL vecType<U, P> associatedMax(
157  vecType<T, P> const & x, U a,
158  vecType<T, P> const & y, U b);
159 
162  template<typename T, typename U>
163  GLM_FUNC_DECL U associatedMax(
164  T x, U a,
165  T y, U b,
166  T z, U c);
167 
170  template<typename T, typename U, precision P, template <typename, precision> class vecType>
171  GLM_FUNC_DECL vecType<U, P> associatedMax(
172  vecType<T, P> const & x, vecType<U, P> const & a,
173  vecType<T, P> const & y, vecType<U, P> const & b,
174  vecType<T, P> const & z, vecType<U, P> const & c);
175 
178  template<typename T, typename U, precision P, template <typename, precision> class vecType>
179  GLM_FUNC_DECL vecType<T, P> associatedMax(
180  T x, vecType<U, P> const & a,
181  T y, vecType<U, P> const & b,
182  T z, vecType<U, P> const & c);
183 
186  template<typename T, typename U, precision P, template <typename, precision> class vecType>
187  GLM_FUNC_DECL vecType<U, P> associatedMax(
188  vecType<T, P> const & x, U a,
189  vecType<T, P> const & y, U b,
190  vecType<T, P> const & z, U c);
191 
194  template<typename T, typename U>
195  GLM_FUNC_DECL U associatedMax(
196  T x, U a,
197  T y, U b,
198  T z, U c,
199  T w, U d);
200 
203  template<typename T, typename U, precision P, template <typename, precision> class vecType>
204  GLM_FUNC_DECL vecType<U, P> associatedMax(
205  vecType<T, P> const & x, vecType<U, P> const & a,
206  vecType<T, P> const & y, vecType<U, P> const & b,
207  vecType<T, P> const & z, vecType<U, P> const & c,
208  vecType<T, P> const & w, vecType<U, P> const & d);
209 
212  template<typename T, typename U, precision P, template <typename, precision> class vecType>
213  GLM_FUNC_DECL vecType<U, P> associatedMax(
214  T x, vecType<U, P> const & a,
215  T y, vecType<U, P> const & b,
216  T z, vecType<U, P> const & c,
217  T w, vecType<U, P> const & d);
218 
221  template<typename T, typename U, precision P, template <typename, precision> class vecType>
222  GLM_FUNC_DECL vecType<U, P> associatedMax(
223  vecType<T, P> const & x, U a,
224  vecType<T, P> const & y, U b,
225  vecType<T, P> const & z, U c,
226  vecType<T, P> const & w, U d);
227 
229 } //namespace glm
230 
231 #include "associated_min_max.inl"
glm::associatedMin
GLM_FUNC_DECL vecType< U, P > associatedMin(vecType< T, P > const &x, U a, vecType< T, P > const &y, U b, vecType< T, P > const &z, U c, vecType< T, P > const &w, U d)
Minimum comparison between 4 variables and returns 4 associated variable values.
glm
Definition: _noise.hpp:40
glm::associatedMax
GLM_FUNC_DECL vecType< U, P > associatedMax(vecType< T, P > const &x, U a, vecType< T, P > const &y, U b, vecType< T, P > const &z, U c, vecType< T, P > const &w, U d)
Maximum comparison between 4 variables and returns 4 associated variable values.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00008.html000066400000000000000000000227721356361734700216540ustar00rootroot00000000000000 0.9.7: bit.hpp File Reference
Functions
bit.hpp File Reference

Go to the source code of this file.

Functions

template<typename genIUType >
GLM_FUNC_DECL genIUType highestBitValue (genIUType Value)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > highestBitValue (vecType< T, P > const &value)
 
template<typename genIUType >
GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoAbove (genIUType Value)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_DEPRECATED GLM_FUNC_DECL vecType< T, P > powerOfTwoAbove (vecType< T, P > const &value)
 
template<typename genIUType >
GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoBelow (genIUType Value)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_DEPRECATED GLM_FUNC_DECL vecType< T, P > powerOfTwoBelow (vecType< T, P > const &value)
 
template<typename genIUType >
GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoNearest (genIUType Value)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_DEPRECATED GLM_FUNC_DECL vecType< T, P > powerOfTwoNearest (vecType< T, P > const &value)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_bit

Date
2007-03-14 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)
gtc_half_float (dependence)

Definition in file bit.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00008_source.html000066400000000000000000000264031356361734700232270ustar00rootroot00000000000000 0.9.7: bit.hpp Source File
bit.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependencies
46 #include "../gtc/bitfield.hpp"
47 
48 #if(defined(GLM_MESSAGES))
49 # pragma message("GLM: GLM_GTX_bit extension is deprecated, include GLM_GTC_bitfield and GLM_GTC_integer instead")
50 #endif
51 
52 namespace glm
53 {
56 
58  template <typename genIUType>
59  GLM_FUNC_DECL genIUType highestBitValue(genIUType Value);
60 
64  template <typename T, precision P, template <typename, precision> class vecType>
65  GLM_FUNC_DECL vecType<T, P> highestBitValue(vecType<T, P> const & value);
66 
72  template <typename genIUType>
73  GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoAbove(genIUType Value);
74 
80  template <typename T, precision P, template <typename, precision> class vecType>
81  GLM_DEPRECATED GLM_FUNC_DECL vecType<T, P> powerOfTwoAbove(vecType<T, P> const & value);
82 
88  template <typename genIUType>
89  GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoBelow(genIUType Value);
90 
96  template <typename T, precision P, template <typename, precision> class vecType>
97  GLM_DEPRECATED GLM_FUNC_DECL vecType<T, P> powerOfTwoBelow(vecType<T, P> const & value);
98 
104  template <typename genIUType>
105  GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoNearest(genIUType Value);
106 
112  template <typename T, precision P, template <typename, precision> class vecType>
113  GLM_DEPRECATED GLM_FUNC_DECL vecType<T, P> powerOfTwoNearest(vecType<T, P> const & value);
114 
116 } //namespace glm
117 
118 
119 #include "bit.inl"
120 
glm::powerOfTwoNearest
GLM_DEPRECATED GLM_FUNC_DECL vecType< T, P > powerOfTwoNearest(vecType< T, P > const &value)
Return the power of two number which value is the closet to the input value.
glm::highestBitValue
GLM_FUNC_DECL vecType< T, P > highestBitValue(vecType< T, P > const &value)
Find the highest bit set to 1 in a integer variable and return its value.
glm::powerOfTwoBelow
GLM_DEPRECATED GLM_FUNC_DECL vecType< T, P > powerOfTwoBelow(vecType< T, P > const &value)
Return the power of two number which value is just lower the input value.
glm::powerOfTwoAbove
GLM_DEPRECATED GLM_FUNC_DECL vecType< T, P > powerOfTwoAbove(vecType< T, P > const &value)
Return the power of two number which value is just higher the input value.
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00009.html000066400000000000000000000425441356361734700216540ustar00rootroot00000000000000 0.9.7: bitfield.hpp File Reference
Functions
bitfield.hpp File Reference

Go to the source code of this file.

Functions

template<typename genIUType >
GLM_FUNC_DECL genIUType bitfieldFillOne (genIUType Value, int FirstBit, int BitCount)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > bitfieldFillOne (vecType< T, P > const &Value, int FirstBit, int BitCount)
 
template<typename genIUType >
GLM_FUNC_DECL genIUType bitfieldFillZero (genIUType Value, int FirstBit, int BitCount)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > bitfieldFillZero (vecType< T, P > const &Value, int FirstBit, int BitCount)
 
GLM_FUNC_DECL int16 bitfieldInterleave (int8 x, int8 y)
 
GLM_FUNC_DECL uint16 bitfieldInterleave (uint8 x, uint8 y)
 
GLM_FUNC_DECL int32 bitfieldInterleave (int16 x, int16 y)
 
GLM_FUNC_DECL uint32 bitfieldInterleave (uint16 x, uint16 y)
 
GLM_FUNC_DECL int64 bitfieldInterleave (int32 x, int32 y)
 
GLM_FUNC_DECL uint64 bitfieldInterleave (uint32 x, uint32 y)
 
GLM_FUNC_DECL int32 bitfieldInterleave (int8 x, int8 y, int8 z)
 
GLM_FUNC_DECL uint32 bitfieldInterleave (uint8 x, uint8 y, uint8 z)
 
GLM_FUNC_DECL int64 bitfieldInterleave (int16 x, int16 y, int16 z)
 
GLM_FUNC_DECL uint64 bitfieldInterleave (uint16 x, uint16 y, uint16 z)
 
GLM_FUNC_DECL int64 bitfieldInterleave (int32 x, int32 y, int32 z)
 
GLM_FUNC_DECL uint64 bitfieldInterleave (uint32 x, uint32 y, uint32 z)
 
GLM_FUNC_DECL int32 bitfieldInterleave (int8 x, int8 y, int8 z, int8 w)
 
GLM_FUNC_DECL uint32 bitfieldInterleave (uint8 x, uint8 y, uint8 z, uint8 w)
 
GLM_FUNC_DECL int64 bitfieldInterleave (int16 x, int16 y, int16 z, int16 w)
 
GLM_FUNC_DECL uint64 bitfieldInterleave (uint16 x, uint16 y, uint16 z, uint16 w)
 
template<typename genIUType >
GLM_FUNC_DECL genIUType bitfieldRotateLeft (genIUType In, int Shift)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > bitfieldRotateLeft (vecType< T, P > const &In, int Shift)
 
template<typename genIUType >
GLM_FUNC_DECL genIUType bitfieldRotateRight (genIUType In, int Shift)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > bitfieldRotateRight (vecType< T, P > const &In, int Shift)
 
template<typename genIUType >
GLM_FUNC_DECL genIUType mask (genIUType Bits)
 
template<typename T , precision P, template< typename, precision > class vecIUType>
GLM_FUNC_DECL vecIUType< T, P > mask (vecIUType< T, P > const &v)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTC_bitfield

Date
2014-10-25 / 2014-10-25
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTC_bitfield (dependence)

Definition in file bitfield.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00009_source.html000066400000000000000000000454701356361734700232350ustar00rootroot00000000000000 0.9.7: bitfield.hpp Source File
bitfield.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependencies
46 #include "../detail/setup.hpp"
47 #include "../detail/precision.hpp"
48 #include "../detail/type_int.hpp"
49 #include "../detail/_vectorize.hpp"
50 #include <limits>
51 
52 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
53 # pragma message("GLM: GLM_GTC_bitfield extension included")
54 #endif
55 
56 namespace glm
57 {
60 
64  template <typename genIUType>
65  GLM_FUNC_DECL genIUType mask(genIUType Bits);
66 
70  template <typename T, precision P, template <typename, precision> class vecIUType>
71  GLM_FUNC_DECL vecIUType<T, P> mask(vecIUType<T, P> const & v);
72 
76  template <typename genIUType>
77  GLM_FUNC_DECL genIUType bitfieldRotateRight(genIUType In, int Shift);
78 
82  template <typename T, precision P, template <typename, precision> class vecType>
83  GLM_FUNC_DECL vecType<T, P> bitfieldRotateRight(vecType<T, P> const & In, int Shift);
84 
88  template <typename genIUType>
89  GLM_FUNC_DECL genIUType bitfieldRotateLeft(genIUType In, int Shift);
90 
94  template <typename T, precision P, template <typename, precision> class vecType>
95  GLM_FUNC_DECL vecType<T, P> bitfieldRotateLeft(vecType<T, P> const & In, int Shift);
96 
100  template <typename genIUType>
101  GLM_FUNC_DECL genIUType bitfieldFillOne(genIUType Value, int FirstBit, int BitCount);
102 
106  template <typename T, precision P, template <typename, precision> class vecType>
107  GLM_FUNC_DECL vecType<T, P> bitfieldFillOne(vecType<T, P> const & Value, int FirstBit, int BitCount);
108 
112  template <typename genIUType>
113  GLM_FUNC_DECL genIUType bitfieldFillZero(genIUType Value, int FirstBit, int BitCount);
114 
118  template <typename T, precision P, template <typename, precision> class vecType>
119  GLM_FUNC_DECL vecType<T, P> bitfieldFillZero(vecType<T, P> const & Value, int FirstBit, int BitCount);
120 
126  GLM_FUNC_DECL int16 bitfieldInterleave(int8 x, int8 y);
127 
133  GLM_FUNC_DECL uint16 bitfieldInterleave(uint8 x, uint8 y);
134 
140  GLM_FUNC_DECL int32 bitfieldInterleave(int16 x, int16 y);
141 
147  GLM_FUNC_DECL uint32 bitfieldInterleave(uint16 x, uint16 y);
148 
154  GLM_FUNC_DECL int64 bitfieldInterleave(int32 x, int32 y);
155 
161  GLM_FUNC_DECL uint64 bitfieldInterleave(uint32 x, uint32 y);
162 
168  GLM_FUNC_DECL int32 bitfieldInterleave(int8 x, int8 y, int8 z);
169 
175  GLM_FUNC_DECL uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z);
176 
182  GLM_FUNC_DECL int64 bitfieldInterleave(int16 x, int16 y, int16 z);
183 
189  GLM_FUNC_DECL uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z);
190 
196  GLM_FUNC_DECL int64 bitfieldInterleave(int32 x, int32 y, int32 z);
197 
203  GLM_FUNC_DECL uint64 bitfieldInterleave(uint32 x, uint32 y, uint32 z);
204 
210  GLM_FUNC_DECL int32 bitfieldInterleave(int8 x, int8 y, int8 z, int8 w);
211 
217  GLM_FUNC_DECL uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z, uint8 w);
218 
224  GLM_FUNC_DECL int64 bitfieldInterleave(int16 x, int16 y, int16 z, int16 w);
225 
231  GLM_FUNC_DECL uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w);
232 
234 } //namespace glm
235 
236 #include "bitfield.inl"
glm::bitfieldFillOne
GLM_FUNC_DECL vecType< T, P > bitfieldFillOne(vecType< T, P > const &Value, int FirstBit, int BitCount)
Set to 1 a range of bits.
glm::bitfieldFillZero
GLM_FUNC_DECL vecType< T, P > bitfieldFillZero(vecType< T, P > const &Value, int FirstBit, int BitCount)
Set to 0 a range of bits.
glm::bitfieldRotateRight
GLM_FUNC_DECL vecType< T, P > bitfieldRotateRight(vecType< T, P > const &In, int Shift)
Rotate all bits to the right.
glm
Definition: _noise.hpp:40
glm::bitfieldRotateLeft
GLM_FUNC_DECL vecType< T, P > bitfieldRotateLeft(vecType< T, P > const &In, int Shift)
Rotate all bits to the left.
glm::mask
GLM_FUNC_DECL vecIUType< T, P > mask(vecIUType< T, P > const &v)
Build a mask of 'count' bits.
glm::bitfieldInterleave
GLM_FUNC_DECL uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w)
Interleaves the bits of x, y, z and w.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00010.html000066400000000000000000000140441356361734700216360ustar00rootroot00000000000000 0.9.7: closest_point.hpp File Reference
Functions
closest_point.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > closestPointOnLine (tvec3< T, P > const &point, tvec3< T, P > const &a, tvec3< T, P > const &b)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec2< T, P > closestPointOnLine (tvec2< T, P > const &point, tvec2< T, P > const &a, tvec2< T, P > const &b)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_closest_point

Date
2005-12-30 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file closest_point.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00010_source.html000066400000000000000000000161051356361734700232160ustar00rootroot00000000000000 0.9.7: closest_point.hpp Source File
closest_point.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../glm.hpp"
46 
47 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
48 # pragma message("GLM: GLM_GTX_closest_point extension included")
49 #endif
50 
51 namespace glm
52 {
55 
58  template <typename T, precision P>
59  GLM_FUNC_DECL tvec3<T, P> closestPointOnLine(
60  tvec3<T, P> const & point,
61  tvec3<T, P> const & a,
62  tvec3<T, P> const & b);
63 
65  template <typename T, precision P>
66  GLM_FUNC_DECL tvec2<T, P> closestPointOnLine(
67  tvec2<T, P> const & point,
68  tvec2<T, P> const & a,
69  tvec2<T, P> const & b);
70 
72 }// namespace glm
73 
74 #include "closest_point.inl"
glm::closestPointOnLine
GLM_FUNC_DECL tvec2< T, P > closestPointOnLine(tvec2< T, P > const &point, tvec2< T, P > const &a, tvec2< T, P > const &b)
2d lines work as well
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00011.html000066400000000000000000000172401356361734700216400ustar00rootroot00000000000000 0.9.7: color_space.hpp File Reference
Functions
gtc/color_space.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > convertLinearToSRGB (vecType< T, P > const &ColorLinear)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > convertLinearToSRGB (vecType< T, P > const &ColorLinear, T Gamma)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > convertSRGBToLinear (vecType< T, P > const &ColorSRGB)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > convertSRGBToLinear (vecType< T, P > const &ColorSRGB, T Gamma)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTC_color_space

Date
2015-02-10 / 2015-08-02
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTC_color_space (dependence)

Definition in file gtc/color_space.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00011_source.html000066400000000000000000000221221356361734700232130ustar00rootroot00000000000000 0.9.7: color_space.hpp Source File
gtc/color_space.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependencies
46 #include "../detail/setup.hpp"
47 #include "../detail/precision.hpp"
48 #include "../exponential.hpp"
49 #include "../vec3.hpp"
50 #include "../vec4.hpp"
51 #include <limits>
52 
53 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
54 # pragma message("GLM: GLM_GTC_color_space extension included")
55 #endif
56 
57 namespace glm
58 {
61 
63  template <typename T, precision P, template <typename, precision> class vecType>
64  GLM_FUNC_DECL vecType<T, P> convertLinearToSRGB(vecType<T, P> const & ColorLinear);
65 
67  template <typename T, precision P, template <typename, precision> class vecType>
68  GLM_FUNC_DECL vecType<T, P> convertLinearToSRGB(vecType<T, P> const & ColorLinear, T Gamma);
69 
71  template <typename T, precision P, template <typename, precision> class vecType>
72  GLM_FUNC_DECL vecType<T, P> convertSRGBToLinear(vecType<T, P> const & ColorSRGB);
73 
75  template <typename T, precision P, template <typename, precision> class vecType>
76  GLM_FUNC_DECL vecType<T, P> convertSRGBToLinear(vecType<T, P> const & ColorSRGB, T Gamma);
77 
79 } //namespace glm
80 
81 #include "color_space.inl"
glm::convertLinearToSRGB
GLM_FUNC_DECL vecType< T, P > convertLinearToSRGB(vecType< T, P > const &ColorLinear, T Gamma)
Convert a linear color to sRGB color using a custom gamma correction.
glm
Definition: _noise.hpp:40
glm::convertSRGBToLinear
GLM_FUNC_DECL vecType< T, P > convertSRGBToLinear(vecType< T, P > const &ColorSRGB, T Gamma)
Convert a sRGB color to linear color using a custom gamma correction.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00012.html000066400000000000000000000201541356361734700216370ustar00rootroot00000000000000 0.9.7: color_space.hpp File Reference
Functions
gtx/color_space.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > hsvColor (tvec3< T, P > const &rgbValue)
 
template<typename T , precision P>
GLM_FUNC_DECL T luminosity (tvec3< T, P > const &color)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > rgbColor (tvec3< T, P > const &hsvValue)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > saturation (T const s)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > saturation (T const s, tvec3< T, P > const &color)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< T, P > saturation (T const s, tvec4< T, P > const &color)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_color_space

Date
2005-12-21 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file gtx/color_space.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00012_source.html000066400000000000000000000244351356361734700232250ustar00rootroot00000000000000 0.9.7: color_space.hpp Source File
gtx/color_space.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../glm.hpp"
46 
47 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
48 # pragma message("GLM: GLM_GTX_color_space extension included")
49 #endif
50 
51 namespace glm
52 {
55 
58  template <typename T, precision P>
59  GLM_FUNC_DECL tvec3<T, P> rgbColor(
60  tvec3<T, P> const & hsvValue);
61 
64  template <typename T, precision P>
65  GLM_FUNC_DECL tvec3<T, P> hsvColor(
66  tvec3<T, P> const & rgbValue);
67 
70  template <typename T>
71  GLM_FUNC_DECL tmat4x4<T, defaultp> saturation(
72  T const s);
73 
76  template <typename T, precision P>
77  GLM_FUNC_DECL tvec3<T, P> saturation(
78  T const s,
79  tvec3<T, P> const & color);
80 
83  template <typename T, precision P>
84  GLM_FUNC_DECL tvec4<T, P> saturation(
85  T const s,
86  tvec4<T, P> const & color);
87 
90  template <typename T, precision P>
91  GLM_FUNC_DECL T luminosity(
92  tvec3<T, P> const & color);
93 
95 }//namespace glm
96 
97 #include "color_space.inl"
glm::saturation
GLM_FUNC_DECL tvec4< T, P > saturation(T const s, tvec4< T, P > const &color)
Modify the saturation of a color.
glm
Definition: _noise.hpp:40
glm::luminosity
GLM_FUNC_DECL T luminosity(tvec3< T, P > const &color)
Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals.
glm::hsvColor
GLM_FUNC_DECL tvec3< T, P > hsvColor(tvec3< T, P > const &rgbValue)
Converts a color from RGB color space to its color in HSV color space.
glm::rgbColor
GLM_FUNC_DECL tvec3< T, P > rgbColor(tvec3< T, P > const &hsvValue)
Converts a color from HSV color space to its color in RGB color space.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00013.html000066400000000000000000000160071356361734700216420ustar00rootroot00000000000000 0.9.7: color_space_YCoCg.hpp File Reference
Functions
color_space_YCoCg.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > rgb2YCoCg (tvec3< T, P > const &rgbColor)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > rgb2YCoCgR (tvec3< T, P > const &rgbColor)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > YCoCg2rgb (tvec3< T, P > const &YCoCgColor)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > YCoCgR2rgb (tvec3< T, P > const &YCoCgColor)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_color_space_YCoCg

Date
2008-10-28 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file color_space_YCoCg.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00013_source.html000066400000000000000000000224371356361734700232260ustar00rootroot00000000000000 0.9.7: color_space_YCoCg.hpp Source File
color_space_YCoCg.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../glm.hpp"
46 
47 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
48 # pragma message("GLM: GLM_GTX_color_space_YCoCg extension included")
49 #endif
50 
51 namespace glm
52 {
55 
58  template <typename T, precision P>
59  GLM_FUNC_DECL tvec3<T, P> rgb2YCoCg(
60  tvec3<T, P> const & rgbColor);
61 
64  template <typename T, precision P>
65  GLM_FUNC_DECL tvec3<T, P> YCoCg2rgb(
66  tvec3<T, P> const & YCoCgColor);
67 
71  template <typename T, precision P>
72  GLM_FUNC_DECL tvec3<T, P> rgb2YCoCgR(
73  tvec3<T, P> const & rgbColor);
74 
78  template <typename T, precision P>
79  GLM_FUNC_DECL tvec3<T, P> YCoCgR2rgb(
80  tvec3<T, P> const & YCoCgColor);
81 
83 }//namespace glm
84 
85 #include "color_space_YCoCg.inl"
glm::rgb2YCoCgR
GLM_FUNC_DECL tvec3< T, P > rgb2YCoCgR(tvec3< T, P > const &rgbColor)
Convert a color from RGB color space to YCoCgR color space.
glm::rgb2YCoCg
GLM_FUNC_DECL tvec3< T, P > rgb2YCoCg(tvec3< T, P > const &rgbColor)
Convert a color from RGB color space to YCoCg color space.
glm
Definition: _noise.hpp:40
glm::YCoCgR2rgb
GLM_FUNC_DECL tvec3< T, P > YCoCgR2rgb(tvec3< T, P > const &YCoCgColor)
Convert a color from YCoCgR color space to RGB color space.
glm::rgbColor
GLM_FUNC_DECL tvec3< T, P > rgbColor(tvec3< T, P > const &hsvValue)
Converts a color from HSV color space to its color in RGB color space.
glm::YCoCg2rgb
GLM_FUNC_DECL tvec3< T, P > YCoCg2rgb(tvec3< T, P > const &YCoCgColor)
Convert a color from YCoCg color space to RGB color space.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00014.html000066400000000000000000000101661356361734700216430ustar00rootroot00000000000000 0.9.7: common.hpp File Reference
common.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-12-24 / 2013-12-24
Author
Christophe Riccio

Definition in file common.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00014_source.html000066400000000000000000000062511356361734700232230ustar00rootroot00000000000000 0.9.7: common.hpp Source File
common.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "detail/func_common.hpp"
func_common.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00015.html000066400000000000000000000135671356361734700216540ustar00rootroot00000000000000 0.9.7: common.hpp File Reference
Functions
gtx/common.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > fmod (vecType< T, P > const &v)
 
template<typename genType >
GLM_FUNC_DECL genType::bool_type isdenormal (genType const &x)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_common

Date
2014-09-08 / 2014-09-08
Author
Christophe Riccio
See also
GLM Core (dependence)
gtc_half_float (dependence)

Definition in file gtx/common.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00015_source.html000066400000000000000000000162101356361734700232200ustar00rootroot00000000000000 0.9.7: common.hpp Source File
gtx/common.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependencies:
46 #include "../vec2.hpp"
47 #include "../vec3.hpp"
48 #include "../vec4.hpp"
49 #include "../gtc/vec1.hpp"
50 
51 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
52 # pragma message("GLM: GLM_GTX_common extension included")
53 #endif
54 
55 namespace glm
56 {
59 
68  template <typename genType>
69  GLM_FUNC_DECL typename genType::bool_type isdenormal(genType const & x);
70 
76  template <typename T, precision P, template <typename, precision> class vecType>
77  GLM_FUNC_DECL vecType<T, P> fmod(vecType<T, P> const & v);
78 
80 }//namespace glm
81 
82 #include "common.inl"
glm::isdenormal
GLM_FUNC_DECL genType::bool_type isdenormal(genType const &x)
Returns true if x is a denormalized number Numbers whose absolute value is too small to be represente...
glm::fmod
GLM_FUNC_DECL vecType< T, P > fmod(vecType< T, P > const &v)
Similiar to 'mod' but with a different rounding and integer support.
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00016.html000066400000000000000000001253031356361734700216450ustar00rootroot00000000000000 0.9.7: compatibility.hpp File Reference
Typedefs | Functions
compatibility.hpp File Reference

Go to the source code of this file.

Typedefs

typedef bool bool1
 
typedef bool bool1x1
 
typedef tvec2< bool, highp > bool2
 
typedef tmat2x2< bool, highp > bool2x2
 
typedef tmat2x3< bool, highp > bool2x3
 
typedef tmat2x4< bool, highp > bool2x4
 
typedef tvec3< bool, highp > bool3
 
typedef tmat3x2< bool, highp > bool3x2
 
typedef tmat3x3< bool, highp > bool3x3
 
typedef tmat3x4< bool, highp > bool3x4
 
typedef tvec4< bool, highp > bool4
 
typedef tmat4x2< bool, highp > bool4x2
 
typedef tmat4x3< bool, highp > bool4x3
 
typedef tmat4x4< bool, highp > bool4x4
 
typedef double double1
 
typedef double double1x1
 
typedef tvec2< double, highp > double2
 
typedef tmat2x2< double, highp > double2x2
 
typedef tmat2x3< double, highp > double2x3
 
typedef tmat2x4< double, highp > double2x4
 
typedef tvec3< double, highp > double3
 
typedef tmat3x2< double, highp > double3x2
 
typedef tmat3x3< double, highp > double3x3
 
typedef tmat3x4< double, highp > double3x4
 
typedef tvec4< double, highp > double4
 
typedef tmat4x2< double, highp > double4x2
 
typedef tmat4x3< double, highp > double4x3
 
typedef tmat4x4< double, highp > double4x4
 
typedef float float1
 
typedef float float1x1
 
typedef tvec2< float, highp > float2
 
typedef tmat2x2< float, highp > float2x2
 
typedef tmat2x3< float, highp > float2x3
 
typedef tmat2x4< float, highp > float2x4
 
typedef tvec3< float, highp > float3
 
typedef tmat3x2< float, highp > float3x2
 
typedef tmat3x3< float, highp > float3x3
 
typedef tmat3x4< float, highp > float3x4
 
typedef tvec4< float, highp > float4
 
typedef tmat4x2< float, highp > float4x2
 
typedef tmat4x3< float, highp > float4x3
 
typedef tmat4x4< float, highp > float4x4
 
typedef int int1
 
typedef int int1x1
 
typedef tvec2< int, highp > int2
 
typedef tmat2x2< int, highp > int2x2
 
typedef tmat2x3< int, highp > int2x3
 
typedef tmat2x4< int, highp > int2x4
 
typedef tvec3< int, highp > int3
 
typedef tmat3x2< int, highp > int3x2
 
typedef tmat3x3< int, highp > int3x3
 
typedef tmat3x4< int, highp > int3x4
 
typedef tvec4< int, highp > int4
 
typedef tmat4x2< int, highp > int4x2
 
typedef tmat4x3< int, highp > int4x3
 
typedef tmat4x4< int, highp > int4x4
 

Functions

template<typename T , precision P>
GLM_FUNC_QUALIFIER T atan2 (T x, T y)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec2< T, P > atan2 (const tvec2< T, P > &x, const tvec2< T, P > &y)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec3< T, P > atan2 (const tvec3< T, P > &x, const tvec3< T, P > &y)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec4< T, P > atan2 (const tvec4< T, P > &x, const tvec4< T, P > &y)
 
template<typename genType >
GLM_FUNC_DECL bool isfinite (genType const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec1< bool, P > isfinite (const tvec1< T, P > &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec2< bool, P > isfinite (const tvec2< T, P > &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< bool, P > isfinite (const tvec3< T, P > &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< bool, P > isfinite (const tvec4< T, P > &x)
 
template<typename T >
GLM_FUNC_QUALIFIER T lerp (T x, T y, T a)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec2< T, P > lerp (const tvec2< T, P > &x, const tvec2< T, P > &y, T a)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec3< T, P > lerp (const tvec3< T, P > &x, const tvec3< T, P > &y, T a)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec4< T, P > lerp (const tvec4< T, P > &x, const tvec4< T, P > &y, T a)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec2< T, P > lerp (const tvec2< T, P > &x, const tvec2< T, P > &y, const tvec2< T, P > &a)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec3< T, P > lerp (const tvec3< T, P > &x, const tvec3< T, P > &y, const tvec3< T, P > &a)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec4< T, P > lerp (const tvec4< T, P > &x, const tvec4< T, P > &y, const tvec4< T, P > &a)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER T saturate (T x)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec2< T, P > saturate (const tvec2< T, P > &x)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec3< T, P > saturate (const tvec3< T, P > &x)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec4< T, P > saturate (const tvec4< T, P > &x)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_compatibility

Date
2007-01-24 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)
gtc_half_float (dependence)

Definition in file compatibility.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00016_source.html000066400000000000000000002032631356361734700232270ustar00rootroot00000000000000 0.9.7: compatibility.hpp Source File
compatibility.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependency:
46 #include "../glm.hpp"
47 #include "../gtc/quaternion.hpp"
48 
49 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
50 # pragma message("GLM: GLM_GTX_compatibility extension included")
51 #endif
52 
53 #if(GLM_COMPILER & GLM_COMPILER_VC)
54 # include <cfloat>
55 #elif(GLM_COMPILER & GLM_COMPILER_GCC)
56 # include <cmath>
57 # if(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
58 # undef isfinite
59 # endif
60 #endif//GLM_COMPILER
61 
62 namespace glm
63 {
66 
67  template <typename T> GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);}
68  template <typename T, precision P> GLM_FUNC_QUALIFIER tvec2<T, P> lerp(const tvec2<T, P>& x, const tvec2<T, P>& y, T a){return mix(x, y, a);}
69 
70  template <typename T, precision P> GLM_FUNC_QUALIFIER tvec3<T, P> lerp(const tvec3<T, P>& x, const tvec3<T, P>& y, T a){return mix(x, y, a);}
71  template <typename T, precision P> GLM_FUNC_QUALIFIER tvec4<T, P> lerp(const tvec4<T, P>& x, const tvec4<T, P>& y, T a){return mix(x, y, a);}
72  template <typename T, precision P> GLM_FUNC_QUALIFIER tvec2<T, P> lerp(const tvec2<T, P>& x, const tvec2<T, P>& y, const tvec2<T, P>& a){return mix(x, y, a);}
73  template <typename T, precision P> GLM_FUNC_QUALIFIER tvec3<T, P> lerp(const tvec3<T, P>& x, const tvec3<T, P>& y, const tvec3<T, P>& a){return mix(x, y, a);}
74  template <typename T, precision P> GLM_FUNC_QUALIFIER tvec4<T, P> lerp(const tvec4<T, P>& x, const tvec4<T, P>& y, const tvec4<T, P>& a){return mix(x, y, a);}
75 
76  template <typename T, precision P> GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));}
77  template <typename T, precision P> GLM_FUNC_QUALIFIER tvec2<T, P> saturate(const tvec2<T, P>& x){return clamp(x, T(0), T(1));}
78  template <typename T, precision P> GLM_FUNC_QUALIFIER tvec3<T, P> saturate(const tvec3<T, P>& x){return clamp(x, T(0), T(1));}
79  template <typename T, precision P> GLM_FUNC_QUALIFIER tvec4<T, P> saturate(const tvec4<T, P>& x){return clamp(x, T(0), T(1));}
80 
81  template <typename T, precision P> GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);}
82  template <typename T, precision P> GLM_FUNC_QUALIFIER tvec2<T, P> atan2(const tvec2<T, P>& x, const tvec2<T, P>& y){return atan(x, y);}
83  template <typename T, precision P> GLM_FUNC_QUALIFIER tvec3<T, P> atan2(const tvec3<T, P>& x, const tvec3<T, P>& y){return atan(x, y);}
84  template <typename T, precision P> GLM_FUNC_QUALIFIER tvec4<T, P> atan2(const tvec4<T, P>& x, const tvec4<T, P>& y){return atan(x, y);}
85 
86  template <typename genType> GLM_FUNC_DECL bool isfinite(genType const & x);
87  template <typename T, precision P> GLM_FUNC_DECL tvec1<bool, P> isfinite(const tvec1<T, P>& x);
88  template <typename T, precision P> GLM_FUNC_DECL tvec2<bool, P> isfinite(const tvec2<T, P>& x);
89  template <typename T, precision P> GLM_FUNC_DECL tvec3<bool, P> isfinite(const tvec3<T, P>& x);
90  template <typename T, precision P> GLM_FUNC_DECL tvec4<bool, P> isfinite(const tvec4<T, P>& x);
91 
92  typedef bool bool1;
93  typedef tvec2<bool, highp> bool2;
94  typedef tvec3<bool, highp> bool3;
95  typedef tvec4<bool, highp> bool4;
96 
97  typedef bool bool1x1;
98  typedef tmat2x2<bool, highp> bool2x2;
99  typedef tmat2x3<bool, highp> bool2x3;
100  typedef tmat2x4<bool, highp> bool2x4;
101  typedef tmat3x2<bool, highp> bool3x2;
102  typedef tmat3x3<bool, highp> bool3x3;
103  typedef tmat3x4<bool, highp> bool3x4;
104  typedef tmat4x2<bool, highp> bool4x2;
105  typedef tmat4x3<bool, highp> bool4x3;
106  typedef tmat4x4<bool, highp> bool4x4;
107 
108  typedef int int1;
109  typedef tvec2<int, highp> int2;
110  typedef tvec3<int, highp> int3;
111  typedef tvec4<int, highp> int4;
112 
113  typedef int int1x1;
114  typedef tmat2x2<int, highp> int2x2;
115  typedef tmat2x3<int, highp> int2x3;
116  typedef tmat2x4<int, highp> int2x4;
117  typedef tmat3x2<int, highp> int3x2;
118  typedef tmat3x3<int, highp> int3x3;
119  typedef tmat3x4<int, highp> int3x4;
120  typedef tmat4x2<int, highp> int4x2;
121  typedef tmat4x3<int, highp> int4x3;
122  typedef tmat4x4<int, highp> int4x4;
123 
124  typedef float float1;
125  typedef tvec2<float, highp> float2;
126  typedef tvec3<float, highp> float3;
127  typedef tvec4<float, highp> float4;
128 
129  typedef float float1x1;
130  typedef tmat2x2<float, highp> float2x2;
131  typedef tmat2x3<float, highp> float2x3;
132  typedef tmat2x4<float, highp> float2x4;
133  typedef tmat3x2<float, highp> float3x2;
134  typedef tmat3x3<float, highp> float3x3;
135  typedef tmat3x4<float, highp> float3x4;
136  typedef tmat4x2<float, highp> float4x2;
137  typedef tmat4x3<float, highp> float4x3;
138  typedef tmat4x4<float, highp> float4x4;
139 
140  typedef double double1;
141  typedef tvec2<double, highp> double2;
142  typedef tvec3<double, highp> double3;
143  typedef tvec4<double, highp> double4;
144 
145  typedef double double1x1;
146  typedef tmat2x2<double, highp> double2x2;
147  typedef tmat2x3<double, highp> double2x3;
148  typedef tmat2x4<double, highp> double2x4;
149  typedef tmat3x2<double, highp> double3x2;
150  typedef tmat3x3<double, highp> double3x3;
151  typedef tmat3x4<double, highp> double3x4;
152  typedef tmat4x2<double, highp> double4x2;
153  typedef tmat4x3<double, highp> double4x3;
154  typedef tmat4x4<double, highp> double4x4;
155 
157 }//namespace glm
158 
159 #include "compatibility.inl"
glm::int2x2
tmat2x2< int, highp > int2x2
integer matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:114
glm::int4x2
tmat4x2< int, highp > int4x2
integer matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:120
glm::clamp
GLM_FUNC_DECL genType clamp(genType x, genType minVal, genType maxVal)
Returns min(max(x, minVal), maxVal) for each component in x using the floating-point values minVal an...
glm::bool3x4
tmat3x4< bool, highp > bool3x4
boolean matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:103
glm::float3x4
tmat3x4< float, highp > float3x4
single-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:135
glm::int4x4
tmat4x4< int, highp > int4x4
integer matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:122
glm::double4x3
tmat4x3< double, highp > double4x3
double-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:153
glm::bool3
tvec3< bool, highp > bool3
boolean type with 3 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:94
glm::float2x4
tmat2x4< float, highp > float2x4
single-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:132
glm::double2x4
tmat2x4< double, highp > double2x4
double-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:148
glm::bool2x3
tmat2x3< bool, highp > bool2x3
boolean matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:99
glm::double1
double double1
double-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:140
glm::bool4x3
tmat4x3< bool, highp > bool4x3
boolean matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:105
glm::float2x3
tmat2x3< float, highp > float2x3
single-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:131
glm::int3x4
tmat3x4< int, highp > int3x4
integer matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:119
glm::int2x3
tmat2x3< int, highp > int2x3
integer matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:115
glm::double4x4
tmat4x4< double, highp > double4x4
double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:154
glm::bool4x2
tmat4x2< bool, highp > bool4x2
boolean matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:104
glm::atan2
GLM_FUNC_QUALIFIER tvec4< T, P > atan2(const tvec4< T, P > &x, const tvec4< T, P > &y)
Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what q...
Definition: compatibility.hpp:84
glm::bool4
tvec4< bool, highp > bool4
boolean type with 4 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:95
glm::double3x2
tmat3x2< double, highp > double3x2
double-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:149
glm::double3
tvec3< double, highp > double3
double-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:142
glm::lerp
GLM_FUNC_QUALIFIER tvec4< T, P > lerp(const tvec4< T, P > &x, const tvec4< T, P > &y, const tvec4< T, P > &a)
Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using v...
Definition: compatibility.hpp:74
glm::float1x1
float float1x1
single-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:129
glm::float2x2
tmat2x2< float, highp > float2x2
single-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:130
glm::int4x3
tmat4x3< int, highp > int4x3
integer matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:121
glm::float3x3
tmat3x3< float, highp > float3x3
single-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:134
glm::int1x1
int int1x1
integer matrix with 1 component. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:113
glm::float4x2
tmat4x2< float, highp > float4x2
single-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:136
glm::double4
tvec4< double, highp > double4
double-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:143
glm::isfinite
GLM_FUNC_DECL tvec4< bool, P > isfinite(const tvec4< T, P > &x)
Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)...
glm::int2x4
tmat2x4< int, highp > int2x4
integer matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:116
glm::float4x3
tmat4x3< float, highp > float4x3
single-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:137
glm::int3
tvec3< int, highp > int3
integer vector with 3 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:110
glm
Definition: _noise.hpp:40
glm::double3x4
tmat3x4< double, highp > double3x4
double-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:151
glm::double3x3
tmat3x3< double, highp > double3x3
double-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:150
glm::double4x2
tmat4x2< double, highp > double4x2
double-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:152
glm::float3
tvec3< float, highp > float3
single-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:126
glm::bool1x1
bool bool1x1
boolean matrix with 1 x 1 component. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:97
glm::int4
tvec4< int, highp > int4
integer vector with 4 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:111
glm::bool3x3
tmat3x3< bool, highp > bool3x3
boolean matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:102
glm::double2
tvec2< double, highp > double2
double-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:141
glm::int3x2
tmat3x2< int, highp > int3x2
integer matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:117
glm::float4
tvec4< float, highp > float4
single-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:127
glm::int1
int int1
integer vector with 1 component. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:108
glm::float4x4
tmat4x4< float, highp > float4x4
single-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:138
glm::float1
float float1
single-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:124
glm::float2
tvec2< float, highp > float2
single-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:125
glm::bool2x4
tmat2x4< bool, highp > bool2x4
boolean matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:100
glm::double2x2
tmat2x2< double, highp > double2x2
double-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:146
glm::atan
GLM_FUNC_DECL vecType< T, P > atan(vecType< T, P > const &y, vecType< T, P > const &x)
Arc tangent.
glm::saturate
GLM_FUNC_QUALIFIER tvec4< T, P > saturate(const tvec4< T, P > &x)
Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
Definition: compatibility.hpp:79
glm::bool2x2
tmat2x2< bool, highp > bool2x2
boolean matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:98
glm::mix
GLM_FUNC_DECL vecType< T, P > mix(vecType< T, P > const &x, vecType< T, P > const &y, vecType< U, P > const &a)
If genTypeU is a floating scalar or vector: Returns x * (1.0 - a) + y * a, i.e., the linear blend of ...
glm::bool1
bool bool1
boolean type with 1 component. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:92
glm::double1x1
double double1x1
double-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:145
glm::bool2
tvec2< bool, highp > bool2
boolean type with 2 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:93
glm::int2
tvec2< int, highp > int2
integer vector with 2 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:109
glm::double2x3
tmat2x3< double, highp > double2x3
double-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:147
glm::bool3x2
tmat3x2< bool, highp > bool3x2
boolean matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:101
glm::int3x3
tmat3x3< int, highp > int3x3
integer matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:118
glm::float3x2
tmat3x2< float, highp > float3x2
single-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension) ...
Definition: compatibility.hpp:133
glm::bool4x4
tmat4x4< bool, highp > bool4x4
boolean matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
Definition: compatibility.hpp:106
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00017.html000066400000000000000000000156051356361734700216510ustar00rootroot00000000000000 0.9.7: component_wise.hpp File Reference
Functions
component_wise.hpp File Reference

Go to the source code of this file.

Functions

template<typename genType >
GLM_FUNC_DECL genType::value_type compAdd (genType const &v)
 
template<typename genType >
GLM_FUNC_DECL genType::value_type compMax (genType const &v)
 
template<typename genType >
GLM_FUNC_DECL genType::value_type compMin (genType const &v)
 
template<typename genType >
GLM_FUNC_DECL genType::value_type compMul (genType const &v)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_component_wise

Date
2007-05-21 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file component_wise.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00017_source.html000066400000000000000000000215221356361734700232240ustar00rootroot00000000000000 0.9.7: component_wise.hpp Source File
component_wise.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependencies
45 #include "../detail/setup.hpp"
46 #include "../detail/precision.hpp"
47 
48 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
49 # pragma message("GLM: GLM_GTX_component_wise extension included")
50 #endif
51 
52 namespace glm
53 {
56 
59  template <typename genType>
60  GLM_FUNC_DECL typename genType::value_type compAdd(
61  genType const & v);
62 
65  template <typename genType>
66  GLM_FUNC_DECL typename genType::value_type compMul(
67  genType const & v);
68 
71  template <typename genType>
72  GLM_FUNC_DECL typename genType::value_type compMin(
73  genType const & v);
74 
77  template <typename genType>
78  GLM_FUNC_DECL typename genType::value_type compMax(
79  genType const & v);
80 
82 }//namespace glm
83 
84 #include "component_wise.inl"
glm
Definition: _noise.hpp:40
glm::compAdd
GLM_FUNC_DECL genType::value_type compAdd(genType const &v)
Add all vector components together.
glm::compMin
GLM_FUNC_DECL genType::value_type compMin(genType const &v)
Find the minimum value between single vector components.
glm::compMax
GLM_FUNC_DECL genType::value_type compMax(genType const &v)
Find the maximum value between single vector components.
glm::compMul
GLM_FUNC_DECL genType::value_type compMul(genType const &v)
Multiply all vector components together.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00018.html000066400000000000000000000475061356361734700216570ustar00rootroot00000000000000 0.9.7: constants.hpp File Reference
Functions
constants.hpp File Reference

Go to the source code of this file.

Functions

template<typename genType >
GLM_FUNC_DECL genType e ()
 
template<typename genType >
GLM_FUNC_DECL genType epsilon ()
 
template<typename genType >
GLM_FUNC_DECL genType euler ()
 
template<typename genType >
GLM_FUNC_DECL genType four_over_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType golden_ratio ()
 
template<typename genType >
GLM_FUNC_DECL genType half_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType ln_ln_two ()
 
template<typename genType >
GLM_FUNC_DECL genType ln_ten ()
 
template<typename genType >
GLM_FUNC_DECL genType ln_two ()
 
template<typename genType >
GLM_FUNC_DECL genType one ()
 
template<typename genType >
GLM_FUNC_DECL genType one_over_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType one_over_root_two ()
 
template<typename genType >
GLM_FUNC_DECL genType one_over_two_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType pi ()
 
template<typename genType >
GLM_FUNC_DECL genType quarter_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType root_five ()
 
template<typename genType >
GLM_FUNC_DECL genType root_half_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType root_ln_four ()
 
template<typename genType >
GLM_FUNC_DECL genType root_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType root_three ()
 
template<typename genType >
GLM_FUNC_DECL genType root_two ()
 
template<typename genType >
GLM_FUNC_DECL genType root_two_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType third ()
 
template<typename genType >
GLM_FUNC_DECL genType three_over_two_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType two_over_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType two_over_root_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType two_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType two_thirds ()
 
template<typename genType >
GLM_FUNC_DECL genType zero ()
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTC_constants

Date
2011-09-30 / 2012-01-25
Author
Christophe Riccio
See also
GLM Core (dependence)
gtc_half_float (dependence)

Definition in file constants.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00018_source.html000066400000000000000000000637421356361734700232370ustar00rootroot00000000000000 0.9.7: constants.hpp Source File
constants.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependencies
46 #include "../detail/setup.hpp"
47 
48 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
49 # pragma message("GLM: GLM_GTC_constants extension included")
50 #endif
51 
52 namespace glm
53 {
56 
59  template <typename genType>
60  GLM_FUNC_DECL genType epsilon();
61 
64  template <typename genType>
65  GLM_FUNC_DECL genType zero();
66 
69  template <typename genType>
70  GLM_FUNC_DECL genType one();
71 
74  template <typename genType>
75  GLM_FUNC_DECL genType pi();
76 
79  template <typename genType>
80  GLM_FUNC_DECL genType two_pi();
81 
84  template <typename genType>
85  GLM_FUNC_DECL genType root_pi();
86 
89  template <typename genType>
90  GLM_FUNC_DECL genType half_pi();
91 
94  template <typename genType>
95  GLM_FUNC_DECL genType three_over_two_pi();
96 
99  template <typename genType>
100  GLM_FUNC_DECL genType quarter_pi();
101 
104  template <typename genType>
105  GLM_FUNC_DECL genType one_over_pi();
106 
109  template <typename genType>
110  GLM_FUNC_DECL genType one_over_two_pi();
111 
114  template <typename genType>
115  GLM_FUNC_DECL genType two_over_pi();
116 
119  template <typename genType>
120  GLM_FUNC_DECL genType four_over_pi();
121 
124  template <typename genType>
125  GLM_FUNC_DECL genType two_over_root_pi();
126 
129  template <typename genType>
130  GLM_FUNC_DECL genType one_over_root_two();
131 
134  template <typename genType>
135  GLM_FUNC_DECL genType root_half_pi();
136 
139  template <typename genType>
140  GLM_FUNC_DECL genType root_two_pi();
141 
144  template <typename genType>
145  GLM_FUNC_DECL genType root_ln_four();
146 
149  template <typename genType>
150  GLM_FUNC_DECL genType e();
151 
154  template <typename genType>
155  GLM_FUNC_DECL genType euler();
156 
159  template <typename genType>
160  GLM_FUNC_DECL genType root_two();
161 
164  template <typename genType>
165  GLM_FUNC_DECL genType root_three();
166 
169  template <typename genType>
170  GLM_FUNC_DECL genType root_five();
171 
174  template <typename genType>
175  GLM_FUNC_DECL genType ln_two();
176 
179  template <typename genType>
180  GLM_FUNC_DECL genType ln_ten();
181 
184  template <typename genType>
185  GLM_FUNC_DECL genType ln_ln_two();
186 
189  template <typename genType>
190  GLM_FUNC_DECL genType third();
191 
194  template <typename genType>
195  GLM_FUNC_DECL genType two_thirds();
196 
199  template <typename genType>
200  GLM_FUNC_DECL genType golden_ratio();
201 
203 } //namespace glm
204 
205 #include "constants.inl"
glm::euler
GLM_FUNC_DECL genType euler()
Return Euler's constant.
glm::two_over_pi
GLM_FUNC_DECL genType two_over_pi()
Return 2 / pi.
glm::three_over_two_pi
GLM_FUNC_DECL genType three_over_two_pi()
Return pi / 2 * 3.
glm::root_pi
GLM_FUNC_DECL genType root_pi()
Return square root of pi.
glm::one
GLM_FUNC_DECL genType one()
Return 1.
glm::root_ln_four
GLM_FUNC_DECL genType root_ln_four()
Return sqrt(ln(4)).
glm::two_pi
GLM_FUNC_DECL genType two_pi()
Return pi * 2.
glm::root_five
GLM_FUNC_DECL genType root_five()
Return sqrt(5).
glm::e
GLM_FUNC_DECL genType e()
Return e constant.
glm::quarter_pi
GLM_FUNC_DECL genType quarter_pi()
Return pi / 4.
glm::epsilon
GLM_FUNC_DECL genType epsilon()
Return the epsilon constant for floating point types.
glm::ln_two
GLM_FUNC_DECL genType ln_two()
Return ln(2).
glm::root_two
GLM_FUNC_DECL genType root_two()
Return sqrt(2).
glm::root_three
GLM_FUNC_DECL genType root_three()
Return sqrt(3).
glm::two_thirds
GLM_FUNC_DECL genType two_thirds()
Return 2 / 3.
glm
Definition: _noise.hpp:40
glm::ln_ln_two
GLM_FUNC_DECL genType ln_ln_two()
Return ln(ln(2)).
glm::zero
GLM_FUNC_DECL genType zero()
Return 0.
glm::one_over_root_two
GLM_FUNC_DECL genType one_over_root_two()
Return 1 / sqrt(2).
glm::root_two_pi
GLM_FUNC_DECL genType root_two_pi()
Return sqrt(2 * pi).
glm::root_half_pi
GLM_FUNC_DECL genType root_half_pi()
Return sqrt(pi / 2).
glm::one_over_pi
GLM_FUNC_DECL genType one_over_pi()
Return 1 / pi.
glm::four_over_pi
GLM_FUNC_DECL genType four_over_pi()
Return 4 / pi.
glm::two_over_root_pi
GLM_FUNC_DECL genType two_over_root_pi()
Return 2 / sqrt(pi).
glm::ln_ten
GLM_FUNC_DECL genType ln_ten()
Return ln(10).
glm::one_over_two_pi
GLM_FUNC_DECL genType one_over_two_pi()
Return 1 / (pi * 2).
glm::pi
GLM_FUNC_DECL genType pi()
Return the pi constant.
glm::third
GLM_FUNC_DECL genType third()
Return 1 / 3.
glm::golden_ratio
GLM_FUNC_DECL genType golden_ratio()
Return the golden ratio constant.
glm::half_pi
GLM_FUNC_DECL genType half_pi()
Return pi / 2.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00019.html000066400000000000000000000344201356361734700216470ustar00rootroot00000000000000 0.9.7: dual_quaternion.hpp File Reference
Typedefs | Functions
dual_quaternion.hpp File Reference

Go to the source code of this file.

Typedefs

typedef highp_ddualquat ddualquat
 
typedef highp_fdualquat dualquat
 
typedef highp_fdualquat fdualquat
 
typedef tdualquat< double, highp > highp_ddualquat
 
typedef tdualquat< float, highp > highp_dualquat
 
typedef tdualquat< float, highp > highp_fdualquat
 
typedef tdualquat< double, lowp > lowp_ddualquat
 
typedef tdualquat< float, lowp > lowp_dualquat
 
typedef tdualquat< float, lowp > lowp_fdualquat
 
typedef tdualquat< double, mediump > mediump_ddualquat
 
typedef tdualquat< float, mediump > mediump_dualquat
 
typedef tdualquat< float, mediump > mediump_fdualquat
 

Functions

template<typename T , precision P>
GLM_FUNC_DECL tdualquat< T, P > dualquat_cast (tmat2x4< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tdualquat< T, P > dualquat_cast (tmat3x4< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tdualquat< T, P > inverse (tdualquat< T, P > const &q)
 
template<typename T , precision P>
GLM_FUNC_DECL tdualquat< T, P > lerp (tdualquat< T, P > const &x, tdualquat< T, P > const &y, T const &a)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat2x4< T, P > mat2x4_cast (tdualquat< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x4< T, P > mat3x4_cast (tdualquat< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tdualquat< T, P > normalize (tdualquat< T, P > const &q)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_dual_quaternion

Date
2013-02-10 / 2013-02-20
Author
Maksim Vorobiev (msome.nosp@m.one@.nosp@m.gmail.nosp@m..com)
See also
GLM Core (dependence)
gtc_half_float (dependence)
GLM_GTC_constants (dependence)
GLM_GTC_quaternion (dependence)

Definition in file dual_quaternion.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00019_source.html000066400000000000000000001211331356361734700232250ustar00rootroot00000000000000 0.9.7: dual_quaternion.hpp Source File
dual_quaternion.hpp
Go to the documentation of this file.
1 
45 #pragma once
46 
47 // Dependency:
48 #include "../glm.hpp"
49 #include "../gtc/constants.hpp"
50 #include "../gtc/quaternion.hpp"
51 
52 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
53 # pragma message("GLM: GLM_GTX_dual_quaternion extension included")
54 #endif
55 
56 namespace glm
57 {
60 
61  template <typename T, precision P = defaultp>
62  struct tdualquat
63  {
64  // -- Implementation detail --
65 
66  typedef T value_type;
67  typedef glm::tquat<T, P> part_type;
68 
69 # ifdef GLM_META_PROG_HELPERS
70  static GLM_RELAXED_CONSTEXPR length_t components = 2;
71  static GLM_RELAXED_CONSTEXPR precision prec = P;
72 # endif//GLM_META_PROG_HELPERS
73 
74  // -- Data --
75 
76  glm::tquat<T, P> real, dual;
77 
78  // -- Component accesses --
79 
80 # ifdef GLM_FORCE_SIZE_FUNC
81  typedef size_t size_type;
83  GLM_FUNC_DECL GLM_CONSTEXPR size_type size() const;
84 
85  GLM_FUNC_DECL part_type & operator[](size_type i);
86  GLM_FUNC_DECL part_type const & operator[](size_type i) const;
87 # else
88  typedef length_t length_type;
90  GLM_FUNC_DECL GLM_CONSTEXPR length_type length() const;
91 
92  GLM_FUNC_DECL part_type & operator[](length_type i);
93  GLM_FUNC_DECL part_type const & operator[](length_type i) const;
94 # endif//GLM_FORCE_SIZE_FUNC
95 
96  // -- Implicit basic constructors --
97 
98  GLM_FUNC_DECL tdualquat() GLM_DEFAULT_CTOR;
99  GLM_FUNC_DECL tdualquat(tdualquat<T, P> const & d) GLM_DEFAULT;
100  template <precision Q>
101  GLM_FUNC_DECL tdualquat(tdualquat<T, Q> const & d);
102 
103  // -- Explicit basic constructors --
104 
105  GLM_FUNC_DECL explicit tdualquat(ctor);
106  GLM_FUNC_DECL explicit tdualquat(tquat<T, P> const & real);
107  GLM_FUNC_DECL tdualquat(tquat<T, P> const & orientation, tvec3<T, P> const & translation);
108  GLM_FUNC_DECL tdualquat(tquat<T, P> const & real, tquat<T, P> const & dual);
109 
110  // -- Conversion constructors --
111 
112  template <typename U, precision Q>
113  GLM_FUNC_DECL GLM_EXPLICIT tdualquat(tdualquat<U, Q> const & q);
114 
115  GLM_FUNC_DECL explicit tdualquat(tmat2x4<T, P> const & holder_mat);
116  GLM_FUNC_DECL explicit tdualquat(tmat3x4<T, P> const & aug_mat);
117 
118  // -- Unary arithmetic operators --
119 
120  GLM_FUNC_DECL tdualquat<T, P> & operator=(tdualquat<T, P> const & m) GLM_DEFAULT;
121 
122  template <typename U>
123  GLM_FUNC_DECL tdualquat<T, P> & operator=(tdualquat<U, P> const & m);
124  template <typename U>
125  GLM_FUNC_DECL tdualquat<T, P> & operator*=(U s);
126  template <typename U>
127  GLM_FUNC_DECL tdualquat<T, P> & operator/=(U s);
128  };
129 
130  // -- Unary bit operators --
131 
132  template <typename T, precision P>
133  GLM_FUNC_DECL tquat<T, P> operator-(tquat<T, P> const & q);
134 
135  // -- Binary operators --
136 
137  template <typename T, precision P>
138  GLM_FUNC_DECL tdualquat<T, P> operator+(tdualquat<T, P> const & q, tdualquat<T, P> const & p);
139 
140  template <typename T, precision P>
141  GLM_FUNC_DECL tdualquat<T, P> operator*(tdualquat<T, P> const & q, tdualquat<T, P> const & p);
142 
143  template <typename T, precision P>
144  GLM_FUNC_DECL tvec3<T, P> operator*(tquat<T, P> const & q, tvec3<T, P> const & v);
145 
146  template <typename T, precision P>
147  GLM_FUNC_DECL tvec3<T, P> operator*(tvec3<T, P> const & v, tquat<T, P> const & q);
148 
149  template <typename T, precision P>
150  GLM_FUNC_DECL tvec4<T, P> operator*(tquat<T, P> const & q, tvec4<T, P> const & v);
151 
152  template <typename T, precision P>
153  GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> const & v, tquat<T, P> const & q);
154 
155  template <typename T, precision P>
156  GLM_FUNC_DECL tdualquat<T, P> operator*(tdualquat<T, P> const & q, T const & s);
157 
158  template <typename T, precision P>
159  GLM_FUNC_DECL tdualquat<T, P> operator*(T const & s, tdualquat<T, P> const & q);
160 
161  template <typename T, precision P>
162  GLM_FUNC_DECL tdualquat<T, P> operator/(tdualquat<T, P> const & q, T const & s);
163 
167  template <typename T, precision P>
168  GLM_FUNC_DECL tdualquat<T, P> normalize(tdualquat<T, P> const & q);
169 
173  template <typename T, precision P>
174  GLM_FUNC_DECL tdualquat<T, P> lerp(tdualquat<T, P> const & x, tdualquat<T, P> const & y, T const & a);
175 
179  template <typename T, precision P>
180  GLM_FUNC_DECL tdualquat<T, P> inverse(tdualquat<T, P> const & q);
181 
185  template <typename T, precision P>
186  GLM_FUNC_DECL tmat2x4<T, P> mat2x4_cast(tdualquat<T, P> const & x);
187 
191  template <typename T, precision P>
192  GLM_FUNC_DECL tmat3x4<T, P> mat3x4_cast(tdualquat<T, P> const & x);
193 
197  template <typename T, precision P>
198  GLM_FUNC_DECL tdualquat<T, P> dualquat_cast(tmat2x4<T, P> const & x);
199 
203  template <typename T, precision P>
204  GLM_FUNC_DECL tdualquat<T, P> dualquat_cast(tmat3x4<T, P> const & x);
205 
206 
210  typedef tdualquat<float, lowp> lowp_dualquat;
211 
215  typedef tdualquat<float, mediump> mediump_dualquat;
216 
220  typedef tdualquat<float, highp> highp_dualquat;
221 
222 
226  typedef tdualquat<float, lowp> lowp_fdualquat;
227 
231  typedef tdualquat<float, mediump> mediump_fdualquat;
232 
236  typedef tdualquat<float, highp> highp_fdualquat;
237 
238 
242  typedef tdualquat<double, lowp> lowp_ddualquat;
243 
247  typedef tdualquat<double, mediump> mediump_ddualquat;
248 
252  typedef tdualquat<double, highp> highp_ddualquat;
253 
254 
255 #if(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
256  typedef highp_fdualquat dualquat;
260 
264  typedef highp_fdualquat fdualquat;
265 #elif(defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
266  typedef highp_fdualquat dualquat;
267  typedef highp_fdualquat fdualquat;
268 #elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
269  typedef mediump_fdualquat dualquat;
270  typedef mediump_fdualquat fdualquat;
271 #elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && defined(GLM_PRECISION_LOWP_FLOAT))
272  typedef lowp_fdualquat dualquat;
273  typedef lowp_fdualquat fdualquat;
274 #else
275 # error "GLM error: multiple default precision requested for single-precision floating-point types"
276 #endif
277 
278 
279 #if(!defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE))
280  typedef highp_ddualquat ddualquat;
284 #elif(defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE))
285  typedef highp_ddualquat ddualquat;
286 #elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE))
287  typedef mediump_ddualquat ddualquat;
288 #elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && defined(GLM_PRECISION_LOWP_DOUBLE))
289  typedef lowp_ddualquat ddualquat;
290 #else
291 # error "GLM error: Multiple default precision requested for double-precision floating-point types"
292 #endif
293 
295 } //namespace glm
296 
297 #include "dual_quaternion.inl"
glm::dualquat_cast
GLM_FUNC_DECL tdualquat< T, P > dualquat_cast(tmat3x4< T, P > const &x)
Converts a 3 * 4 matrix (augmented matrix rotation + translation) to a quaternion.
glm::lowp_ddualquat
tdualquat< double, lowp > lowp_ddualquat
Dual-quaternion of low double-precision floating-point numbers.
Definition: dual_quaternion.hpp:242
glm::normalize
GLM_FUNC_DECL tdualquat< T, P > normalize(tdualquat< T, P > const &q)
Returns the normalized quaternion.
glm::highp_dualquat
tdualquat< float, highp > highp_dualquat
Dual-quaternion of high single-precision floating-point numbers.
Definition: dual_quaternion.hpp:220
glm::orientation
GLM_FUNC_DECL tmat4x4< T, P > orientation(tvec3< T, P > const &Normal, tvec3< T, P > const &Up)
Build a rotation matrix from a normal and a up vector.
glm::mediump_fdualquat
tdualquat< float, mediump > mediump_fdualquat
Dual-quaternion of medium single-precision floating-point numbers.
Definition: dual_quaternion.hpp:231
glm::fdualquat
highp_fdualquat fdualquat
Dual-quaternion of single-precision floating-point numbers.
Definition: dual_quaternion.hpp:264
glm::length
GLM_FUNC_DECL T length(vecType< T, P > const &x)
Returns the length of x, i.e., sqrt(x * x).
glm::lowp_dualquat
tdualquat< float, lowp > lowp_dualquat
Dual-quaternion of low single-precision floating-point numbers.
Definition: dual_quaternion.hpp:210
glm::lerp
GLM_FUNC_DECL tdualquat< T, P > lerp(tdualquat< T, P > const &x, tdualquat< T, P > const &y, T const &a)
Returns the linear interpolation of two dual quaternion.
glm::mat2x4_cast
GLM_FUNC_DECL tmat2x4< T, P > mat2x4_cast(tdualquat< T, P > const &x)
Converts a quaternion to a 2 * 4 matrix.
glm::ddualquat
highp_ddualquat ddualquat
Dual-quaternion of default double-precision floating-point numbers.
Definition: dual_quaternion.hpp:283
glm::highp_ddualquat
tdualquat< double, highp > highp_ddualquat
Dual-quaternion of high double-precision floating-point numbers.
Definition: dual_quaternion.hpp:252
glm::highp_fdualquat
tdualquat< float, highp > highp_fdualquat
Dual-quaternion of high single-precision floating-point numbers.
Definition: dual_quaternion.hpp:236
glm
Definition: _noise.hpp:40
glm::inverse
GLM_FUNC_DECL tdualquat< T, P > inverse(tdualquat< T, P > const &q)
Returns the q inverse.
glm::mediump_dualquat
tdualquat< float, mediump > mediump_dualquat
Dual-quaternion of medium single-precision floating-point numbers.
Definition: dual_quaternion.hpp:215
glm::mediump_ddualquat
tdualquat< double, mediump > mediump_ddualquat
Dual-quaternion of medium double-precision floating-point numbers.
Definition: dual_quaternion.hpp:247
glm::mat3x4_cast
GLM_FUNC_DECL tmat3x4< T, P > mat3x4_cast(tdualquat< T, P > const &x)
Converts a quaternion to a 3 * 4 matrix.
glm::lowp_fdualquat
tdualquat< float, lowp > lowp_fdualquat
Dual-quaternion of low single-precision floating-point numbers.
Definition: dual_quaternion.hpp:226
glm::dualquat
highp_fdualquat dualquat
Dual-quaternion of floating-point numbers.
Definition: dual_quaternion.hpp:259
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00020.html000066400000000000000000000165361356361734700216470ustar00rootroot00000000000000 0.9.7: epsilon.hpp File Reference
Functions
epsilon.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > epsilonEqual (vecType< T, P > const &x, vecType< T, P > const &y, T const &epsilon)
 
template<typename genType >
GLM_FUNC_DECL bool epsilonEqual (genType const &x, genType const &y, genType const &epsilon)
 
template<typename genType >
GLM_FUNC_DECL genType::boolType epsilonNotEqual (genType const &x, genType const &y, typename genType::value_type const &epsilon)
 
template<typename genType >
GLM_FUNC_DECL bool epsilonNotEqual (genType const &x, genType const &y, genType const &epsilon)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTC_epsilon

Date
2012-04-07 / 2012-04-07
Author
Christophe Riccio
See also
GLM Core (dependence)
gtc_half_float (dependence)
GLM_GTC_quaternion (dependence)

Definition in file epsilon.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00020_source.html000066400000000000000000000243441356361734700232230ustar00rootroot00000000000000 0.9.7: epsilon.hpp Source File
epsilon.hpp
Go to the documentation of this file.
1 
44 #pragma once
45 
46 // Dependencies
47 #include "../detail/setup.hpp"
48 #include "../detail/precision.hpp"
49 
50 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
51 # pragma message("GLM: GLM_GTC_epsilon extension included")
52 #endif
53 
54 namespace glm
55 {
58 
63  template <typename T, precision P, template <typename, precision> class vecType>
64  GLM_FUNC_DECL vecType<bool, P> epsilonEqual(
65  vecType<T, P> const & x,
66  vecType<T, P> const & y,
67  T const & epsilon);
68 
73  template <typename genType>
74  GLM_FUNC_DECL bool epsilonEqual(
75  genType const & x,
76  genType const & y,
77  genType const & epsilon);
78 
83  template <typename genType>
84  GLM_FUNC_DECL typename genType::boolType epsilonNotEqual(
85  genType const & x,
86  genType const & y,
87  typename genType::value_type const & epsilon);
88 
93  template <typename genType>
94  GLM_FUNC_DECL bool epsilonNotEqual(
95  genType const & x,
96  genType const & y,
97  genType const & epsilon);
98 
100 }//namespace glm
101 
102 #include "epsilon.inl"
glm::epsilonNotEqual
GLM_FUNC_DECL bool epsilonNotEqual(genType const &x, genType const &y, genType const &epsilon)
Returns the component-wise comparison of |x - y| >= epsilon.
glm::epsilon
GLM_FUNC_DECL genType epsilon()
Return the epsilon constant for floating point types.
glm::epsilonEqual
GLM_FUNC_DECL bool epsilonEqual(genType const &x, genType const &y, genType const &epsilon)
Returns the component-wise comparison of |x - y| < epsilon.
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00021.html000066400000000000000000000347501356361734700216460ustar00rootroot00000000000000 0.9.7: euler_angles.hpp File Reference
Functions
euler_angles.hpp File Reference

Go to the source code of this file.

Functions

template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleX (T const &angleX)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleXY (T const &angleX, T const &angleY)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleXYZ (T const &t1, T const &t2, T const &t3)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleXZ (T const &angleX, T const &angleZ)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleY (T const &angleY)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleYX (T const &angleY, T const &angleX)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleYXZ (T const &yaw, T const &pitch, T const &roll)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleYZ (T const &angleY, T const &angleZ)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleZ (T const &angleZ)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleZX (T const &angle, T const &angleX)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleZY (T const &angleZ, T const &angleY)
 
template<typename T >
GLM_FUNC_DECL void extractEulerAngleXYZ (tmat4x4< T, defaultp > &M, T &t1, T &t2, T &t3)
 
template<typename T >
GLM_FUNC_DECL tmat2x2< T, defaultp > orientate2 (T const &angle)
 
template<typename T >
GLM_FUNC_DECL tmat3x3< T, defaultp > orientate3 (T const &angle)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > orientate3 (tvec3< T, P > const &angles)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > orientate4 (tvec3< T, P > const &angles)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > yawPitchRoll (T const &yaw, T const &pitch, T const &roll)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_euler_angles

Date
2005-12-21 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)
gtc_half_float (dependence)

Definition in file euler_angles.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00021_source.html000066400000000000000000000621441356361734700232240ustar00rootroot00000000000000 0.9.7: euler_angles.hpp Source File
euler_angles.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependency:
46 #include "../glm.hpp"
47 
48 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
49 # pragma message("GLM: GLM_GTX_euler_angles extension included")
50 #endif
51 
52 namespace glm
53 {
56 
59  template <typename T>
60  GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleX(
61  T const & angleX);
62 
65  template <typename T>
66  GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleY(
67  T const & angleY);
68 
71  template <typename T>
72  GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleZ(
73  T const & angleZ);
74 
77  template <typename T>
78  GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleXY(
79  T const & angleX,
80  T const & angleY);
81 
84  template <typename T>
85  GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleYX(
86  T const & angleY,
87  T const & angleX);
88 
91  template <typename T>
92  GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleXZ(
93  T const & angleX,
94  T const & angleZ);
95 
98  template <typename T>
99  GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleZX(
100  T const & angle,
101  T const & angleX);
102 
105  template <typename T>
106  GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleYZ(
107  T const & angleY,
108  T const & angleZ);
109 
112  template <typename T>
113  GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleZY(
114  T const & angleZ,
115  T const & angleY);
116 
119  template <typename T>
120  GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleXYZ(
121  T const & t1,
122  T const & t2,
123  T const & t3);
124 
127  template <typename T>
128  GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleYXZ(
129  T const & yaw,
130  T const & pitch,
131  T const & roll);
132 
135  template <typename T>
136  GLM_FUNC_DECL tmat4x4<T, defaultp> yawPitchRoll(
137  T const & yaw,
138  T const & pitch,
139  T const & roll);
140 
143  template <typename T>
144  GLM_FUNC_DECL tmat2x2<T, defaultp> orientate2(T const & angle);
145 
148  template <typename T>
149  GLM_FUNC_DECL tmat3x3<T, defaultp> orientate3(T const & angle);
150 
153  template <typename T, precision P>
154  GLM_FUNC_DECL tmat3x3<T, P> orientate3(tvec3<T, P> const & angles);
155 
158  template <typename T, precision P>
159  GLM_FUNC_DECL tmat4x4<T, P> orientate4(tvec3<T, P> const & angles);
160 
163  template <typename T>
164  GLM_FUNC_DECL void extractEulerAngleXYZ(tmat4x4<T, defaultp> & M,
165  T & t1,
166  T & t2,
167  T & t3);
168 
170 }//namespace glm
171 
172 #include "euler_angles.inl"
glm::eulerAngleZX
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleZX(T const &angle, T const &angleX)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X).
glm::pitch
GLM_FUNC_DECL T pitch(tquat< T, P > const &x)
Returns pitch value of euler angles expressed in radians.
glm::orientate4
GLM_FUNC_DECL tmat4x4< T, P > orientate4(tvec3< T, P > const &angles)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
glm::eulerAngleYZ
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleYZ(T const &angleY, T const &angleZ)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z).
glm::eulerAngleYX
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleYX(T const &angleY, T const &angleX)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X).
glm::extractEulerAngleXYZ
GLM_FUNC_DECL void extractEulerAngleXYZ(tmat4x4< T, defaultp > &M, T &t1, T &t2, T &t3)
Extracts the (X * Y * Z) Euler angles from the rotation matrix M.
glm::eulerAngleXY
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleXY(T const &angleX, T const &angleY)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y).
glm::eulerAngleZY
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleZY(T const &angleZ, T const &angleY)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y).
glm::orientate3
GLM_FUNC_DECL tmat3x3< T, P > orientate3(tvec3< T, P > const &angles)
Creates a 3D 3 * 3 rotation matrix from euler angles (Y * X * Z).
glm::orientate2
GLM_FUNC_DECL tmat2x2< T, defaultp > orientate2(T const &angle)
Creates a 2D 2 * 2 rotation matrix from an euler angle.
glm
Definition: _noise.hpp:40
glm::eulerAngleZ
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleZ(T const &angleZ)
Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Z.
glm::yawPitchRoll
GLM_FUNC_DECL tmat4x4< T, defaultp > yawPitchRoll(T const &yaw, T const &pitch, T const &roll)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
glm::eulerAngleX
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleX(T const &angleX)
Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X.
glm::angle
GLM_FUNC_DECL T angle(tquat< T, P > const &x)
Returns the quaternion rotation angle.
glm::eulerAngleXZ
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleXZ(T const &angleX, T const &angleZ)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z).
glm::yaw
GLM_FUNC_DECL T yaw(tquat< T, P > const &x)
Returns yaw value of euler angles expressed in radians.
glm::eulerAngleY
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleY(T const &angleY)
Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Y.
glm::eulerAngleXYZ
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleXYZ(T const &t1, T const &t2, T const &t3)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y * Z).
glm::eulerAngleYXZ
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleYXZ(T const &yaw, T const &pitch, T const &roll)
Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
glm::roll
GLM_FUNC_DECL T roll(tquat< T, P > const &x)
Returns roll value of euler angles expressed in radians.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00022.html000066400000000000000000000102051356361734700216340ustar00rootroot00000000000000 0.9.7: exponential.hpp File Reference
exponential.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-12-24 / 2013-12-24
Author
Christophe Riccio

Definition in file exponential.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00022_source.html000066400000000000000000000062751356361734700232300ustar00rootroot00000000000000 0.9.7: exponential.hpp Source File
exponential.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "detail/func_exponential.hpp"
func_exponential.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00023_source.html000066400000000000000000000730171356361734700232270ustar00rootroot00000000000000 0.9.7: ext.hpp Source File
ext.hpp
1 
57 #pragma once
58 
59 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_EXT_INCLUDED_DISPLAYED))
60 # define GLM_MESSAGE_EXT_INCLUDED_DISPLAYED
61 # pragma message("GLM: All extensions included (not recommanded)")
62 #endif//GLM_MESSAGES
63 
64 #include "./gtc/bitfield.hpp"
65 #include "./gtc/constants.hpp"
66 #include "./gtc/epsilon.hpp"
67 #include "./gtc/integer.hpp"
68 #include "./gtc/matrix_access.hpp"
69 #include "./gtc/matrix_integer.hpp"
70 #include "./gtc/matrix_inverse.hpp"
71 #include "./gtc/matrix_transform.hpp"
72 #include "./gtc/noise.hpp"
73 #include "./gtc/packing.hpp"
74 #include "./gtc/quaternion.hpp"
75 #include "./gtc/random.hpp"
76 #include "./gtc/reciprocal.hpp"
77 #include "./gtc/round.hpp"
78 #include "./gtc/type_precision.hpp"
79 #include "./gtc/type_ptr.hpp"
80 #include "./gtc/ulp.hpp"
81 #include "./gtc/vec1.hpp"
82 
83 #include "./gtx/associated_min_max.hpp"
84 #include "./gtx/bit.hpp"
85 #include "./gtx/closest_point.hpp"
86 #include "./gtx/color_space.hpp"
87 #include "./gtx/color_space_YCoCg.hpp"
88 #include "./gtx/compatibility.hpp"
89 #include "./gtx/component_wise.hpp"
90 #include "./gtx/dual_quaternion.hpp"
91 #include "./gtx/euler_angles.hpp"
92 #include "./gtx/extend.hpp"
93 #include "./gtx/extented_min_max.hpp"
94 #include "./gtx/fast_exponential.hpp"
95 #include "./gtx/fast_square_root.hpp"
96 #include "./gtx/fast_trigonometry.hpp"
97 #include "./gtx/gradient_paint.hpp"
98 #include "./gtx/handed_coordinate_space.hpp"
99 #include "./gtx/integer.hpp"
100 #include "./gtx/intersect.hpp"
101 #include "./gtx/log_base.hpp"
102 #include "./gtx/matrix_cross_product.hpp"
103 #include "./gtx/matrix_interpolation.hpp"
104 #include "./gtx/matrix_major_storage.hpp"
105 #include "./gtx/matrix_operation.hpp"
106 #include "./gtx/matrix_query.hpp"
107 #include "./gtx/mixed_product.hpp"
108 #include "./gtx/norm.hpp"
109 #include "./gtx/normal.hpp"
110 #include "./gtx/normalize_dot.hpp"
111 #include "./gtx/number_precision.hpp"
112 #include "./gtx/optimum_pow.hpp"
113 #include "./gtx/orthonormalize.hpp"
114 #include "./gtx/perpendicular.hpp"
115 #include "./gtx/polar_coordinates.hpp"
116 #include "./gtx/projection.hpp"
117 #include "./gtx/quaternion.hpp"
118 #include "./gtx/raw_data.hpp"
119 #include "./gtx/rotate_vector.hpp"
120 #include "./gtx/spline.hpp"
121 #include "./gtx/std_based_type.hpp"
122 #if !(GLM_COMPILER & GLM_COMPILER_CUDA)
123 # include "./gtx/string_cast.hpp"
124 #endif
125 #include "./gtx/transform.hpp"
126 #include "./gtx/transform2.hpp"
127 #include "./gtx/type_aligned.hpp"
128 #include "./gtx/vector_angle.hpp"
129 #include "./gtx/vector_query.hpp"
130 #include "./gtx/wrap.hpp"
131 
132 #if GLM_HAS_TEMPLATE_ALIASES
133 # include "./gtx/scalar_multiplication.hpp"
134 #endif
135 
136 #if GLM_HAS_RANGE_FOR
137 # include "./gtx/range.hpp"
138 #endif
139 
140 #if GLM_ARCH & GLM_ARCH_SSE2
141 # include "./gtx/simd_vec4.hpp"
142 # include "./gtx/simd_mat4.hpp"
143 #endif
extend.hpp
OpenGL Mathematics (glm.g-truc.net)
closest_point.hpp
OpenGL Mathematics (glm.g-truc.net)
projection.hpp
OpenGL Mathematics (glm.g-truc.net)
std_based_type.hpp
OpenGL Mathematics (glm.g-truc.net)
matrix_access.hpp
OpenGL Mathematics (glm.g-truc.net)
polar_coordinates.hpp
OpenGL Mathematics (glm.g-truc.net)
log_base.hpp
OpenGL Mathematics (glm.g-truc.net)
fast_square_root.hpp
OpenGL Mathematics (glm.g-truc.net)
integer.hpp
OpenGL Mathematics (glm.g-truc.net)
type_aligned.hpp
OpenGL Mathematics (glm.g-truc.net)
handed_coordinate_space.hpp
OpenGL Mathematics (glm.g-truc.net)
vector_angle.hpp
OpenGL Mathematics (glm.g-truc.net)
scalar_multiplication.hpp
OpenGL Mathematics (glm.g-truc.net)
type_precision.hpp
OpenGL Mathematics (glm.g-truc.net)
rotate_vector.hpp
OpenGL Mathematics (glm.g-truc.net)
matrix_query.hpp
OpenGL Mathematics (glm.g-truc.net)
intersect.hpp
OpenGL Mathematics (glm.g-truc.net)
euler_angles.hpp
OpenGL Mathematics (glm.g-truc.net)
mixed_product.hpp
OpenGL Mathematics (glm.g-truc.net)
random.hpp
OpenGL Mathematics (glm.g-truc.net)
number_precision.hpp
OpenGL Mathematics (glm.g-truc.net)
normal.hpp
OpenGL Mathematics (glm.g-truc.net)
constants.hpp
OpenGL Mathematics (glm.g-truc.net)
vector_query.hpp
OpenGL Mathematics (glm.g-truc.net)
gradient_paint.hpp
OpenGL Mathematics (glm.g-truc.net)
reciprocal.hpp
OpenGL Mathematics (glm.g-truc.net)
simd_mat4.hpp
OpenGL Mathematics (glm.g-truc.net)
packing.hpp
OpenGL Mathematics (glm.g-truc.net)
matrix_operation.hpp
OpenGL Mathematics (glm.g-truc.net)
bitfield.hpp
OpenGL Mathematics (glm.g-truc.net)
vec1.hpp
OpenGL Mathematics (glm.g-truc.net)
perpendicular.hpp
OpenGL Mathematics (glm.g-truc.net)
spline.hpp
OpenGL Mathematics (glm.g-truc.net)
fast_exponential.hpp
OpenGL Mathematics (glm.g-truc.net)
color_space.hpp
OpenGL Mathematics (glm.g-truc.net)
quaternion.hpp
OpenGL Mathematics (glm.g-truc.net)
transform.hpp
OpenGL Mathematics (glm.g-truc.net)
normalize_dot.hpp
OpenGL Mathematics (glm.g-truc.net)
norm.hpp
OpenGL Mathematics (glm.g-truc.net)
component_wise.hpp
OpenGL Mathematics (glm.g-truc.net)
epsilon.hpp
OpenGL Mathematics (glm.g-truc.net)
ulp.hpp
OpenGL Mathematics (glm.g-truc.net)
extented_min_max.hpp
OpenGL Mathematics (glm.g-truc.net)
color_space_YCoCg.hpp
OpenGL Mathematics (glm.g-truc.net)
transform2.hpp
OpenGL Mathematics (glm.g-truc.net)
raw_data.hpp
OpenGL Mathematics (glm.g-truc.net)
string_cast.hpp
OpenGL Mathematics (glm.g-truc.net)
matrix_cross_product.hpp
OpenGL Mathematics (glm.g-truc.net)
orthonormalize.hpp
OpenGL Mathematics (glm.g-truc.net)
matrix_major_storage.hpp
OpenGL Mathematics (glm.g-truc.net)
integer.hpp
OpenGL Mathematics (glm.g-truc.net)
wrap.hpp
OpenGL Mathematics (glm.g-truc.net)
matrix_interpolation.hpp
OpenGL Mathematics (glm.g-truc.net)
bit.hpp
OpenGL Mathematics (glm.g-truc.net)
simd_vec4.hpp
OpenGL Mathematics (glm.g-truc.net)
type_ptr.hpp
OpenGL Mathematics (glm.g-truc.net)
matrix_transform.hpp
OpenGL Mathematics (glm.g-truc.net)
quaternion.hpp
OpenGL Mathematics (glm.g-truc.net)
fast_trigonometry.hpp
OpenGL Mathematics (glm.g-truc.net)
noise.hpp
OpenGL Mathematics (glm.g-truc.net)
compatibility.hpp
OpenGL Mathematics (glm.g-truc.net)
range.hpp
OpenGL Mathematics (glm.g-truc.net)
optimum_pow.hpp
OpenGL Mathematics (glm.g-truc.net)
round.hpp
OpenGL Mathematics (glm.g-truc.net)
matrix_inverse.hpp
OpenGL Mathematics (glm.g-truc.net)
dual_quaternion.hpp
OpenGL Mathematics (glm.g-truc.net)
matrix_integer.hpp
OpenGL Mathematics (glm.g-truc.net)
associated_min_max.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00024.html000066400000000000000000000124071356361734700216440ustar00rootroot00000000000000 0.9.7: extend.hpp File Reference
Functions
extend.hpp File Reference

Go to the source code of this file.

Functions

template<typename genType >
GLM_FUNC_DECL genType extend (genType const &Origin, genType const &Source, typename genType::value_type const Length)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_extend

Date
2006-01-07 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file extend.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00024_source.html000066400000000000000000000141151356361734700232220ustar00rootroot00000000000000 0.9.7: extend.hpp Source File
extend.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../glm.hpp"
46 
47 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
48 # pragma message("GLM: GLM_GTX_extend extension included")
49 #endif
50 
51 namespace glm
52 {
55 
58  template <typename genType>
59  GLM_FUNC_DECL genType extend(
60  genType const & Origin,
61  genType const & Source,
62  typename genType::value_type const Length);
63 
65 }//namespace glm
66 
67 #include "extend.inl"
glm
Definition: _noise.hpp:40
glm::extend
GLM_FUNC_DECL genType extend(genType const &Origin, genType const &Source, typename genType::value_type const Length)
Extends of Length the Origin position using the (Source - Origin) direction.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00025.html000066400000000000000000000303001356361734700216350ustar00rootroot00000000000000 0.9.7: extented_min_max.hpp File Reference
Functions
extented_min_max.hpp File Reference

Go to the source code of this file.

Functions

template<typename T >
GLM_FUNC_DECL T max (T const &x, T const &y, T const &z)
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > max (C< T > const &x, typename C< T >::T const &y, typename C< T >::T const &z)
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > max (C< T > const &x, C< T > const &y, C< T > const &z)
 
template<typename T >
GLM_FUNC_DECL T max (T const &x, T const &y, T const &z, T const &w)
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > max (C< T > const &x, typename C< T >::T const &y, typename C< T >::T const &z, typename C< T >::T const &w)
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > max (C< T > const &x, C< T > const &y, C< T > const &z, C< T > const &w)
 
template<typename T >
GLM_FUNC_DECL T min (T const &x, T const &y, T const &z)
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > min (C< T > const &x, typename C< T >::T const &y, typename C< T >::T const &z)
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > min (C< T > const &x, C< T > const &y, C< T > const &z)
 
template<typename T >
GLM_FUNC_DECL T min (T const &x, T const &y, T const &z, T const &w)
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > min (C< T > const &x, typename C< T >::T const &y, typename C< T >::T const &z, typename C< T >::T const &w)
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > min (C< T > const &x, C< T > const &y, C< T > const &z, C< T > const &w)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_extented_min_max

Date
2007-03-14 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)
gtx_half_float (dependence)

Definition in file extented_min_max.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00025_source.html000066400000000000000000000450211356361734700232230ustar00rootroot00000000000000 0.9.7: extented_min_max.hpp Source File
extented_min_max.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependency:
46 #include "../glm.hpp"
47 
48 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
49 # pragma message("GLM: GLM_GTX_extented_min_max extension included")
50 #endif
51 
52 namespace glm
53 {
56 
59  template <typename T>
60  GLM_FUNC_DECL T min(
61  T const & x,
62  T const & y,
63  T const & z);
64 
67  template <typename T, template <typename> class C>
68  GLM_FUNC_DECL C<T> min(
69  C<T> const & x,
70  typename C<T>::T const & y,
71  typename C<T>::T const & z);
72 
75  template <typename T, template <typename> class C>
76  GLM_FUNC_DECL C<T> min(
77  C<T> const & x,
78  C<T> const & y,
79  C<T> const & z);
80 
83  template <typename T>
84  GLM_FUNC_DECL T min(
85  T const & x,
86  T const & y,
87  T const & z,
88  T const & w);
89 
92  template <typename T, template <typename> class C>
93  GLM_FUNC_DECL C<T> min(
94  C<T> const & x,
95  typename C<T>::T const & y,
96  typename C<T>::T const & z,
97  typename C<T>::T const & w);
98 
101  template <typename T, template <typename> class C>
102  GLM_FUNC_DECL C<T> min(
103  C<T> const & x,
104  C<T> const & y,
105  C<T> const & z,
106  C<T> const & w);
107 
110  template <typename T>
111  GLM_FUNC_DECL T max(
112  T const & x,
113  T const & y,
114  T const & z);
115 
118  template <typename T, template <typename> class C>
119  GLM_FUNC_DECL C<T> max(
120  C<T> const & x,
121  typename C<T>::T const & y,
122  typename C<T>::T const & z);
123 
126  template <typename T, template <typename> class C>
127  GLM_FUNC_DECL C<T> max(
128  C<T> const & x,
129  C<T> const & y,
130  C<T> const & z);
131 
134  template <typename T>
135  GLM_FUNC_DECL T max(
136  T const & x,
137  T const & y,
138  T const & z,
139  T const & w);
140 
143  template <typename T, template <typename> class C>
144  GLM_FUNC_DECL C<T> max(
145  C<T> const & x,
146  typename C<T>::T const & y,
147  typename C<T>::T const & z,
148  typename C<T>::T const & w);
149 
152  template <typename T, template <typename> class C>
153  GLM_FUNC_DECL C<T> max(
154  C<T> const & x,
155  C<T> const & y,
156  C<T> const & z,
157  C<T> const & w);
158 
160 }//namespace glm
161 
162 #include "extented_min_max.inl"
glm::max
GLM_FUNC_DECL C< T > max(C< T > const &x, C< T > const &y, C< T > const &z, C< T > const &w)
Return the maximum component-wise values of 4 inputs.
glm::min
GLM_FUNC_DECL C< T > min(C< T > const &x, C< T > const &y, C< T > const &z, C< T > const &w)
Return the minimum component-wise values of 4 inputs.
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00026.html000066400000000000000000000272401356361734700216470ustar00rootroot00000000000000 0.9.7: fast_exponential.hpp File Reference
Functions
fast_exponential.hpp File Reference

Go to the source code of this file.

Functions

template<typename T >
GLM_FUNC_DECL T fastExp (T x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > fastExp (vecType< T, P > const &x)
 
template<typename T >
GLM_FUNC_DECL T fastExp2 (T x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > fastExp2 (vecType< T, P > const &x)
 
template<typename T >
GLM_FUNC_DECL T fastLog (T x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > fastLog (vecType< T, P > const &x)
 
template<typename T >
GLM_FUNC_DECL T fastLog2 (T x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > fastLog2 (vecType< T, P > const &x)
 
template<typename genType >
GLM_FUNC_DECL genType fastPow (genType x, genType y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > fastPow (vecType< T, P > const &x, vecType< T, P > const &y)
 
template<typename genTypeT , typename genTypeU >
GLM_FUNC_DECL genTypeT fastPow (genTypeT x, genTypeU y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > fastPow (vecType< T, P > const &x)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_fast_exponential

Date
2006-01-09 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)
gtx_half_float (dependence)

Definition in file fast_exponential.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00026_source.html000066400000000000000000000326251356361734700232320ustar00rootroot00000000000000 0.9.7: fast_exponential.hpp Source File
fast_exponential.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependency:
46 #include "../glm.hpp"
47 
48 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
49 # pragma message("GLM: GLM_GTX_fast_exponential extension included")
50 #endif
51 
52 namespace glm
53 {
56 
59  template <typename genType>
60  GLM_FUNC_DECL genType fastPow(genType x, genType y);
61 
64  template <typename T, precision P, template <typename, precision> class vecType>
65  GLM_FUNC_DECL vecType<T, P> fastPow(vecType<T, P> const & x, vecType<T, P> const & y);
66 
69  template <typename genTypeT, typename genTypeU>
70  GLM_FUNC_DECL genTypeT fastPow(genTypeT x, genTypeU y);
71 
74  template <typename T, precision P, template <typename, precision> class vecType>
75  GLM_FUNC_DECL vecType<T, P> fastPow(vecType<T, P> const & x);
76 
79  template <typename T>
80  GLM_FUNC_DECL T fastExp(T x);
81 
84  template <typename T, precision P, template <typename, precision> class vecType>
85  GLM_FUNC_DECL vecType<T, P> fastExp(vecType<T, P> const & x);
86 
89  template <typename T>
90  GLM_FUNC_DECL T fastLog(T x);
91 
94  template <typename T, precision P, template <typename, precision> class vecType>
95  GLM_FUNC_DECL vecType<T, P> fastLog(vecType<T, P> const & x);
96 
99  template <typename T>
100  GLM_FUNC_DECL T fastExp2(T x);
101 
104  template <typename T, precision P, template <typename, precision> class vecType>
105  GLM_FUNC_DECL vecType<T, P> fastExp2(vecType<T, P> const & x);
106 
109  template <typename T>
110  GLM_FUNC_DECL T fastLog2(T x);
111 
114  template <typename T, precision P, template <typename, precision> class vecType>
115  GLM_FUNC_DECL vecType<T, P> fastLog2(vecType<T, P> const & x);
116 
118 }//namespace glm
119 
120 #include "fast_exponential.inl"
glm::fastLog
GLM_FUNC_DECL vecType< T, P > fastLog(vecType< T, P > const &x)
Faster than the common exp2 function but less accurate.
glm::fastPow
GLM_FUNC_DECL vecType< T, P > fastPow(vecType< T, P > const &x)
Faster than the common pow function but less accurate.
glm
Definition: _noise.hpp:40
glm::fastExp
GLM_FUNC_DECL vecType< T, P > fastExp(vecType< T, P > const &x)
Faster than the common exp function but less accurate.
glm::fastLog2
GLM_FUNC_DECL vecType< T, P > fastLog2(vecType< T, P > const &x)
Faster than the common log2 function but less accurate.
glm::fastExp2
GLM_FUNC_DECL vecType< T, P > fastExp2(vecType< T, P > const &x)
Faster than the common exp2 function but less accurate.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00027.html000066400000000000000000000236101356361734700216450ustar00rootroot00000000000000 0.9.7: fast_square_root.hpp File Reference
Functions
fast_square_root.hpp File Reference

Go to the source code of this file.

Functions

template<typename genType >
GLM_FUNC_DECL genType fastDistance (genType x, genType y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL T fastDistance (vecType< T, P > const &x, vecType< T, P > const &y)
 
template<typename genType >
GLM_FUNC_DECL genType fastInverseSqrt (genType x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > fastInverseSqrt (vecType< T, P > const &x)
 
template<typename genType >
GLM_FUNC_DECL genType fastLength (genType x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL T fastLength (vecType< T, P > const &x)
 
template<typename genType >
GLM_FUNC_DECL genType fastNormalize (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL genType fastSqrt (genType x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > fastSqrt (vecType< T, P > const &x)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_fast_square_root

Date
2006-01-04 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file fast_square_root.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00027_source.html000066400000000000000000000277511356361734700232370ustar00rootroot00000000000000 0.9.7: fast_square_root.hpp Source File
fast_square_root.hpp
Go to the documentation of this file.
1 
44 #pragma once
45 
46 // Dependency:
47 #include "../common.hpp"
48 #include "../exponential.hpp"
49 #include "../geometric.hpp"
50 
51 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
52 # pragma message("GLM: GLM_GTX_fast_square_root extension included")
53 #endif
54 
55 namespace glm
56 {
59 
63  template <typename genType>
64  GLM_FUNC_DECL genType fastSqrt(genType x);
65 
69  template <typename T, precision P, template <typename, precision> class vecType>
70  GLM_FUNC_DECL vecType<T, P> fastSqrt(vecType<T, P> const & x);
71 
75  template <typename genType>
76  GLM_FUNC_DECL genType fastInverseSqrt(genType x);
77 
81  template <typename T, precision P, template <typename, precision> class vecType>
82  GLM_FUNC_DECL vecType<T, P> fastInverseSqrt(vecType<T, P> const & x);
83 
87  template <typename genType>
88  GLM_FUNC_DECL genType fastLength(genType x);
89 
93  template <typename T, precision P, template <typename, precision> class vecType>
94  GLM_FUNC_DECL T fastLength(vecType<T, P> const & x);
95 
99  template <typename genType>
100  GLM_FUNC_DECL genType fastDistance(genType x, genType y);
101 
105  template <typename T, precision P, template <typename, precision> class vecType>
106  GLM_FUNC_DECL T fastDistance(vecType<T, P> const & x, vecType<T, P> const & y);
107 
111  template <typename genType>
112  GLM_FUNC_DECL genType fastNormalize(genType const & x);
113 
115 }// namespace glm
116 
117 #include "fast_square_root.inl"
glm::fastSqrt
GLM_FUNC_DECL vecType< T, P > fastSqrt(vecType< T, P > const &x)
Faster than the common sqrt function but less accurate.
glm::fastLength
GLM_FUNC_DECL T fastLength(vecType< T, P > const &x)
Faster than the common length function but less accurate.
glm::fastDistance
GLM_FUNC_DECL T fastDistance(vecType< T, P > const &x, vecType< T, P > const &y)
Faster than the common distance function but less accurate.
glm::fastInverseSqrt
GLM_FUNC_DECL vecType< T, P > fastInverseSqrt(vecType< T, P > const &x)
Faster than the common inversesqrt function but less accurate.
glm::fastNormalize
GLM_FUNC_DECL genType fastNormalize(genType const &x)
Faster than the common normalize function but less accurate.
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00028.html000066400000000000000000000215001356361734700216420ustar00rootroot00000000000000 0.9.7: fast_trigonometry.hpp File Reference
Functions
fast_trigonometry.hpp File Reference

Go to the source code of this file.

Functions

template<typename T >
GLM_FUNC_DECL T fastAcos (T angle)
 
template<typename T >
GLM_FUNC_DECL T fastAsin (T angle)
 
template<typename T >
GLM_FUNC_DECL T fastAtan (T y, T x)
 
template<typename T >
GLM_FUNC_DECL T fastAtan (T angle)
 
template<typename T >
GLM_FUNC_DECL T fastCos (T angle)
 
template<typename T >
GLM_FUNC_DECL T fastSin (T angle)
 
template<typename T >
GLM_FUNC_DECL T fastTan (T angle)
 
template<typename T >
GLM_FUNC_DECL T wrapAngle (T angle)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_fast_trigonometry

Date
2006-01-08 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file fast_trigonometry.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00028_source.html000066400000000000000000000265621356361734700232370ustar00rootroot00000000000000 0.9.7: fast_trigonometry.hpp Source File
fast_trigonometry.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../gtc/constants.hpp"
46 
47 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
48 # pragma message("GLM: GLM_GTX_fast_trigonometry extension included")
49 #endif
50 
51 namespace glm
52 {
55 
58  template <typename T>
59  GLM_FUNC_DECL T wrapAngle(T angle);
60 
63  template <typename T>
64  GLM_FUNC_DECL T fastSin(T angle);
65 
68  template <typename T>
69  GLM_FUNC_DECL T fastCos(T angle);
70 
74  template <typename T>
75  GLM_FUNC_DECL T fastTan(T angle);
76 
80  template <typename T>
81  GLM_FUNC_DECL T fastAsin(T angle);
82 
86  template <typename T>
87  GLM_FUNC_DECL T fastAcos(T angle);
88 
92  template <typename T>
93  GLM_FUNC_DECL T fastAtan(T y, T x);
94 
98  template <typename T>
99  GLM_FUNC_DECL T fastAtan(T angle);
100 
102 }//namespace glm
103 
104 #include "fast_trigonometry.inl"
glm::fastAtan
GLM_FUNC_DECL T fastAtan(T angle)
Faster than the common atan function but less accurate.
glm::fastAcos
GLM_FUNC_DECL T fastAcos(T angle)
Faster than the common acos function but less accurate.
glm
Definition: _noise.hpp:40
glm::fastCos
GLM_FUNC_DECL T fastCos(T angle)
Faster than the common cos function but less accurate.
glm::angle
GLM_FUNC_DECL T angle(tquat< T, P > const &x)
Returns the quaternion rotation angle.
glm::fastSin
GLM_FUNC_DECL T fastSin(T angle)
Faster than the common sin function but less accurate.
glm::wrapAngle
GLM_FUNC_DECL T wrapAngle(T angle)
Wrap an angle to [0 2pi[ From GLM_GTX_fast_trigonometry extension.
glm::fastAsin
GLM_FUNC_DECL T fastAsin(T angle)
Faster than the common asin function but less accurate.
glm::fastTan
GLM_FUNC_DECL T fastTan(T angle)
Faster than the common tan function but less accurate.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00029.html000066400000000000000000000571001356361734700216500ustar00rootroot00000000000000 0.9.7: func_common.hpp File Reference
Functions
func_common.hpp File Reference

Go to the source code of this file.

Functions

template<typename genType >
GLM_FUNC_DECL genType abs (genType x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > ceil (vecType< T, P > const &x)
 
template<typename genType >
GLM_FUNC_DECL genType clamp (genType x, genType minVal, genType maxVal)
 
GLM_FUNC_DECL int floatBitsToInt (float const &v)
 
template<template< typename, precision > class vecType, precision P>
GLM_FUNC_DECL vecType< int, P > floatBitsToInt (vecType< float, P > const &v)
 
GLM_FUNC_DECL uint floatBitsToUint (float const &v)
 
template<template< typename, precision > class vecType, precision P>
GLM_FUNC_DECL vecType< uint, P > floatBitsToUint (vecType< float, P > const &v)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > floor (vecType< T, P > const &x)
 
template<typename genType >
GLM_FUNC_DECL genType fma (genType const &a, genType const &b, genType const &c)
 
template<typename genType >
GLM_FUNC_DECL genType fract (genType x)
 
template<typename genType , typename genIType >
GLM_FUNC_DECL genType frexp (genType const &x, genIType &exp)
 
GLM_FUNC_DECL float intBitsToFloat (int const &v)
 
template<template< typename, precision > class vecType, precision P>
GLM_FUNC_DECL vecType< float, P > intBitsToFloat (vecType< int, P > const &v)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > isinf (vecType< T, P > const &x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > isnan (vecType< T, P > const &x)
 
template<typename genType , typename genIType >
GLM_FUNC_DECL genType ldexp (genType const &x, genIType const &exp)
 
template<typename genType >
GLM_FUNC_DECL genType max (genType x, genType y)
 
template<typename genType >
GLM_FUNC_DECL genType min (genType x, genType y)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > mix (vecType< T, P > const &x, vecType< T, P > const &y, vecType< U, P > const &a)
 
template<typename genType >
GLM_FUNC_DECL genType mod (genType x, genType y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > mod (vecType< T, P > const &x, T y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > mod (vecType< T, P > const &x, vecType< T, P > const &y)
 
template<typename genType >
GLM_FUNC_DECL genType modf (genType x, genType &i)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > round (vecType< T, P > const &x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > roundEven (vecType< T, P > const &x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > sign (vecType< T, P > const &x)
 
template<typename genType >
GLM_FUNC_DECL genType smoothstep (genType edge0, genType edge1, genType x)
 
template<typename genType >
GLM_FUNC_DECL genType step (genType edge, genType x)
 
template<template< typename, precision > class vecType, typename T , precision P>
GLM_FUNC_DECL vecType< T, P > step (T edge, vecType< T, P > const &x)
 
template<template< typename, precision > class vecType, typename T , precision P>
GLM_FUNC_DECL vecType< T, P > step (vecType< T, P > const &edge, vecType< T, P > const &x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > trunc (vecType< T, P > const &x)
 
GLM_FUNC_DECL float uintBitsToFloat (uint const &v)
 
template<template< typename, precision > class vecType, precision P>
GLM_FUNC_DECL vecType< float, P > uintBitsToFloat (vecType< uint, P > const &v)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2008-03-08 / 2010-01-26
Author
Christophe Riccio
See also
GLSL 4.20.8 specification, section 8.3 Common Functions

Definition in file func_common.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00029_source.html000066400000000000000000001263051356361734700232340ustar00rootroot00000000000000 0.9.7: func_common.hpp Source File
func_common.hpp
Go to the documentation of this file.
1 
40 #pragma once
41 
42 #include "setup.hpp"
43 #include "precision.hpp"
44 #include "type_int.hpp"
45 #include "_fixes.hpp"
46 
47 namespace glm
48 {
51 
58  template <typename genType>
59  GLM_FUNC_DECL genType abs(genType x);
60 
61  template <typename T, precision P, template <typename, precision> class vecType>
62  GLM_FUNC_DECL vecType<T, P> abs(vecType<T, P> const & x);
63 
70  template <typename T, precision P, template <typename, precision> class vecType>
71  GLM_FUNC_DECL vecType<T, P> sign(vecType<T, P> const & x);
72 
79  template <typename T, precision P, template <typename, precision> class vecType>
80  GLM_FUNC_DECL vecType<T, P> floor(vecType<T, P> const & x);
81 
89  template <typename T, precision P, template <typename, precision> class vecType>
90  GLM_FUNC_DECL vecType<T, P> trunc(vecType<T, P> const & x);
91 
102  template <typename T, precision P, template <typename, precision> class vecType>
103  GLM_FUNC_DECL vecType<T, P> round(vecType<T, P> const & x);
104 
114  template <typename T, precision P, template <typename, precision> class vecType>
115  GLM_FUNC_DECL vecType<T, P> roundEven(vecType<T, P> const & x);
116 
124  template <typename T, precision P, template <typename, precision> class vecType>
125  GLM_FUNC_DECL vecType<T, P> ceil(vecType<T, P> const & x);
126 
133  template <typename genType>
134  GLM_FUNC_DECL genType fract(genType x);
135 
136  template <typename T, precision P, template <typename, precision> class vecType>
137  GLM_FUNC_DECL vecType<T, P> fract(vecType<T, P> const & x);
138 
146  template <typename genType>
147  GLM_FUNC_DECL genType mod(genType x, genType y);
148 
149  template <typename T, precision P, template <typename, precision> class vecType>
150  GLM_FUNC_DECL vecType<T, P> mod(vecType<T, P> const & x, T y);
151 
152  template <typename T, precision P, template <typename, precision> class vecType>
153  GLM_FUNC_DECL vecType<T, P> mod(vecType<T, P> const & x, vecType<T, P> const & y);
154 
164  template <typename genType>
165  GLM_FUNC_DECL genType modf(genType x, genType & i);
166 
173  template <typename genType>
174  GLM_FUNC_DECL genType min(genType x, genType y);
175 
176  template <typename T, precision P, template <typename, precision> class vecType>
177  GLM_FUNC_DECL vecType<T, P> min(vecType<T, P> const & x, T y);
178 
179  template <typename T, precision P, template <typename, precision> class vecType>
180  GLM_FUNC_DECL vecType<T, P> min(vecType<T, P> const & x, vecType<T, P> const & y);
181 
188  template <typename genType>
189  GLM_FUNC_DECL genType max(genType x, genType y);
190 
191  template <typename T, precision P, template <typename, precision> class vecType>
192  GLM_FUNC_DECL vecType<T, P> max(vecType<T, P> const & x, T y);
193 
194  template <typename T, precision P, template <typename, precision> class vecType>
195  GLM_FUNC_DECL vecType<T, P> max(vecType<T, P> const & x, vecType<T, P> const & y);
196 
204  template <typename genType>
205  GLM_FUNC_DECL genType clamp(genType x, genType minVal, genType maxVal);
206 
207  template <typename T, precision P, template <typename, precision> class vecType>
208  GLM_FUNC_DECL vecType<T, P> clamp(vecType<T, P> const & x, T minVal, T maxVal);
209 
210  template <typename T, precision P, template <typename, precision> class vecType>
211  GLM_FUNC_DECL vecType<T, P> clamp(vecType<T, P> const & x, vecType<T, P> const & minVal, vecType<T, P> const & maxVal);
212 
255  template <typename T, typename U, precision P, template <typename, precision> class vecType>
256  GLM_FUNC_DECL vecType<T, P> mix(vecType<T, P> const & x, vecType<T, P> const & y, vecType<U, P> const & a);
257 
258  template <typename T, typename U, precision P, template <typename, precision> class vecType>
259  GLM_FUNC_DECL vecType<T, P> mix(vecType<T, P> const & x, vecType<T, P> const & y, U a);
260 
261  template <typename genTypeT, typename genTypeU>
262  GLM_FUNC_DECL genTypeT mix(genTypeT x, genTypeT y, genTypeU a);
263 
268  template <typename genType>
269  GLM_FUNC_DECL genType step(genType edge, genType x);
270 
275  template <template <typename, precision> class vecType, typename T, precision P>
276  GLM_FUNC_DECL vecType<T, P> step(T edge, vecType<T, P> const & x);
277 
282  template <template <typename, precision> class vecType, typename T, precision P>
283  GLM_FUNC_DECL vecType<T, P> step(vecType<T, P> const & edge, vecType<T, P> const & x);
284 
299  template <typename genType>
300  GLM_FUNC_DECL genType smoothstep(genType edge0, genType edge1, genType x);
301 
302  template <typename T, precision P, template <typename, precision> class vecType>
303  GLM_FUNC_DECL vecType<T, P> smoothstep(T edge0, T edge1, vecType<T, P> const & x);
304 
305  template <typename T, precision P, template <typename, precision> class vecType>
306  GLM_FUNC_DECL vecType<T, P> smoothstep(vecType<T, P> const & edge0, vecType<T, P> const & edge1, vecType<T, P> const & x);
307 
320  template <typename T, precision P, template <typename, precision> class vecType>
321  GLM_FUNC_DECL vecType<bool, P> isnan(vecType<T, P> const & x);
322 
333  template <typename T, precision P, template <typename, precision> class vecType>
334  GLM_FUNC_DECL vecType<bool, P> isinf(vecType<T, P> const & x);
335 
342  GLM_FUNC_DECL int floatBitsToInt(float const & v);
343 
350  template <template <typename, precision> class vecType, precision P>
351  GLM_FUNC_DECL vecType<int, P> floatBitsToInt(vecType<float, P> const & v);
352 
359  GLM_FUNC_DECL uint floatBitsToUint(float const & v);
360 
367  template <template <typename, precision> class vecType, precision P>
368  GLM_FUNC_DECL vecType<uint, P> floatBitsToUint(vecType<float, P> const & v);
369 
378  GLM_FUNC_DECL float intBitsToFloat(int const & v);
379 
388  template <template <typename, precision> class vecType, precision P>
389  GLM_FUNC_DECL vecType<float, P> intBitsToFloat(vecType<int, P> const & v);
390 
399  GLM_FUNC_DECL float uintBitsToFloat(uint const & v);
400 
409  template <template <typename, precision> class vecType, precision P>
410  GLM_FUNC_DECL vecType<float, P> uintBitsToFloat(vecType<uint, P> const & v);
411 
418  template <typename genType>
419  GLM_FUNC_DECL genType fma(genType const & a, genType const & b, genType const & c);
420 
435  template <typename genType, typename genIType>
436  GLM_FUNC_DECL genType frexp(genType const & x, genIType & exp);
437 
449  template <typename genType, typename genIType>
450  GLM_FUNC_DECL genType ldexp(genType const & x, genIType const & exp);
451 
453 }//namespace glm
454 
455 #include "func_common.inl"
456 
glm::clamp
GLM_FUNC_DECL genType clamp(genType x, genType minVal, genType maxVal)
Returns min(max(x, minVal), maxVal) for each component in x using the floating-point values minVal an...
glm::uintBitsToFloat
GLM_FUNC_DECL vecType< float, P > uintBitsToFloat(vecType< uint, P > const &v)
Returns a floating-point value corresponding to a unsigned integer encoding of a floating-point value...
glm::floatBitsToInt
GLM_FUNC_DECL vecType< int, P > floatBitsToInt(vecType< float, P > const &v)
Returns a signed integer value representing the encoding of a floating-point value.
glm::ldexp
GLM_FUNC_DECL genType ldexp(genType const &x, genIType const &exp)
Builds a floating-point number from x and the corresponding integral exponent of two in exp...
glm::fma
GLM_FUNC_DECL genType fma(genType const &a, genType const &b, genType const &c)
Computes and returns a * b + c.
glm::floor
GLM_FUNC_DECL vecType< T, P > floor(vecType< T, P > const &x)
Returns a value equal to the nearest integer that is less then or equal to x.
glm::isnan
GLM_FUNC_DECL vecType< bool, P > isnan(vecType< T, P > const &x)
Returns true if x holds a NaN (not a number) representation in the underlying implementation's set of...
glm::fract
GLM_FUNC_DECL genType fract(genType x)
Return x - floor(x).
glm::ceil
GLM_FUNC_DECL vecType< T, P > ceil(vecType< T, P > const &x)
Returns a value equal to the nearest integer that is greater than or equal to x.
glm::smoothstep
GLM_FUNC_DECL genType smoothstep(genType edge0, genType edge1, genType x)
Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and performs smooth Hermite interpolation between 0 a...
glm::trunc
GLM_FUNC_DECL vecType< T, P > trunc(vecType< T, P > const &x)
Returns a value equal to the nearest integer to x whose absolute value is not larger than the absolut...
glm::floatBitsToUint
GLM_FUNC_DECL vecType< uint, P > floatBitsToUint(vecType< float, P > const &v)
Returns a unsigned integer value representing the encoding of a floating-point value.
glm::round
GLM_FUNC_DECL vecType< T, P > round(vecType< T, P > const &x)
Returns a value equal to the nearest integer to x.
glm::uint
unsigned int uint
Unsigned integer type.
Definition: type_int.hpp:308
glm::roundEven
GLM_FUNC_DECL vecType< T, P > roundEven(vecType< T, P > const &x)
Returns a value equal to the nearest integer to x.
glm::frexp
GLM_FUNC_DECL genType frexp(genType const &x, genIType &exp)
Splits x into a floating-point significand in the range [0.5, 1.0) and an integral exponent of two...
glm
Definition: _noise.hpp:40
setup.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::sign
GLM_FUNC_DECL vecType< T, P > sign(vecType< T, P > const &x)
Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0.
glm::intBitsToFloat
GLM_FUNC_DECL vecType< float, P > intBitsToFloat(vecType< int, P > const &v)
Returns a floating-point value corresponding to a signed integer encoding of a floating-point value...
glm::max
GLM_FUNC_DECL genType max(genType x, genType y)
Returns y if x < y; otherwise, it returns x.
glm::mod
GLM_FUNC_DECL vecType< T, P > mod(vecType< T, P > const &x, vecType< T, P > const &y)
Modulus.
glm::step
GLM_FUNC_DECL vecType< T, P > step(vecType< T, P > const &edge, vecType< T, P > const &x)
Returns 0.0 if x < edge, otherwise it returns 1.0.
glm::abs
GLM_FUNC_DECL genType abs(genType x)
Returns x if x >= 0; otherwise, it returns -x.
glm::min
GLM_FUNC_DECL genType min(genType x, genType y)
Returns y if y < x; otherwise, it returns x.
glm::isinf
GLM_FUNC_DECL vecType< bool, P > isinf(vecType< T, P > const &x)
Returns true if x holds a positive infinity or negative infinity representation in the underlying imp...
glm::exp
GLM_FUNC_DECL vecType< T, P > exp(vecType< T, P > const &v)
Returns the natural exponentiation of x, i.e., e^x.
glm::mix
GLM_FUNC_DECL vecType< T, P > mix(vecType< T, P > const &x, vecType< T, P > const &y, vecType< U, P > const &a)
If genTypeU is a floating scalar or vector: Returns x * (1.0 - a) + y * a, i.e., the linear blend of ...
precision.hpp
OpenGL Mathematics (glm.g-truc.net)
_fixes.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::modf
GLM_FUNC_DECL genType modf(genType x, genType &i)
Returns the fractional part of x and sets i to the integer part (as a whole number floating point val...
type_int.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00030.html000066400000000000000000000220531356361734700216370ustar00rootroot00000000000000 0.9.7: func_exponential.hpp File Reference
Functions
func_exponential.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > exp (vecType< T, P > const &v)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > exp2 (vecType< T, P > const &v)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > inversesqrt (vecType< T, P > const &v)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > log (vecType< T, P > const &v)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > log2 (vecType< T, P > const &v)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > pow (vecType< T, P > const &base, vecType< T, P > const &exponent)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > sqrt (vecType< T, P > const &v)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2008-08-08 / 2011-06-14
Author
Christophe Riccio
See also
GLSL 4.20.8 specification, section 8.2 Exponential Functions

Definition in file func_exponential.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00030_source.html000066400000000000000000000320551356361734700232220ustar00rootroot00000000000000 0.9.7: func_exponential.hpp Source File
func_exponential.hpp
Go to the documentation of this file.
1 
40 #pragma once
41 
42 #include "type_vec1.hpp"
43 #include "type_vec2.hpp"
44 #include "type_vec3.hpp"
45 #include "type_vec4.hpp"
46 #include <cmath>
47 
48 namespace glm
49 {
52 
61  template <typename T, precision P, template <typename, precision> class vecType>
62  GLM_FUNC_DECL vecType<T, P> pow(vecType<T, P> const & base, vecType<T, P> const & exponent);
63 
71  template <typename T, precision P, template <typename, precision> class vecType>
72  GLM_FUNC_DECL vecType<T, P> exp(vecType<T, P> const & v);
73 
83  template <typename T, precision P, template <typename, precision> class vecType>
84  GLM_FUNC_DECL vecType<T, P> log(vecType<T, P> const & v);
85 
93  template <typename T, precision P, template <typename, precision> class vecType>
94  GLM_FUNC_DECL vecType<T, P> exp2(vecType<T, P> const & v);
95 
104  template <typename T, precision P, template <typename, precision> class vecType>
105  GLM_FUNC_DECL vecType<T, P> log2(vecType<T, P> const & v);
106 
114  //template <typename genType>
115  //GLM_FUNC_DECL genType sqrt(genType const & x);
116  template <typename T, precision P, template <typename, precision> class vecType>
117  GLM_FUNC_DECL vecType<T, P> sqrt(vecType<T, P> const & v);
118 
126  template <typename T, precision P, template <typename, precision> class vecType>
127  GLM_FUNC_DECL vecType<T, P> inversesqrt(vecType<T, P> const & v);
128 
130 }//namespace glm
131 
132 #include "func_exponential.inl"
glm::pow
GLM_FUNC_DECL vecType< T, P > pow(vecType< T, P > const &base, vecType< T, P > const &exponent)
Returns 'base' raised to the power 'exponent'.
glm::log
GLM_FUNC_DECL vecType< T, P > log(vecType< T, P > const &v)
Returns the natural logarithm of v, i.e., returns the value y which satisfies the equation x = e^y...
type_vec3.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::exp2
GLM_FUNC_DECL vecType< T, P > exp2(vecType< T, P > const &v)
Returns 2 raised to the v power.
glm
Definition: _noise.hpp:40
type_vec2.hpp
OpenGL Mathematics (glm.g-truc.net)
type_vec1.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::exp
GLM_FUNC_DECL vecType< T, P > exp(vecType< T, P > const &v)
Returns the natural exponentiation of x, i.e., e^x.
glm::inversesqrt
GLM_FUNC_DECL vecType< T, P > inversesqrt(vecType< T, P > const &v)
Returns the reciprocal of the positive square root of v.
glm::sqrt
GLM_FUNC_DECL vecType< T, P > sqrt(vecType< T, P > const &v)
Returns the positive square root of v.
glm::log2
GLM_FUNC_DECL vecType< T, P > log2(vecType< T, P > const &v)
Returns the base 2 log of x, i.e., returns the value y, which satisfies the equation x = 2 ^ y...
type_vec4.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00031.html000066400000000000000000000232611356361734700216420ustar00rootroot00000000000000 0.9.7: func_geometric.hpp File Reference
Functions
func_geometric.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > cross (tvec3< T, P > const &x, tvec3< T, P > const &y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL T distance (vecType< T, P > const &p0, vecType< T, P > const &p1)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL T dot (vecType< T, P > const &x, vecType< T, P > const &y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > faceforward (vecType< T, P > const &N, vecType< T, P > const &I, vecType< T, P > const &Nref)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL T length (vecType< T, P > const &x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > normalize (vecType< T, P > const &x)
 
template<typename genType >
GLM_FUNC_DECL genType reflect (genType const &I, genType const &N)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > refract (vecType< T, P > const &I, vecType< T, P > const &N, T eta)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2008-08-03 / 2011-06-14
Author
Christophe Riccio
See also
GLSL 4.20.8 specification, section 8.5 Geometric Functions

Definition in file func_geometric.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00031_source.html000066400000000000000000000344601356361734700232250ustar00rootroot00000000000000 0.9.7: func_geometric.hpp Source File
func_geometric.hpp
Go to the documentation of this file.
1 
40 #pragma once
41 
42 #include "type_vec3.hpp"
43 
44 namespace glm
45 {
48 
55  template <typename T, precision P, template <typename, precision> class vecType>
56  GLM_FUNC_DECL T length(
57  vecType<T, P> const & x);
58 
65  template <typename T, precision P, template <typename, precision> class vecType>
66  GLM_FUNC_DECL T distance(
67  vecType<T, P> const & p0,
68  vecType<T, P> const & p1);
69 
76  template <typename T, precision P, template <typename, precision> class vecType>
77  GLM_FUNC_DECL T dot(
78  vecType<T, P> const & x,
79  vecType<T, P> const & y);
80 
87  template <typename T, precision P>
88  GLM_FUNC_DECL tvec3<T, P> cross(
89  tvec3<T, P> const & x,
90  tvec3<T, P> const & y);
91 
97  template <typename T, precision P, template <typename, precision> class vecType>
98  GLM_FUNC_DECL vecType<T, P> normalize(
99  vecType<T, P> const & x);
100 
107  template <typename T, precision P, template <typename, precision> class vecType>
108  GLM_FUNC_DECL vecType<T, P> faceforward(
109  vecType<T, P> const & N,
110  vecType<T, P> const & I,
111  vecType<T, P> const & Nref);
112 
120  template <typename genType>
121  GLM_FUNC_DECL genType reflect(
122  genType const & I,
123  genType const & N);
124 
133  template <typename T, precision P, template <typename, precision> class vecType>
134  GLM_FUNC_DECL vecType<T, P> refract(
135  vecType<T, P> const & I,
136  vecType<T, P> const & N,
137  T eta);
138 
140 }//namespace glm
141 
142 #include "func_geometric.inl"
glm::distance
GLM_FUNC_DECL T distance(vecType< T, P > const &p0, vecType< T, P > const &p1)
Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
type_vec3.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::length
GLM_FUNC_DECL T length(vecType< T, P > const &x)
Returns the length of x, i.e., sqrt(x * x).
glm::refract
GLM_FUNC_DECL vecType< T, P > refract(vecType< T, P > const &I, vecType< T, P > const &N, T eta)
For the incident vector I and surface normal N, and the ratio of indices of refraction eta...
glm::normalize
GLM_FUNC_DECL vecType< T, P > normalize(vecType< T, P > const &x)
Returns a vector in the same direction as x but with length of 1.
glm
Definition: _noise.hpp:40
glm::reflect
GLM_FUNC_DECL genType reflect(genType const &I, genType const &N)
For the incident vector I and surface orientation N, returns the reflection direction : result = I - ...
glm::faceforward
GLM_FUNC_DECL vecType< T, P > faceforward(vecType< T, P > const &N, vecType< T, P > const &I, vecType< T, P > const &Nref)
If dot(Nref, I) < 0.0, return N, otherwise, return -N.
glm::dot
GLM_FUNC_DECL T dot(vecType< T, P > const &x, vecType< T, P > const &y)
Returns the dot product of x and y, i.e., result = x * y.
glm::cross
GLM_FUNC_DECL tvec3< T, P > cross(tvec3< T, P > const &x, tvec3< T, P > const &y)
Returns the cross product of x and y.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00032.html000066400000000000000000000316061356361734700216450ustar00rootroot00000000000000 0.9.7: func_integer.hpp File Reference
Functions
func_integer.hpp File Reference

Go to the source code of this file.

Functions

template<typename genType >
GLM_FUNC_DECL int bitCount (genType v)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< int, P > bitCount (vecType< T, P > const &v)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > bitfieldExtract (vecType< T, P > const &Value, int Offset, int Bits)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > bitfieldInsert (vecType< T, P > const &Base, vecType< T, P > const &Insert, int Offset, int Bits)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > bitfieldReverse (vecType< T, P > const &v)
 
template<typename genIUType >
GLM_FUNC_DECL int findLSB (genIUType x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< int, P > findLSB (vecType< T, P > const &v)
 
template<typename genIUType >
GLM_FUNC_DECL int findMSB (genIUType x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< int, P > findMSB (vecType< T, P > const &v)
 
template<precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL void imulExtended (vecType< int, P > const &x, vecType< int, P > const &y, vecType< int, P > &msb, vecType< int, P > &lsb)
 
template<precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< uint, P > uaddCarry (vecType< uint, P > const &x, vecType< uint, P > const &y, vecType< uint, P > &carry)
 
template<precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL void umulExtended (vecType< uint, P > const &x, vecType< uint, P > const &y, vecType< uint, P > &msb, vecType< uint, P > &lsb)
 
template<precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< uint, P > usubBorrow (vecType< uint, P > const &x, vecType< uint, P > const &y, vecType< uint, P > &borrow)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2010-03-17 / 2011-06-18
Author
Christophe Riccio
See also
GLSL 4.20.8 specification, section 8.8 Integer Functions

Definition in file func_integer.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00032_source.html000066400000000000000000000510301356361734700232160ustar00rootroot00000000000000 0.9.7: func_integer.hpp Source File
func_integer.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 #include "setup.hpp"
45 #include "precision.hpp"
46 #include "func_common.hpp"
47 #include "func_vector_relational.hpp"
48 
49 namespace glm
50 {
53 
62  template <precision P, template <typename, precision> class vecType>
63  GLM_FUNC_DECL vecType<uint, P> uaddCarry(
64  vecType<uint, P> const & x,
65  vecType<uint, P> const & y,
66  vecType<uint, P> & carry);
67 
76  template <precision P, template <typename, precision> class vecType>
77  GLM_FUNC_DECL vecType<uint, P> usubBorrow(
78  vecType<uint, P> const & x,
79  vecType<uint, P> const & y,
80  vecType<uint, P> & borrow);
81 
90  template <precision P, template <typename, precision> class vecType>
91  GLM_FUNC_DECL void umulExtended(
92  vecType<uint, P> const & x,
93  vecType<uint, P> const & y,
94  vecType<uint, P> & msb,
95  vecType<uint, P> & lsb);
96 
105  template <precision P, template <typename, precision> class vecType>
106  GLM_FUNC_DECL void imulExtended(
107  vecType<int, P> const & x,
108  vecType<int, P> const & y,
109  vecType<int, P> & msb,
110  vecType<int, P> & lsb);
111 
127  template <typename T, precision P, template <typename, precision> class vecType>
128  GLM_FUNC_DECL vecType<T, P> bitfieldExtract(
129  vecType<T, P> const & Value,
130  int Offset,
131  int Bits);
132 
147  template <typename T, precision P, template <typename, precision> class vecType>
148  GLM_FUNC_DECL vecType<T, P> bitfieldInsert(
149  vecType<T, P> const & Base,
150  vecType<T, P> const & Insert,
151  int Offset,
152  int Bits);
153 
162  template <typename T, precision P, template <typename, precision> class vecType>
163  GLM_FUNC_DECL vecType<T, P> bitfieldReverse(vecType<T, P> const & v);
164 
171  template <typename genType>
172  GLM_FUNC_DECL int bitCount(genType v);
173 
180  template <typename T, precision P, template <typename, precision> class vecType>
181  GLM_FUNC_DECL vecType<int, P> bitCount(vecType<T, P> const & v);
182 
191  template <typename genIUType>
192  GLM_FUNC_DECL int findLSB(genIUType x);
193 
202  template <typename T, precision P, template <typename, precision> class vecType>
203  GLM_FUNC_DECL vecType<int, P> findLSB(vecType<T, P> const & v);
204 
214  template <typename genIUType>
215  GLM_FUNC_DECL int findMSB(genIUType x);
216 
226  template <typename T, precision P, template <typename, precision> class vecType>
227  GLM_FUNC_DECL vecType<int, P> findMSB(vecType<T, P> const & v);
228 
230 }//namespace glm
231 
232 #include "func_integer.inl"
glm::bitfieldInsert
GLM_FUNC_DECL vecType< T, P > bitfieldInsert(vecType< T, P > const &Base, vecType< T, P > const &Insert, int Offset, int Bits)
Returns the insertion the bits least-significant bits of insert into base.
glm::usubBorrow
GLM_FUNC_DECL vecType< uint, P > usubBorrow(vecType< uint, P > const &x, vecType< uint, P > const &y, vecType< uint, P > &borrow)
Subtracts the 32-bit unsigned integer y from x, returning the difference if non-negative, or pow(2, 32) plus the difference otherwise.
glm::bitfieldExtract
GLM_FUNC_DECL vecType< T, P > bitfieldExtract(vecType< T, P > const &Value, int Offset, int Bits)
Extracts bits [offset, offset + bits - 1] from value, returning them in the least significant bits of...
glm::findLSB
GLM_FUNC_DECL vecType< int, P > findLSB(vecType< T, P > const &v)
Returns the bit number of the least significant bit set to 1 in the binary representation of value...
glm::findMSB
GLM_FUNC_DECL vecType< int, P > findMSB(vecType< T, P > const &v)
Returns the bit number of the most significant bit in the binary representation of value...
glm::bitfieldReverse
GLM_FUNC_DECL vecType< T, P > bitfieldReverse(vecType< T, P > const &v)
Returns the reversal of the bits of value.
glm::uaddCarry
GLM_FUNC_DECL vecType< uint, P > uaddCarry(vecType< uint, P > const &x, vecType< uint, P > const &y, vecType< uint, P > &carry)
Adds 32-bit unsigned integer x and y, returning the sum modulo pow(2, 32).
glm::umulExtended
GLM_FUNC_DECL void umulExtended(vecType< uint, P > const &x, vecType< uint, P > const &y, vecType< uint, P > &msb, vecType< uint, P > &lsb)
Multiplies 32-bit integers x and y, producing a 64-bit result.
glm::imulExtended
GLM_FUNC_DECL void imulExtended(vecType< int, P > const &x, vecType< int, P > const &y, vecType< int, P > &msb, vecType< int, P > &lsb)
Multiplies 32-bit integers x and y, producing a 64-bit result.
func_common.hpp
OpenGL Mathematics (glm.g-truc.net)
glm
Definition: _noise.hpp:40
setup.hpp
OpenGL Mathematics (glm.g-truc.net)
func_vector_relational.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::bitCount
GLM_FUNC_DECL vecType< int, P > bitCount(vecType< T, P > const &v)
Returns the number of bits set to 1 in the binary representation of value.
precision.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00033.html000066400000000000000000000164441356361734700216510ustar00rootroot00000000000000 0.9.7: func_matrix.hpp File Reference
Functions
func_matrix.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P, template< typename, precision > class matType>
GLM_FUNC_DECL T determinant (matType< T, P > const &m)
 
template<typename T , precision P, template< typename, precision > class matType>
GLM_FUNC_DECL matType< T, P > inverse (matType< T, P > const &m)
 
template<typename T , precision P, template< typename, precision > class matType>
GLM_FUNC_DECL matType< T, P > matrixCompMult (matType< T, P > const &x, matType< T, P > const &y)
 
template<typename T , precision P, template< typename, precision > class vecTypeA, template< typename, precision > class vecTypeB>
GLM_FUNC_DECL detail::outerProduct_trait< T, P, vecTypeA, vecTypeB >::type outerProduct (vecTypeA< T, P > const &c, vecTypeB< T, P > const &r)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2008-08-03 / 2011-06-15
Author
Christophe Riccio
See also
GLSL 4.20.8 specification, section 8.6 Matrix Functions

Definition in file func_matrix.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00033_source.html000066400000000000000000000464451356361734700232350ustar00rootroot00000000000000 0.9.7: func_matrix.hpp Source File
func_matrix.hpp
Go to the documentation of this file.
1 
44 #pragma once
45 
46 // Dependencies
47 #include "../detail/precision.hpp"
48 #include "../detail/setup.hpp"
49 #include "../detail/type_mat.hpp"
50 #include "../vec2.hpp"
51 #include "../vec3.hpp"
52 #include "../vec4.hpp"
53 #include "../mat2x2.hpp"
54 #include "../mat2x3.hpp"
55 #include "../mat2x4.hpp"
56 #include "../mat3x2.hpp"
57 #include "../mat3x3.hpp"
58 #include "../mat3x4.hpp"
59 #include "../mat4x2.hpp"
60 #include "../mat4x3.hpp"
61 #include "../mat4x4.hpp"
62 
63 namespace glm{
64 namespace detail
65 {
66  template <typename T, precision P>
67  struct outerProduct_trait<T, P, tvec2, tvec2>
68  {
69  typedef tmat2x2<T, P> type;
70  };
71 
72  template <typename T, precision P>
73  struct outerProduct_trait<T, P, tvec2, tvec3>
74  {
75  typedef tmat2x3<T, P> type;
76  };
77 
78  template <typename T, precision P>
79  struct outerProduct_trait<T, P, tvec2, tvec4>
80  {
81  typedef tmat2x4<T, P> type;
82  };
83 
84  template <typename T, precision P>
85  struct outerProduct_trait<T, P, tvec3, tvec2>
86  {
87  typedef tmat3x2<T, P> type;
88  };
89 
90  template <typename T, precision P>
91  struct outerProduct_trait<T, P, tvec3, tvec3>
92  {
93  typedef tmat3x3<T, P> type;
94  };
95 
96  template <typename T, precision P>
97  struct outerProduct_trait<T, P, tvec3, tvec4>
98  {
99  typedef tmat3x4<T, P> type;
100  };
101 
102  template <typename T, precision P>
103  struct outerProduct_trait<T, P, tvec4, tvec2>
104  {
105  typedef tmat4x2<T, P> type;
106  };
107 
108  template <typename T, precision P>
109  struct outerProduct_trait<T, P, tvec4, tvec3>
110  {
111  typedef tmat4x3<T, P> type;
112  };
113 
114  template <typename T, precision P>
115  struct outerProduct_trait<T, P, tvec4, tvec4>
116  {
117  typedef tmat4x4<T, P> type;
118  };
119 
120 }//namespace detail
121 
124 
132  template <typename T, precision P, template <typename, precision> class matType>
133  GLM_FUNC_DECL matType<T, P> matrixCompMult(matType<T, P> const & x, matType<T, P> const & y);
134 
143  template <typename T, precision P, template <typename, precision> class vecTypeA, template <typename, precision> class vecTypeB>
144  GLM_FUNC_DECL typename detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type outerProduct(vecTypeA<T, P> const & c, vecTypeB<T, P> const & r);
145 
152 # if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2012))
153  template <typename T, precision P, template <typename, precision> class matType>
154  GLM_FUNC_DECL typename matType<T, P>::transpose_type transpose(matType<T, P> const & x);
155 # endif
156 
163  template <typename T, precision P, template <typename, precision> class matType>
164  GLM_FUNC_DECL T determinant(matType<T, P> const & m);
165 
172  template <typename T, precision P, template <typename, precision> class matType>
173  GLM_FUNC_DECL matType<T, P> inverse(matType<T, P> const & m);
174 
176 }//namespace glm
177 
178 #include "func_matrix.inl"
glm::determinant
GLM_FUNC_DECL T determinant(matType< T, P > const &m)
Returns the transposed matrix of x.
glm
Definition: _noise.hpp:40
glm::inverse
GLM_FUNC_DECL matType< T, P > inverse(matType< T, P > const &m)
Return the inverse of a squared matrix.
glm::outerProduct
GLM_FUNC_DECL detail::outerProduct_trait< T, P, vecTypeA, vecTypeB >::type outerProduct(vecTypeA< T, P > const &c, vecTypeB< T, P > const &r)
Treats the first parameter c as a column vector and the second parameter r as a row vector and does a...
glm::matrixCompMult
GLM_FUNC_DECL matType< T, P > matrixCompMult(matType< T, P > const &x, matType< T, P > const &y)
Multiply matrix x by matrix y component-wise, i.e., result[i][j] is the scalar product of x[i][j] and...
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00034.html000066400000000000000000000156511356361734700216510ustar00rootroot00000000000000 0.9.7: func_noise.hpp File Reference
Functions
func_noise.hpp File Reference

Go to the source code of this file.

Functions

template<typename genType >
GLM_FUNC_DECL genType::value_type noise1 (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL tvec2< typename genType::value_type, defaultp > noise2 (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL tvec3< typename genType::value_type, defaultp > noise3 (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL tvec4< typename genType::value_type, defaultp > noise4 (genType const &x)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2008-08-01 / 2011-06-18
Author
Christophe Riccio
See also
GLSL 4.20.8 specification, section 8.13 Noise Functions

Definition in file func_noise.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00034_source.html000066400000000000000000000216151356361734700232260ustar00rootroot00000000000000 0.9.7: func_noise.hpp Source File
func_noise.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 #include "type_vec1.hpp"
45 #include "type_vec2.hpp"
46 #include "type_vec3.hpp"
47 #include "setup.hpp"
48 
49 namespace glm
50 {
53 
60  template <typename genType>
61  GLM_FUNC_DECL typename genType::value_type noise1(genType const & x);
62 
69  template <typename genType>
70  GLM_FUNC_DECL tvec2<typename genType::value_type, defaultp> noise2(genType const & x);
71 
78  template <typename genType>
79  GLM_FUNC_DECL tvec3<typename genType::value_type, defaultp> noise3(genType const & x);
80 
87  template <typename genType>
88  GLM_FUNC_DECL tvec4<typename genType::value_type, defaultp> noise4(genType const & x);
89 
91 }//namespace glm
92 
93 #include "func_noise.inl"
glm::noise4
GLM_FUNC_DECL tvec4< typename genType::value_type, defaultp > noise4(genType const &x)
Returns a 4D noise value based on the input value x.
type_vec3.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::noise2
GLM_FUNC_DECL tvec2< typename genType::value_type, defaultp > noise2(genType const &x)
Returns a 2D noise value based on the input value x.
glm
Definition: _noise.hpp:40
type_vec2.hpp
OpenGL Mathematics (glm.g-truc.net)
setup.hpp
OpenGL Mathematics (glm.g-truc.net)
type_vec1.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::noise1
GLM_FUNC_DECL genType::value_type noise1(genType const &x)
Returns a 1D noise value based on the input value x.
glm::noise3
GLM_FUNC_DECL tvec3< typename genType::value_type, defaultp > noise3(genType const &x)
Returns a 3D noise value based on the input value x.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00035.html000066400000000000000000000227361356361734700216540ustar00rootroot00000000000000 0.9.7: func_packing.hpp File Reference
Functions
func_packing.hpp File Reference

Go to the source code of this file.

Functions

GLM_FUNC_DECL double packDouble2x32 (uvec2 const &v)
 
GLM_FUNC_DECL uint packHalf2x16 (vec2 const &v)
 
GLM_FUNC_DECL uint packSnorm2x16 (vec2 const &v)
 
GLM_FUNC_DECL uint packSnorm4x8 (vec4 const &v)
 
GLM_FUNC_DECL uint packUnorm2x16 (vec2 const &v)
 
GLM_FUNC_DECL uint packUnorm4x8 (vec4 const &v)
 
GLM_FUNC_DECL uvec2 unpackDouble2x32 (double v)
 
GLM_FUNC_DECL vec2 unpackHalf2x16 (uint v)
 
GLM_FUNC_DECL vec2 unpackSnorm2x16 (uint p)
 
GLM_FUNC_DECL vec4 unpackSnorm4x8 (uint p)
 
GLM_FUNC_DECL vec2 unpackUnorm2x16 (uint p)
 
GLM_FUNC_DECL vec4 unpackUnorm4x8 (uint p)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2010-03-17 / 2011-06-15
Author
Christophe Riccio
See also
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_GTC_packing

Definition in file func_packing.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00035_source.html000066400000000000000000000400721356361734700232250ustar00rootroot00000000000000 0.9.7: func_packing.hpp Source File
func_packing.hpp
Go to the documentation of this file.
1 
41 #pragma once
42 
43 #include "type_vec2.hpp"
44 #include "type_vec4.hpp"
45 
46 namespace glm
47 {
50 
62  GLM_FUNC_DECL uint packUnorm2x16(vec2 const & v);
63 
75  GLM_FUNC_DECL uint packSnorm2x16(vec2 const & v);
76 
88  GLM_FUNC_DECL uint packUnorm4x8(vec4 const & v);
89 
101  GLM_FUNC_DECL uint packSnorm4x8(vec4 const & v);
102 
114  GLM_FUNC_DECL vec2 unpackUnorm2x16(uint p);
115 
127  GLM_FUNC_DECL vec2 unpackSnorm2x16(uint p);
128 
140  GLM_FUNC_DECL vec4 unpackUnorm4x8(uint p);
141 
153  GLM_FUNC_DECL vec4 unpackSnorm4x8(uint p);
154 
163  GLM_FUNC_DECL double packDouble2x32(uvec2 const & v);
164 
172  GLM_FUNC_DECL uvec2 unpackDouble2x32(double v);
173 
182  GLM_FUNC_DECL uint packHalf2x16(vec2 const & v);
183 
192  GLM_FUNC_DECL vec2 unpackHalf2x16(uint v);
193 
195 }//namespace glm
196 
197 #include "func_packing.inl"
glm::packHalf2x16
GLM_FUNC_DECL uint packHalf2x16(vec2 const &v)
Returns an unsigned integer obtained by converting the components of a two-component floating-point v...
glm::unpackUnorm2x16
GLM_FUNC_DECL vec2 unpackUnorm2x16(uint p)
First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.
glm::unpackUnorm4x8
GLM_FUNC_DECL vec4 unpackUnorm4x8(uint p)
First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.
glm::unpackDouble2x32
GLM_FUNC_DECL uvec2 unpackDouble2x32(double v)
Returns a two-component unsigned integer vector representation of v.
glm::packUnorm2x16
GLM_FUNC_DECL uint packUnorm2x16(vec2 const &v)
First, converts each component of the normalized floating-point value v into 8- or 16-bit integer val...
glm::packSnorm4x8
GLM_FUNC_DECL uint packSnorm4x8(vec4 const &v)
First, converts each component of the normalized floating-point value v into 8- or 16-bit integer val...
glm::vec2
highp_vec2 vec2
2 components vector of floating-point numbers.
Definition: type_vec.hpp:390
glm::uvec2
highp_uvec2 uvec2
2 components vector of unsigned integer numbers.
Definition: type_vec.hpp:471
glm::packSnorm2x16
GLM_FUNC_DECL uint packSnorm2x16(vec2 const &v)
First, converts each component of the normalized floating-point value v into 8- or 16-bit integer val...
glm::unpackSnorm2x16
GLM_FUNC_DECL vec2 unpackSnorm2x16(uint p)
First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.
glm::uint
unsigned int uint
Unsigned integer type.
Definition: type_int.hpp:308
glm::packUnorm4x8
GLM_FUNC_DECL uint packUnorm4x8(vec4 const &v)
First, converts each component of the normalized floating-point value v into 8- or 16-bit integer val...
glm
Definition: _noise.hpp:40
glm::packDouble2x32
GLM_FUNC_DECL double packDouble2x32(uvec2 const &v)
Returns a double-precision value obtained by packing the components of v into a 64-bit value...
type_vec2.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::vec4
highp_vec4 vec4
4 components vector of floating-point numbers.
Definition: type_vec.hpp:400
glm::unpackSnorm4x8
GLM_FUNC_DECL vec4 unpackSnorm4x8(uint p)
First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.
glm::unpackHalf2x16
GLM_FUNC_DECL vec2 unpackHalf2x16(uint v)
Returns a two-component floating-point vector with components obtained by unpacking a 32-bit unsigned...
type_vec4.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00036.html000066400000000000000000000341071356361734700216500ustar00rootroot00000000000000 0.9.7: func_trigonometric.hpp File Reference
Functions
func_trigonometric.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > acos (vecType< T, P > const &x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > acosh (vecType< T, P > const &x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > asin (vecType< T, P > const &x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > asinh (vecType< T, P > const &x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > atan (vecType< T, P > const &y, vecType< T, P > const &x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > atan (vecType< T, P > const &y_over_x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > atanh (vecType< T, P > const &x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > cos (vecType< T, P > const &angle)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > cosh (vecType< T, P > const &angle)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > degrees (vecType< T, P > const &radians)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > radians (vecType< T, P > const &degrees)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > sin (vecType< T, P > const &angle)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > sinh (vecType< T, P > const &angle)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > tan (vecType< T, P > const &angle)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > tanh (vecType< T, P > const &angle)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2008-08-01 / 2011-06-15
Author
Christophe Riccio
See also
GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions

Definition in file func_trigonometric.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00036_source.html000066400000000000000000000506121356361734700232270ustar00rootroot00000000000000 0.9.7: func_trigonometric.hpp Source File
func_trigonometric.hpp
Go to the documentation of this file.
1 
44 #pragma once
45 
46 #include "setup.hpp"
47 #include "precision.hpp"
48 
49 namespace glm
50 {
53 
60  template <typename T, precision P, template <typename, precision> class vecType>
61  GLM_FUNC_DECL vecType<T, P> radians(vecType<T, P> const & degrees);
62 
69  template <typename T, precision P, template <typename, precision> class vecType>
70  GLM_FUNC_DECL vecType<T, P> degrees(vecType<T, P> const & radians);
71 
79  template <typename T, precision P, template <typename, precision> class vecType>
80  GLM_FUNC_DECL vecType<T, P> sin(vecType<T, P> const & angle);
81 
89  template <typename T, precision P, template <typename, precision> class vecType>
90  GLM_FUNC_DECL vecType<T, P> cos(vecType<T, P> const & angle);
91 
98  template <typename T, precision P, template <typename, precision> class vecType>
99  GLM_FUNC_DECL vecType<T, P> tan(vecType<T, P> const & angle);
100 
109  template <typename T, precision P, template <typename, precision> class vecType>
110  GLM_FUNC_DECL vecType<T, P> asin(vecType<T, P> const & x);
111 
120  template <typename T, precision P, template <typename, precision> class vecType>
121  GLM_FUNC_DECL vecType<T, P> acos(vecType<T, P> const & x);
122 
133  template <typename T, precision P, template <typename, precision> class vecType>
134  GLM_FUNC_DECL vecType<T, P> atan(vecType<T, P> const & y, vecType<T, P> const & x);
135 
143  template <typename T, precision P, template <typename, precision> class vecType>
144  GLM_FUNC_DECL vecType<T, P> atan(vecType<T, P> const & y_over_x);
145 
152  template <typename T, precision P, template <typename, precision> class vecType>
153  GLM_FUNC_DECL vecType<T, P> sinh(vecType<T, P> const & angle);
154 
161  template <typename T, precision P, template <typename, precision> class vecType>
162  GLM_FUNC_DECL vecType<T, P> cosh(vecType<T, P> const & angle);
163 
170  template <typename T, precision P, template <typename, precision> class vecType>
171  GLM_FUNC_DECL vecType<T, P> tanh(vecType<T, P> const & angle);
172 
179  template <typename T, precision P, template <typename, precision> class vecType>
180  GLM_FUNC_DECL vecType<T, P> asinh(vecType<T, P> const & x);
181 
189  template <typename T, precision P, template <typename, precision> class vecType>
190  GLM_FUNC_DECL vecType<T, P> acosh(vecType<T, P> const & x);
191 
199  template <typename T, precision P, template <typename, precision> class vecType>
200  GLM_FUNC_DECL vecType<T, P> atanh(vecType<T, P> const & x);
201 
203 }//namespace glm
204 
205 #include "func_trigonometric.inl"
glm::atan
GLM_FUNC_DECL vecType< T, P > atan(vecType< T, P > const &y_over_x)
Arc tangent.
glm::acos
GLM_FUNC_DECL vecType< T, P > acos(vecType< T, P > const &x)
Arc cosine.
glm::tanh
GLM_FUNC_DECL vecType< T, P > tanh(vecType< T, P > const &angle)
Returns the hyperbolic tangent function, sinh(angle) / cosh(angle)
glm::cosh
GLM_FUNC_DECL vecType< T, P > cosh(vecType< T, P > const &angle)
Returns the hyperbolic cosine function, (exp(x) + exp(-x)) / 2.
glm::asinh
GLM_FUNC_DECL vecType< T, P > asinh(vecType< T, P > const &x)
Arc hyperbolic sine; returns the inverse of sinh.
glm::radians
GLM_FUNC_DECL vecType< T, P > radians(vecType< T, P > const &degrees)
Converts degrees to radians and returns the result.
glm::cos
GLM_FUNC_DECL vecType< T, P > cos(vecType< T, P > const &angle)
The standard trigonometric cosine function.
glm::sin
GLM_FUNC_DECL vecType< T, P > sin(vecType< T, P > const &angle)
The standard trigonometric sine function.
glm::sinh
GLM_FUNC_DECL vecType< T, P > sinh(vecType< T, P > const &angle)
Returns the hyperbolic sine function, (exp(x) - exp(-x)) / 2.
glm::degrees
GLM_FUNC_DECL vecType< T, P > degrees(vecType< T, P > const &radians)
Converts radians to degrees and returns the result.
glm::tan
GLM_FUNC_DECL vecType< T, P > tan(vecType< T, P > const &angle)
The standard trigonometric tangent function.
glm
Definition: _noise.hpp:40
setup.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::angle
GLM_FUNC_DECL T angle(tquat< T, P > const &x)
Returns the quaternion rotation angle.
glm::acosh
GLM_FUNC_DECL vecType< T, P > acosh(vecType< T, P > const &x)
Arc hyperbolic cosine; returns the non-negative inverse of cosh.
precision.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::asin
GLM_FUNC_DECL vecType< T, P > asin(vecType< T, P > const &x)
Arc sine.
glm::atanh
GLM_FUNC_DECL vecType< T, P > atanh(vecType< T, P > const &x)
Arc hyperbolic tangent; returns the inverse of tanh.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00037.html000066400000000000000000000247331356361734700216550ustar00rootroot00000000000000 0.9.7: func_vector_relational.hpp File Reference
Functions
func_vector_relational.hpp File Reference

Go to the source code of this file.

Functions

template<precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL bool all (vecType< bool, P > const &v)
 
template<precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL bool any (vecType< bool, P > const &v)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > equal (vecType< T, P > const &x, vecType< T, P > const &y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > greaterThan (vecType< T, P > const &x, vecType< T, P > const &y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > greaterThanEqual (vecType< T, P > const &x, vecType< T, P > const &y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > lessThan (vecType< T, P > const &x, vecType< T, P > const &y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > lessThanEqual (vecType< T, P > const &x, vecType< T, P > const &y)
 
template<precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > not_ (vecType< bool, P > const &v)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > notEqual (vecType< T, P > const &x, vecType< T, P > const &y)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2008-08-03 / 2011-06-15
Author
Christophe Riccio
See also
GLSL 4.20.8 specification, section 8.7 Vector Relational Functions

Definition in file func_vector_relational.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00037_source.html000066400000000000000000000345331356361734700232340ustar00rootroot00000000000000 0.9.7: func_vector_relational.hpp Source File
func_vector_relational.hpp
Go to the documentation of this file.
1 
45 #pragma once
46 
47 #include "precision.hpp"
48 #include "setup.hpp"
49 
50 namespace glm
51 {
54 
61  template <typename T, precision P, template <typename, precision> class vecType>
62  GLM_FUNC_DECL vecType<bool, P> lessThan(vecType<T, P> const & x, vecType<T, P> const & y);
63 
70  template <typename T, precision P, template <typename, precision> class vecType>
71  GLM_FUNC_DECL vecType<bool, P> lessThanEqual(vecType<T, P> const & x, vecType<T, P> const & y);
72 
79  template <typename T, precision P, template <typename, precision> class vecType>
80  GLM_FUNC_DECL vecType<bool, P> greaterThan(vecType<T, P> const & x, vecType<T, P> const & y);
81 
88  template <typename T, precision P, template <typename, precision> class vecType>
89  GLM_FUNC_DECL vecType<bool, P> greaterThanEqual(vecType<T, P> const & x, vecType<T, P> const & y);
90 
97  template <typename T, precision P, template <typename, precision> class vecType>
98  GLM_FUNC_DECL vecType<bool, P> equal(vecType<T, P> const & x, vecType<T, P> const & y);
99 
106  template <typename T, precision P, template <typename, precision> class vecType>
107  GLM_FUNC_DECL vecType<bool, P> notEqual(vecType<T, P> const & x, vecType<T, P> const & y);
108 
115  template <precision P, template <typename, precision> class vecType>
116  GLM_FUNC_DECL bool any(vecType<bool, P> const & v);
117 
124  template <precision P, template <typename, precision> class vecType>
125  GLM_FUNC_DECL bool all(vecType<bool, P> const & v);
126 
134  template <precision P, template <typename, precision> class vecType>
135  GLM_FUNC_DECL vecType<bool, P> not_(vecType<bool, P> const & v);
136 
138 }//namespace glm
139 
140 #include "func_vector_relational.inl"
glm::lessThan
GLM_FUNC_DECL vecType< bool, P > lessThan(vecType< T, P > const &x, vecType< T, P > const &y)
Returns the component-wise comparison result of x < y.
glm::greaterThanEqual
GLM_FUNC_DECL vecType< bool, P > greaterThanEqual(vecType< T, P > const &x, vecType< T, P > const &y)
Returns the component-wise comparison of result x >= y.
glm::greaterThan
GLM_FUNC_DECL vecType< bool, P > greaterThan(vecType< T, P > const &x, vecType< T, P > const &y)
Returns the component-wise comparison of result x > y.
glm::all
GLM_FUNC_DECL bool all(vecType< bool, P > const &v)
Returns true if all components of x are true.
glm
Definition: _noise.hpp:40
glm::lessThanEqual
GLM_FUNC_DECL vecType< bool, P > lessThanEqual(vecType< T, P > const &x, vecType< T, P > const &y)
Returns the component-wise comparison of result x <= y.
glm::equal
GLM_FUNC_DECL vecType< bool, P > equal(vecType< T, P > const &x, vecType< T, P > const &y)
Returns the component-wise comparison of result x == y.
setup.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::any
GLM_FUNC_DECL bool any(vecType< bool, P > const &v)
Returns true if any component of x is true.
glm::not_
GLM_FUNC_DECL vecType< bool, P > not_(vecType< bool, P > const &v)
Returns the component-wise logical complement of x.
precision.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::notEqual
GLM_FUNC_DECL vecType< bool, P > notEqual(vecType< T, P > const &x, vecType< T, P > const &y)
Returns the component-wise comparison of result x != y.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00038.html000066400000000000000000004763071356361734700216660ustar00rootroot00000000000000 0.9.7: fwd.hpp File Reference
Typedefs
fwd.hpp File Reference

Go to the source code of this file.

Typedefs

typedef highp_dquat dquat
 
typedef highp_float32_t f32
 
typedef f32mat2x2 f32mat2
 
typedef highp_f32mat2x2 f32mat2x2
 
typedef highp_f32mat2x3 f32mat2x3
 
typedef highp_f32mat2x4 f32mat2x4
 
typedef f32mat3x3 f32mat3
 
typedef highp_f32mat3x2 f32mat3x2
 
typedef highp_f32mat3x3 f32mat3x3
 
typedef highp_f32mat3x4 f32mat3x4
 
typedef f32mat4x4 f32mat4
 
typedef highp_f32mat4x2 f32mat4x2
 
typedef highp_f32mat4x3 f32mat4x3
 
typedef highp_f32mat4x4 f32mat4x4
 
typedef highp_f32quat f32quat
 
typedef highp_f32vec1 f32vec1
 
typedef highp_f32vec2 f32vec2
 
typedef highp_f32vec3 f32vec3
 
typedef highp_f32vec4 f32vec4
 
typedef highp_float64_t f64
 
typedef f64mat2x2 f64mat2
 
typedef highp_f64mat2x2 f64mat2x2
 
typedef highp_f64mat2x3 f64mat2x3
 
typedef highp_f64mat2x4 f64mat2x4
 
typedef f64mat3x3 f64mat3
 
typedef highp_f64mat3x2 f64mat3x2
 
typedef highp_f64mat3x3 f64mat3x3
 
typedef highp_f64mat3x4 f64mat3x4
 
typedef f64mat4x4 f64mat4
 
typedef highp_f64mat4x2 f64mat4x2
 
typedef highp_f64mat4x3 f64mat4x3
 
typedef highp_f64mat4x4 f64mat4x4
 
typedef highp_f64quat f64quat
 
typedef highp_f64vec1 f64vec1
 
typedef highp_f64vec2 f64vec2
 
typedef highp_f64vec3 f64vec3
 
typedef highp_f64vec4 f64vec4
 
typedef highp_float32_t float32_t
 
typedef highp_float64_t float64_t
 
typedef fmat2x2 fmat2
 
typedef highp_f32mat2x2 fmat2x2
 
typedef highp_f32mat2x3 fmat2x3
 
typedef highp_f32mat2x4 fmat2x4
 
typedef fmat3x3 fmat3
 
typedef highp_f32mat3x2 fmat3x2
 
typedef highp_f32mat3x3 fmat3x3
 
typedef highp_f32mat3x4 fmat3x4
 
typedef fmat4x4 fmat4
 
typedef highp_f32mat4x2 fmat4x2
 
typedef highp_f32mat4x3 fmat4x3
 
typedef highp_f32mat4x4 fmat4x4
 
typedef quat fquat
 
typedef highp_f32vec1 fvec1
 
typedef highp_f32vec2 fvec2
 
typedef highp_f32vec3 fvec3
 
typedef highp_f32vec4 fvec4
 
typedef tquat< double, highp > highp_dquat
 
typedef float32 highp_f32
 
typedef highp_f32mat2x2 highp_f32mat2
 
typedef tmat2x2< f32, highp > highp_f32mat2x2
 
typedef tmat2x3< f32, highp > highp_f32mat2x3
 
typedef tmat2x4< f32, highp > highp_f32mat2x4
 
typedef highp_f32mat3x3 highp_f32mat3
 
typedef tmat3x2< f32, highp > highp_f32mat3x2
 
typedef tmat3x3< f32, highp > highp_f32mat3x3
 
typedef tmat3x4< f32, highp > highp_f32mat3x4
 
typedef highp_f32mat4x4 highp_f32mat4
 
typedef tmat4x2< f32, highp > highp_f32mat4x2
 
typedef tmat4x3< f32, highp > highp_f32mat4x3
 
typedef tmat4x4< f32, highp > highp_f32mat4x4
 
typedef tquat< f32, highp > highp_f32quat
 
typedef tvec1< f32, highp > highp_f32vec1
 
typedef tvec2< f32, highp > highp_f32vec2
 
typedef tvec3< f32, highp > highp_f32vec3
 
typedef tvec4< f32, highp > highp_f32vec4
 
typedef float64 highp_f64
 
typedef highp_f64mat2x2 highp_f64mat2
 
typedef tmat2x2< f64, highp > highp_f64mat2x2
 
typedef tmat2x3< f64, highp > highp_f64mat2x3
 
typedef tmat2x4< f64, highp > highp_f64mat2x4
 
typedef highp_f64mat3x3 highp_f64mat3
 
typedef tmat3x2< f64, highp > highp_f64mat3x2
 
typedef tmat3x3< f64, highp > highp_f64mat3x3
 
typedef tmat3x4< f64, highp > highp_f64mat3x4
 
typedef highp_f64mat4x4 highp_f64mat4
 
typedef tmat4x2< f64, highp > highp_f64mat4x2
 
typedef tmat4x3< f64, highp > highp_f64mat4x3
 
typedef tmat4x4< f64, highp > highp_f64mat4x4
 
typedef tquat< f64, highp > highp_f64quat
 
typedef tvec1< f64, highp > highp_f64vec1
 
typedef tvec2< f64, highp > highp_f64vec2
 
typedef tvec3< f64, highp > highp_f64vec3
 
typedef tvec4< f64, highp > highp_f64vec4
 
typedef detail::float32 highp_float32
 
typedef detail::float32 highp_float32_t
 
typedef detail::float64 highp_float64
 
typedef detail::float64 highp_float64_t
 
typedef highp_fmat2x2 highp_fmat2
 
typedef tmat2x2< f32, highp > highp_fmat2x2
 
typedef tmat2x3< f32, highp > highp_fmat2x3
 
typedef tmat2x4< f32, highp > highp_fmat2x4
 
typedef highp_fmat3x3 highp_fmat3
 
typedef tmat3x2< f32, highp > highp_fmat3x2
 
typedef tmat3x3< f32, highp > highp_fmat3x3
 
typedef tmat3x4< f32, highp > highp_fmat3x4
 
typedef highp_fmat4x4 highp_fmat4
 
typedef tmat4x2< f32, highp > highp_fmat4x2
 
typedef tmat4x3< f32, highp > highp_fmat4x3
 
typedef tmat4x4< f32, highp > highp_fmat4x4
 
typedef highp_quat highp_fquat
 
typedef tvec1< float, highp > highp_fvec1
 
typedef tvec2< float, highp > highp_fvec2
 
typedef tvec3< float, highp > highp_fvec3
 
typedef tvec4< float, highp > highp_fvec4
 
typedef detail::int16 highp_i16
 
typedef tvec1< i16, highp > highp_i16vec1
 
typedef tvec2< i16, highp > highp_i16vec2
 
typedef tvec3< i16, highp > highp_i16vec3
 
typedef tvec4< i16, highp > highp_i16vec4
 
typedef detail::int32 highp_i32
 
typedef tvec1< i32, highp > highp_i32vec1
 
typedef tvec2< i32, highp > highp_i32vec2
 
typedef tvec3< i32, highp > highp_i32vec3
 
typedef tvec4< i32, highp > highp_i32vec4
 
typedef detail::int64 highp_i64
 
typedef tvec1< i64, highp > highp_i64vec1
 
typedef tvec2< i64, highp > highp_i64vec2
 
typedef tvec3< i64, highp > highp_i64vec3
 
typedef tvec4< i64, highp > highp_i64vec4
 
typedef detail::int8 highp_i8
 
typedef tvec1< i8, highp > highp_i8vec1
 
typedef tvec2< i8, highp > highp_i8vec2
 
typedef tvec3< i8, highp > highp_i8vec3
 
typedef tvec4< i8, highp > highp_i8vec4
 
typedef detail::int16 highp_int16
 
typedef detail::int16 highp_int16_t
 
typedef detail::int32 highp_int32
 
typedef detail::int32 highp_int32_t
 
typedef detail::int64 highp_int64
 
typedef detail::int64 highp_int64_t
 
typedef detail::int8 highp_int8
 
typedef detail::int8 highp_int8_t
 
typedef tquat< float, highp > highp_quat
 
typedef detail::uint16 highp_u16
 
typedef tvec1< u16, highp > highp_u16vec1
 
typedef tvec2< u16, highp > highp_u16vec2
 
typedef tvec3< u16, highp > highp_u16vec3
 
typedef tvec4< u16, highp > highp_u16vec4
 
typedef detail::uint32 highp_u32
 
typedef tvec1< u32, highp > highp_u32vec1
 
typedef tvec2< u32, highp > highp_u32vec2
 
typedef tvec3< u32, highp > highp_u32vec3
 
typedef tvec4< u32, highp > highp_u32vec4
 
typedef detail::uint64 highp_u64
 
typedef tvec1< u64, highp > highp_u64vec1
 
typedef tvec2< u64, highp > highp_u64vec2
 
typedef tvec3< u64, highp > highp_u64vec3
 
typedef tvec4< u64, highp > highp_u64vec4
 
typedef detail::uint8 highp_u8
 
typedef tvec1< u8, highp > highp_u8vec1
 
typedef tvec2< u8, highp > highp_u8vec2
 
typedef tvec3< u8, highp > highp_u8vec3
 
typedef tvec4< u8, highp > highp_u8vec4
 
typedef detail::uint16 highp_uint16
 
typedef detail::uint16 highp_uint16_t
 
typedef detail::uint32 highp_uint32
 
typedef detail::uint32 highp_uint32_t
 
typedef detail::uint64 highp_uint64
 
typedef detail::uint64 highp_uint64_t
 
typedef detail::uint8 highp_uint8
 
typedef detail::uint8 highp_uint8_t
 
typedef tvec1< float, highp > highp_vec1
 
typedef detail::int16 i16
 
typedef highp_i16vec1 i16vec1
 
typedef highp_i16vec2 i16vec2
 
typedef highp_i16vec3 i16vec3
 
typedef highp_i16vec4 i16vec4
 
typedef detail::int32 i32
 
typedef highp_i32vec1 i32vec1
 
typedef highp_i32vec2 i32vec2
 
typedef highp_i32vec3 i32vec3
 
typedef highp_i32vec4 i32vec4
 
typedef detail::int64 i64
 
typedef highp_i64vec1 i64vec1
 
typedef highp_i64vec2 i64vec2
 
typedef highp_i64vec3 i64vec3
 
typedef highp_i64vec4 i64vec4
 
typedef detail::int8 i8
 
typedef highp_i8vec1 i8vec1
 
typedef highp_i8vec2 i8vec2
 
typedef highp_i8vec3 i8vec3
 
typedef highp_i8vec4 i8vec4
 
typedef detail::int16 int16_t
 
typedef detail::int32 int32_t
 
typedef detail::int64 int64_t
 
typedef detail::int8 int8_t
 
typedef tquat< double, lowp > lowp_dquat
 
typedef float32 lowp_f32
 
typedef lowp_f32mat2x2 lowp_f32mat2
 
typedef tmat2x2< f32, lowp > lowp_f32mat2x2
 
typedef tmat2x3< f32, lowp > lowp_f32mat2x3
 
typedef tmat2x4< f32, lowp > lowp_f32mat2x4
 
typedef lowp_f32mat3x3 lowp_f32mat3
 
typedef tmat3x2< f32, lowp > lowp_f32mat3x2
 
typedef tmat3x3< f32, lowp > lowp_f32mat3x3
 
typedef tmat3x4< f32, lowp > lowp_f32mat3x4
 
typedef lowp_f32mat4x4 lowp_f32mat4
 
typedef tmat4x2< f32, lowp > lowp_f32mat4x2
 
typedef tmat4x3< f32, lowp > lowp_f32mat4x3
 
typedef tmat4x4< f32, lowp > lowp_f32mat4x4
 
typedef tquat< f32, lowp > lowp_f32quat
 
typedef tvec1< f32, lowp > lowp_f32vec1
 
typedef tvec2< f32, lowp > lowp_f32vec2
 
typedef tvec3< f32, lowp > lowp_f32vec3
 
typedef tvec4< f32, lowp > lowp_f32vec4
 
typedef float64 lowp_f64
 
typedef lowp_f64mat2x2 lowp_f64mat2
 
typedef tmat2x2< f64, lowp > lowp_f64mat2x2
 
typedef tmat2x3< f64, lowp > lowp_f64mat2x3
 
typedef tmat2x4< f64, lowp > lowp_f64mat2x4
 
typedef lowp_f64mat3x3 lowp_f64mat3
 
typedef tmat3x2< f64, lowp > lowp_f64mat3x2
 
typedef tmat3x3< f64, lowp > lowp_f64mat3x3
 
typedef tmat3x4< f64, lowp > lowp_f64mat3x4
 
typedef lowp_f64mat4x4 lowp_f64mat4
 
typedef tmat4x2< f64, lowp > lowp_f64mat4x2
 
typedef tmat4x3< f64, lowp > lowp_f64mat4x3
 
typedef tmat4x4< f64, lowp > lowp_f64mat4x4
 
typedef tquat< f64, lowp > lowp_f64quat
 
typedef tvec1< f64, lowp > lowp_f64vec1
 
typedef tvec2< f64, lowp > lowp_f64vec2
 
typedef tvec3< f64, lowp > lowp_f64vec3
 
typedef tvec4< f64, lowp > lowp_f64vec4
 
typedef detail::float32 lowp_float32
 
typedef detail::float32 lowp_float32_t
 
typedef detail::float64 lowp_float64
 
typedef detail::float64 lowp_float64_t
 
typedef lowp_fmat2x2 lowp_fmat2
 
typedef tmat2x2< f32, lowp > lowp_fmat2x2
 
typedef tmat2x3< f32, lowp > lowp_fmat2x3
 
typedef tmat2x4< f32, lowp > lowp_fmat2x4
 
typedef lowp_fmat3x3 lowp_fmat3
 
typedef tmat3x2< f32, lowp > lowp_fmat3x2
 
typedef tmat3x3< f32, lowp > lowp_fmat3x3
 
typedef tmat3x4< f32, lowp > lowp_fmat3x4
 
typedef lowp_fmat4x4 lowp_fmat4
 
typedef tmat4x2< f32, lowp > lowp_fmat4x2
 
typedef tmat4x3< f32, lowp > lowp_fmat4x3
 
typedef tmat4x4< f32, lowp > lowp_fmat4x4
 
typedef lowp_quat lowp_fquat
 
typedef tvec1< float, lowp > lowp_fvec1
 
typedef tvec2< float, lowp > lowp_fvec2
 
typedef tvec3< float, lowp > lowp_fvec3
 
typedef tvec4< float, lowp > lowp_fvec4
 
typedef detail::int16 lowp_i16
 
typedef tvec1< i16, lowp > lowp_i16vec1
 
typedef tvec2< i16, lowp > lowp_i16vec2
 
typedef tvec3< i16, lowp > lowp_i16vec3
 
typedef tvec4< i16, lowp > lowp_i16vec4
 
typedef detail::int32 lowp_i32
 
typedef tvec1< i32, lowp > lowp_i32vec1
 
typedef tvec2< i32, lowp > lowp_i32vec2
 
typedef tvec3< i32, lowp > lowp_i32vec3
 
typedef tvec4< i32, lowp > lowp_i32vec4
 
typedef detail::int64 lowp_i64
 
typedef tvec1< i64, lowp > lowp_i64vec1
 
typedef tvec2< i64, lowp > lowp_i64vec2
 
typedef tvec3< i64, lowp > lowp_i64vec3
 
typedef tvec4< i64, lowp > lowp_i64vec4
 
typedef detail::int8 lowp_i8
 
typedef tvec1< i8, lowp > lowp_i8vec1
 
typedef tvec2< i8, lowp > lowp_i8vec2
 
typedef tvec3< i8, lowp > lowp_i8vec3
 
typedef tvec4< i8, lowp > lowp_i8vec4
 
typedef detail::int16 lowp_int16
 
typedef detail::int16 lowp_int16_t
 
typedef detail::int32 lowp_int32
 
typedef detail::int32 lowp_int32_t
 
typedef detail::int64 lowp_int64
 
typedef detail::int64 lowp_int64_t
 
typedef detail::int8 lowp_int8
 
typedef detail::int8 lowp_int8_t
 
typedef tquat< float, lowp > lowp_quat
 
typedef detail::uint16 lowp_u16
 
typedef tvec1< u16, lowp > lowp_u16vec1
 
typedef tvec2< u16, lowp > lowp_u16vec2
 
typedef tvec3< u16, lowp > lowp_u16vec3
 
typedef tvec4< u16, lowp > lowp_u16vec4
 
typedef detail::uint32 lowp_u32
 
typedef tvec1< u32, lowp > lowp_u32vec1
 
typedef tvec2< u32, lowp > lowp_u32vec2
 
typedef tvec3< u32, lowp > lowp_u32vec3
 
typedef tvec4< u32, lowp > lowp_u32vec4
 
typedef detail::uint64 lowp_u64
 
typedef tvec1< u64, lowp > lowp_u64vec1
 
typedef tvec2< u64, lowp > lowp_u64vec2
 
typedef tvec3< u64, lowp > lowp_u64vec3
 
typedef tvec4< u64, lowp > lowp_u64vec4
 
typedef detail::uint8 lowp_u8
 
typedef tvec1< u8, lowp > lowp_u8vec1
 
typedef tvec2< u8, lowp > lowp_u8vec2
 
typedef tvec3< u8, lowp > lowp_u8vec3
 
typedef tvec4< u8, lowp > lowp_u8vec4
 
typedef detail::uint16 lowp_uint16
 
typedef detail::uint16 lowp_uint16_t
 
typedef detail::uint32 lowp_uint32
 
typedef detail::uint32 lowp_uint32_t
 
typedef detail::uint64 lowp_uint64
 
typedef detail::uint64 lowp_uint64_t
 
typedef detail::uint8 lowp_uint8
 
typedef detail::uint8 lowp_uint8_t
 
typedef tvec1< float, lowp > lowp_vec1
 
typedef tquat< double, mediump > mediump_dquat
 
typedef float32 mediump_f32
 
typedef mediump_f32mat2x2 mediump_f32mat2
 
typedef tmat2x2< f32, mediump > mediump_f32mat2x2
 
typedef tmat2x3< f32, mediump > mediump_f32mat2x3
 
typedef tmat2x4< f32, mediump > mediump_f32mat2x4
 
typedef mediump_f32mat3x3 mediump_f32mat3
 
typedef tmat3x2< f32, mediump > mediump_f32mat3x2
 
typedef tmat3x3< f32, mediump > mediump_f32mat3x3
 
typedef tmat3x4< f32, mediump > mediump_f32mat3x4
 
typedef mediump_f32mat4x4 mediump_f32mat4
 
typedef tmat4x2< f32, mediump > mediump_f32mat4x2
 
typedef tmat4x3< f32, mediump > mediump_f32mat4x3
 
typedef tmat4x4< f32, mediump > mediump_f32mat4x4
 
typedef tquat< f32, mediump > mediump_f32quat
 
typedef tvec1< f32, mediump > mediump_f32vec1
 
typedef tvec2< f32, mediump > mediump_f32vec2
 
typedef tvec3< f32, mediump > mediump_f32vec3
 
typedef tvec4< f32, mediump > mediump_f32vec4
 
typedef float64 mediump_f64
 
typedef mediump_f64mat2x2 mediump_f64mat2
 
typedef tmat2x2< f64, mediump > mediump_f64mat2x2
 
typedef tmat2x3< f64, mediump > mediump_f64mat2x3
 
typedef tmat2x4< f64, mediump > mediump_f64mat2x4
 
typedef mediump_f64mat3x3 mediump_f64mat3
 
typedef tmat3x2< f64, mediump > mediump_f64mat3x2
 
typedef tmat3x3< f64, mediump > mediump_f64mat3x3
 
typedef tmat3x4< f64, mediump > mediump_f64mat3x4
 
typedef mediump_f64mat4x4 mediump_f64mat4
 
typedef tmat4x2< f64, mediump > mediump_f64mat4x2
 
typedef tmat4x3< f64, mediump > mediump_f64mat4x3
 
typedef tmat4x4< f64, mediump > mediump_f64mat4x4
 
typedef tquat< f64, mediump > mediump_f64quat
 
typedef tvec1< f64, mediump > mediump_f64vec1
 
typedef tvec2< f64, mediump > mediump_f64vec2
 
typedef tvec3< f64, mediump > mediump_f64vec3
 
typedef tvec4< f64, mediump > mediump_f64vec4
 
typedef detail::float32 mediump_float32
 
typedef detail::float32 mediump_float32_t
 
typedef detail::float64 mediump_float64
 
typedef detail::float64 mediump_float64_t
 
typedef mediump_fmat2x2 mediump_fmat2
 
typedef tmat2x2< f32, mediump > mediump_fmat2x2
 
typedef tmat2x3< f32, mediump > mediump_fmat2x3
 
typedef tmat2x4< f32, mediump > mediump_fmat2x4
 
typedef mediump_fmat3x3 mediump_fmat3
 
typedef tmat3x2< f32, mediump > mediump_fmat3x2
 
typedef tmat3x3< f32, mediump > mediump_fmat3x3
 
typedef tmat3x4< f32, mediump > mediump_fmat3x4
 
typedef mediump_fmat4x4 mediump_fmat4
 
typedef tmat4x2< f32, mediump > mediump_fmat4x2
 
typedef tmat4x3< f32, mediump > mediump_fmat4x3
 
typedef tmat4x4< f32, mediump > mediump_fmat4x4
 
typedef mediump_quat mediump_fquat
 
typedef tvec1< float, mediump > mediump_fvec1
 
typedef tvec2< float, mediump > mediump_fvec2
 
typedef tvec3< float, mediump > mediump_fvec3
 
typedef tvec4< float, mediump > mediump_fvec4
 
typedef detail::int16 mediump_i16
 
typedef tvec1< i16, mediump > mediump_i16vec1
 
typedef tvec2< i16, mediump > mediump_i16vec2
 
typedef tvec3< i16, mediump > mediump_i16vec3
 
typedef tvec4< i16, mediump > mediump_i16vec4
 
typedef detail::int32 mediump_i32
 
typedef tvec1< i32, mediump > mediump_i32vec1
 
typedef tvec2< i32, mediump > mediump_i32vec2
 
typedef tvec3< i32, mediump > mediump_i32vec3
 
typedef tvec4< i32, mediump > mediump_i32vec4
 
typedef detail::int64 mediump_i64
 
typedef tvec1< i64, mediump > mediump_i64vec1
 
typedef tvec2< i64, mediump > mediump_i64vec2
 
typedef tvec3< i64, mediump > mediump_i64vec3
 
typedef tvec4< i64, mediump > mediump_i64vec4
 
typedef detail::int8 mediump_i8
 
typedef tvec1< i8, mediump > mediump_i8vec1
 
typedef tvec2< i8, mediump > mediump_i8vec2
 
typedef tvec3< i8, mediump > mediump_i8vec3
 
typedef tvec4< i8, mediump > mediump_i8vec4
 
typedef detail::int16 mediump_int16
 
typedef detail::int16 mediump_int16_t
 
typedef detail::int32 mediump_int32
 
typedef detail::int32 mediump_int32_t
 
typedef detail::int64 mediump_int64
 
typedef detail::int64 mediump_int64_t
 
typedef detail::int8 mediump_int8
 
typedef detail::int8 mediump_int8_t
 
typedef tquat< float, mediump > mediump_quat
 
typedef detail::uint16 mediump_u16
 
typedef tvec1< u16, mediump > mediump_u16vec1
 
typedef tvec2< u16, mediump > mediump_u16vec2
 
typedef tvec3< u16, mediump > mediump_u16vec3
 
typedef tvec4< u16, mediump > mediump_u16vec4
 
typedef detail::uint32 mediump_u32
 
typedef tvec1< u32, mediump > mediump_u32vec1
 
typedef tvec2< u32, mediump > mediump_u32vec2
 
typedef tvec3< u32, mediump > mediump_u32vec3
 
typedef tvec4< u32, mediump > mediump_u32vec4
 
typedef detail::uint64 mediump_u64
 
typedef tvec1< u64, mediump > mediump_u64vec1
 
typedef tvec2< u64, mediump > mediump_u64vec2
 
typedef tvec3< u64, mediump > mediump_u64vec3
 
typedef tvec4< u64, mediump > mediump_u64vec4
 
typedef detail::uint8 mediump_u8
 
typedef tvec1< u8, mediump > mediump_u8vec1
 
typedef tvec2< u8, mediump > mediump_u8vec2
 
typedef tvec3< u8, mediump > mediump_u8vec3
 
typedef tvec4< u8, mediump > mediump_u8vec4
 
typedef detail::uint16 mediump_uint16
 
typedef detail::uint16 mediump_uint16_t
 
typedef detail::uint32 mediump_uint32
 
typedef detail::uint32 mediump_uint32_t
 
typedef detail::uint64 mediump_uint64
 
typedef detail::uint64 mediump_uint64_t
 
typedef detail::uint8 mediump_uint8
 
typedef detail::uint8 mediump_uint8_t
 
typedef tvec1< float, mediump > mediump_vec1
 
typedef highp_quat quat
 
typedef detail::uint16 u16
 
typedef highp_u16vec1 u16vec1
 
typedef highp_u16vec2 u16vec2
 
typedef highp_u16vec3 u16vec3
 
typedef highp_u16vec4 u16vec4
 
typedef detail::uint32 u32
 
typedef highp_u32vec1 u32vec1
 
typedef highp_u32vec2 u32vec2
 
typedef highp_u32vec3 u32vec3
 
typedef highp_u32vec4 u32vec4
 
typedef detail::uint64 u64
 
typedef highp_u64vec1 u64vec1
 
typedef highp_u64vec2 u64vec2
 
typedef highp_u64vec3 u64vec3
 
typedef highp_u64vec4 u64vec4
 
typedef detail::uint8 u8
 
typedef highp_u8vec1 u8vec1
 
typedef highp_u8vec2 u8vec2
 
typedef highp_u8vec3 u8vec3
 
typedef highp_u8vec4 u8vec4
 
typedef detail::uint16 uint16_t
 
typedef detail::uint32 uint32_t
 
typedef detail::uint64 uint64_t
 
typedef detail::uint8 uint8_t
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-03-30 / 2013-03-31
Author
Christophe Riccio

Definition in file fwd.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00038_source.html000066400000000000000000011473661356361734700232470ustar00rootroot00000000000000 0.9.7: fwd.hpp Source File
fwd.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "detail/type_int.hpp"
36 #include "detail/type_float.hpp"
37 #include "detail/type_vec.hpp"
38 #include "detail/type_mat.hpp"
39 
41 // GLM_GTC_quaternion
42 namespace glm
43 {
44  template <typename T, precision P> struct tquat;
45 
49  typedef tquat<float, lowp> lowp_quat;
50 
54  typedef tquat<float, mediump> mediump_quat;
55 
59  typedef tquat<float, highp> highp_quat;
60 
61 #if(defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
62  typedef highp_quat quat;
63 #elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
64  typedef mediump_quat quat;
65 #elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && defined(GLM_PRECISION_LOWP_FLOAT))
66  typedef lowp_quat quat;
67 #elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
68  typedef highp_quat quat;
70 #endif
71 
75  typedef lowp_quat lowp_fquat;
76 
80  typedef mediump_quat mediump_fquat;
81 
85  typedef highp_quat highp_fquat;
86 
90  typedef quat fquat;
91 
92 
96  typedef tquat<double, lowp> lowp_dquat;
97 
101  typedef tquat<double, mediump> mediump_dquat;
102 
106  typedef tquat<double, highp> highp_dquat;
107 
108 #if(defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE))
109  typedef highp_dquat dquat;
110 #elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE))
111  typedef mediump_dquat dquat;
112 #elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && defined(GLM_PRECISION_LOWP_DOUBLE))
113  typedef lowp_dquat dquat;
114 #elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE))
115  typedef highp_dquat dquat;
119 #endif
120 
121 }//namespace glm
122 
124 // GLM_GTC_precision
125 namespace glm
126 {
129  typedef detail::int8 lowp_int8;
130 
133  typedef detail::int16 lowp_int16;
134 
137  typedef detail::int32 lowp_int32;
138 
141  typedef detail::int64 lowp_int64;
142 
145  typedef detail::int8 lowp_int8_t;
146 
149  typedef detail::int16 lowp_int16_t;
150 
153  typedef detail::int32 lowp_int32_t;
154 
157  typedef detail::int64 lowp_int64_t;
158 
161  typedef detail::int8 lowp_i8;
162 
165  typedef detail::int16 lowp_i16;
166 
169  typedef detail::int32 lowp_i32;
170 
173  typedef detail::int64 lowp_i64;
174 
177  typedef detail::int8 mediump_int8;
178 
181  typedef detail::int16 mediump_int16;
182 
185  typedef detail::int32 mediump_int32;
186 
189  typedef detail::int64 mediump_int64;
190 
193  typedef detail::int8 mediump_int8_t;
194 
197  typedef detail::int16 mediump_int16_t;
198 
201  typedef detail::int32 mediump_int32_t;
202 
205  typedef detail::int64 mediump_int64_t;
206 
209  typedef detail::int8 mediump_i8;
210 
213  typedef detail::int16 mediump_i16;
214 
217  typedef detail::int32 mediump_i32;
218 
221  typedef detail::int64 mediump_i64;
222 
225  typedef detail::int8 highp_int8;
226 
229  typedef detail::int16 highp_int16;
230 
233  typedef detail::int32 highp_int32;
234 
237  typedef detail::int64 highp_int64;
238 
241  typedef detail::int8 highp_int8_t;
242 
245  typedef detail::int16 highp_int16_t;
246 
249  typedef detail::int32 highp_int32_t;
250 
253  typedef detail::int64 highp_int64_t;
254 
257  typedef detail::int8 highp_i8;
258 
261  typedef detail::int16 highp_i16;
262 
265  typedef detail::int32 highp_i32;
266 
269  typedef detail::int64 highp_i64;
270 
271 
274  typedef detail::int8 int8;
275 
278  typedef detail::int16 int16;
279 
282  typedef detail::int32 int32;
283 
286  typedef detail::int64 int64;
287 
288 
289 #if GLM_HAS_EXTENDED_INTEGER_TYPE
290  using std::int8_t;
291  using std::int16_t;
292  using std::int32_t;
293  using std::int64_t;
294 #else
295  typedef detail::int8 int8_t;
298 
301  typedef detail::int16 int16_t;
302 
305  typedef detail::int32 int32_t;
306 
309  typedef detail::int64 int64_t;
310 #endif
311 
314  typedef detail::int8 i8;
315 
318  typedef detail::int16 i16;
319 
322  typedef detail::int32 i32;
323 
326  typedef detail::int64 i64;
327 
328 
329 
332  typedef tvec1<i8, lowp> lowp_i8vec1;
333 
336  typedef tvec2<i8, lowp> lowp_i8vec2;
337 
340  typedef tvec3<i8, lowp> lowp_i8vec3;
341 
344  typedef tvec4<i8, lowp> lowp_i8vec4;
345 
346 
349  typedef tvec1<i8, mediump> mediump_i8vec1;
350 
353  typedef tvec2<i8, mediump> mediump_i8vec2;
354 
357  typedef tvec3<i8, mediump> mediump_i8vec3;
358 
361  typedef tvec4<i8, mediump> mediump_i8vec4;
362 
363 
366  typedef tvec1<i8, highp> highp_i8vec1;
367 
370  typedef tvec2<i8, highp> highp_i8vec2;
371 
374  typedef tvec3<i8, highp> highp_i8vec3;
375 
378  typedef tvec4<i8, highp> highp_i8vec4;
379 
380 #if(defined(GLM_PRECISION_LOWP_INT))
381  typedef lowp_i8vec1 i8vec1;
382  typedef lowp_i8vec2 i8vec2;
383  typedef lowp_i8vec3 i8vec3;
384  typedef lowp_i8vec4 i8vec4;
385 #elif(defined(GLM_PRECISION_MEDIUMP_INT))
386  typedef mediump_i8vec1 i8vec1;
387  typedef mediump_i8vec2 i8vec2;
388  typedef mediump_i8vec3 i8vec3;
389  typedef mediump_i8vec4 i8vec4;
390 #else
391  typedef highp_i8vec1 i8vec1;
394 
397  typedef highp_i8vec2 i8vec2;
398 
401  typedef highp_i8vec3 i8vec3;
402 
405  typedef highp_i8vec4 i8vec4;
406 #endif
407 
408 
411  typedef tvec1<i16, lowp> lowp_i16vec1;
412 
415  typedef tvec2<i16, lowp> lowp_i16vec2;
416 
419  typedef tvec3<i16, lowp> lowp_i16vec3;
420 
423  typedef tvec4<i16, lowp> lowp_i16vec4;
424 
425 
428  typedef tvec1<i16, mediump> mediump_i16vec1;
429 
432  typedef tvec2<i16, mediump> mediump_i16vec2;
433 
436  typedef tvec3<i16, mediump> mediump_i16vec3;
437 
440  typedef tvec4<i16, mediump> mediump_i16vec4;
441 
442 
445  typedef tvec1<i16, highp> highp_i16vec1;
446 
449  typedef tvec2<i16, highp> highp_i16vec2;
450 
453  typedef tvec3<i16, highp> highp_i16vec3;
454 
457  typedef tvec4<i16, highp> highp_i16vec4;
458 
459 
460 #if(defined(GLM_PRECISION_LOWP_INT))
461  typedef lowp_i16vec1 i16vec1;
462  typedef lowp_i16vec2 i16vec2;
463  typedef lowp_i16vec3 i16vec3;
464  typedef lowp_i16vec4 i16vec4;
465 #elif(defined(GLM_PRECISION_MEDIUMP_INT))
466  typedef mediump_i16vec1 i16vec1;
467  typedef mediump_i16vec2 i16vec2;
468  typedef mediump_i16vec3 i16vec3;
469  typedef mediump_i16vec4 i16vec4;
470 #else
471  typedef highp_i16vec1 i16vec1;
474 
477  typedef highp_i16vec2 i16vec2;
478 
481  typedef highp_i16vec3 i16vec3;
482 
485  typedef highp_i16vec4 i16vec4;
486 #endif
487 
488 
491  typedef tvec1<i32, lowp> lowp_i32vec1;
492 
495  typedef tvec2<i32, lowp> lowp_i32vec2;
496 
499  typedef tvec3<i32, lowp> lowp_i32vec3;
500 
503  typedef tvec4<i32, lowp> lowp_i32vec4;
504 
505 
508  typedef tvec1<i32, mediump> mediump_i32vec1;
509 
512  typedef tvec2<i32, mediump> mediump_i32vec2;
513 
516  typedef tvec3<i32, mediump> mediump_i32vec3;
517 
520  typedef tvec4<i32, mediump> mediump_i32vec4;
521 
522 
525  typedef tvec1<i32, highp> highp_i32vec1;
526 
529  typedef tvec2<i32, highp> highp_i32vec2;
530 
533  typedef tvec3<i32, highp> highp_i32vec3;
534 
537  typedef tvec4<i32, highp> highp_i32vec4;
538 
539 #if(defined(GLM_PRECISION_LOWP_INT))
540  typedef lowp_i32vec1 i32vec1;
541  typedef lowp_i32vec2 i32vec2;
542  typedef lowp_i32vec3 i32vec3;
543  typedef lowp_i32vec4 i32vec4;
544 #elif(defined(GLM_PRECISION_MEDIUMP_INT))
545  typedef mediump_i32vec1 i32vec1;
546  typedef mediump_i32vec2 i32vec2;
547  typedef mediump_i32vec3 i32vec3;
548  typedef mediump_i32vec4 i32vec4;
549 #else
550  typedef highp_i32vec1 i32vec1;
553 
556  typedef highp_i32vec2 i32vec2;
557 
560  typedef highp_i32vec3 i32vec3;
561 
564  typedef highp_i32vec4 i32vec4;
565 #endif
566 
567 
570  typedef tvec1<i32, lowp> lowp_i32vec1;
571 
574  typedef tvec2<i32, lowp> lowp_i32vec2;
575 
578  typedef tvec3<i32, lowp> lowp_i32vec3;
579 
582  typedef tvec4<i32, lowp> lowp_i32vec4;
583 
584 
587  typedef tvec1<i32, mediump> mediump_i32vec1;
588 
591  typedef tvec2<i32, mediump> mediump_i32vec2;
592 
595  typedef tvec3<i32, mediump> mediump_i32vec3;
596 
599  typedef tvec4<i32, mediump> mediump_i32vec4;
600 
601 
604  typedef tvec1<i32, highp> highp_i32vec1;
605 
608  typedef tvec2<i32, highp> highp_i32vec2;
609 
612  typedef tvec3<i32, highp> highp_i32vec3;
613 
616  typedef tvec4<i32, highp> highp_i32vec4;
617 
618 #if(defined(GLM_PRECISION_LOWP_INT))
619  typedef lowp_i32vec1 i32vec1;
620  typedef lowp_i32vec2 i32vec2;
621  typedef lowp_i32vec3 i32vec3;
622  typedef lowp_i32vec4 i32vec4;
623 #elif(defined(GLM_PRECISION_MEDIUMP_INT))
624  typedef mediump_i32vec1 i32vec1;
625  typedef mediump_i32vec2 i32vec2;
626  typedef mediump_i32vec3 i32vec3;
627  typedef mediump_i32vec4 i32vec4;
628 #else
629  typedef highp_i32vec1 i32vec1;
632 
635  typedef highp_i32vec2 i32vec2;
636 
639  typedef highp_i32vec3 i32vec3;
640 
643  typedef highp_i32vec4 i32vec4;
644 #endif
645 
646 
647 
650  typedef tvec1<i64, lowp> lowp_i64vec1;
651 
654  typedef tvec2<i64, lowp> lowp_i64vec2;
655 
658  typedef tvec3<i64, lowp> lowp_i64vec3;
659 
662  typedef tvec4<i64, lowp> lowp_i64vec4;
663 
664 
667  typedef tvec1<i64, mediump> mediump_i64vec1;
668 
671  typedef tvec2<i64, mediump> mediump_i64vec2;
672 
675  typedef tvec3<i64, mediump> mediump_i64vec3;
676 
679  typedef tvec4<i64, mediump> mediump_i64vec4;
680 
681 
684  typedef tvec1<i64, highp> highp_i64vec1;
685 
688  typedef tvec2<i64, highp> highp_i64vec2;
689 
692  typedef tvec3<i64, highp> highp_i64vec3;
693 
696  typedef tvec4<i64, highp> highp_i64vec4;
697 
698 #if(defined(GLM_PRECISION_LOWP_INT))
699  typedef lowp_i64vec1 i64vec1;
700  typedef lowp_i64vec2 i64vec2;
701  typedef lowp_i64vec3 i64vec3;
702  typedef lowp_i64vec4 i64vec4;
703 #elif(defined(GLM_PRECISION_MEDIUMP_INT))
704  typedef mediump_i64vec1 i64vec1;
705  typedef mediump_i64vec2 i64vec2;
706  typedef mediump_i64vec3 i64vec3;
707  typedef mediump_i64vec4 i64vec4;
708 #else
709  typedef highp_i64vec1 i64vec1;
712 
715  typedef highp_i64vec2 i64vec2;
716 
719  typedef highp_i64vec3 i64vec3;
720 
723  typedef highp_i64vec4 i64vec4;
724 #endif
725 
726 
728  // Unsigned int vector types
729 
732  typedef detail::uint8 lowp_uint8;
733 
736  typedef detail::uint16 lowp_uint16;
737 
740  typedef detail::uint32 lowp_uint32;
741 
744  typedef detail::uint64 lowp_uint64;
745 
746 
749  typedef detail::uint8 lowp_uint8_t;
750 
753  typedef detail::uint16 lowp_uint16_t;
754 
757  typedef detail::uint32 lowp_uint32_t;
758 
761  typedef detail::uint64 lowp_uint64_t;
762 
763 
766  typedef detail::uint8 lowp_u8;
767 
770  typedef detail::uint16 lowp_u16;
771 
774  typedef detail::uint32 lowp_u32;
775 
778  typedef detail::uint64 lowp_u64;
779 
780 
781 
784  typedef detail::uint8 mediump_uint8;
785 
788  typedef detail::uint16 mediump_uint16;
789 
792  typedef detail::uint32 mediump_uint32;
793 
796  typedef detail::uint64 mediump_uint64;
797 
800  typedef detail::uint8 mediump_uint8_t;
801 
804  typedef detail::uint16 mediump_uint16_t;
805 
808  typedef detail::uint32 mediump_uint32_t;
809 
812  typedef detail::uint64 mediump_uint64_t;
813 
816  typedef detail::uint8 mediump_u8;
817 
820  typedef detail::uint16 mediump_u16;
821 
824  typedef detail::uint32 mediump_u32;
825 
828  typedef detail::uint64 mediump_u64;
829 
830 
831 
834  typedef detail::uint8 highp_uint8;
835 
838  typedef detail::uint16 highp_uint16;
839 
842  typedef detail::uint32 highp_uint32;
843 
846  typedef detail::uint64 highp_uint64;
847 
850  typedef detail::uint8 highp_uint8_t;
851 
854  typedef detail::uint16 highp_uint16_t;
855 
858  typedef detail::uint32 highp_uint32_t;
859 
862  typedef detail::uint64 highp_uint64_t;
863 
866  typedef detail::uint8 highp_u8;
867 
870  typedef detail::uint16 highp_u16;
871 
874  typedef detail::uint32 highp_u32;
875 
878  typedef detail::uint64 highp_u64;
879 
880 
881 
884  typedef detail::uint8 uint8;
885 
888  typedef detail::uint16 uint16;
889 
892  typedef detail::uint32 uint32;
893 
896  typedef detail::uint64 uint64;
897 
898 #if GLM_HAS_EXTENDED_INTEGER_TYPE
899  using std::uint8_t;
900  using std::uint16_t;
901  using std::uint32_t;
902  using std::uint64_t;
903 #else
904  typedef detail::uint8 uint8_t;
907 
910  typedef detail::uint16 uint16_t;
911 
914  typedef detail::uint32 uint32_t;
915 
918  typedef detail::uint64 uint64_t;
919 #endif
920 
923  typedef detail::uint8 u8;
924 
927  typedef detail::uint16 u16;
928 
931  typedef detail::uint32 u32;
932 
935  typedef detail::uint64 u64;
936 
937 
938 
941  typedef tvec1<u8, lowp> lowp_u8vec1;
942 
945  typedef tvec2<u8, lowp> lowp_u8vec2;
946 
949  typedef tvec3<u8, lowp> lowp_u8vec3;
950 
953  typedef tvec4<u8, lowp> lowp_u8vec4;
954 
955 
958  typedef tvec1<u8, mediump> mediump_u8vec1;
959 
962  typedef tvec2<u8, mediump> mediump_u8vec2;
963 
966  typedef tvec3<u8, mediump> mediump_u8vec3;
967 
970  typedef tvec4<u8, mediump> mediump_u8vec4;
971 
972 
975  typedef tvec1<u8, highp> highp_u8vec1;
976 
979  typedef tvec2<u8, highp> highp_u8vec2;
980 
983  typedef tvec3<u8, highp> highp_u8vec3;
984 
987  typedef tvec4<u8, highp> highp_u8vec4;
988 
989 #if(defined(GLM_PRECISION_LOWP_INT))
990  typedef lowp_u8vec1 u8vec1;
991  typedef lowp_u8vec2 u8vec2;
992  typedef lowp_u8vec3 u8vec3;
993  typedef lowp_u8vec4 u8vec4;
994 #elif(defined(GLM_PRECISION_MEDIUMP_INT))
995  typedef mediump_u8vec1 u8vec1;
996  typedef mediump_u8vec2 u8vec2;
997  typedef mediump_u8vec3 u8vec3;
998  typedef mediump_u8vec4 u8vec4;
999 #else
1000  typedef highp_u8vec1 u8vec1;
1003 
1006  typedef highp_u8vec2 u8vec2;
1007 
1010  typedef highp_u8vec3 u8vec3;
1011 
1014  typedef highp_u8vec4 u8vec4;
1015 #endif
1016 
1017 
1020  typedef tvec1<u16, lowp> lowp_u16vec1;
1021 
1024  typedef tvec2<u16, lowp> lowp_u16vec2;
1025 
1028  typedef tvec3<u16, lowp> lowp_u16vec3;
1029 
1032  typedef tvec4<u16, lowp> lowp_u16vec4;
1033 
1034 
1037  typedef tvec1<u16, mediump> mediump_u16vec1;
1038 
1041  typedef tvec2<u16, mediump> mediump_u16vec2;
1042 
1045  typedef tvec3<u16, mediump> mediump_u16vec3;
1046 
1049  typedef tvec4<u16, mediump> mediump_u16vec4;
1050 
1051 
1054  typedef tvec1<u16, highp> highp_u16vec1;
1055 
1058  typedef tvec2<u16, highp> highp_u16vec2;
1059 
1062  typedef tvec3<u16, highp> highp_u16vec3;
1063 
1066  typedef tvec4<u16, highp> highp_u16vec4;
1067 
1068 
1069 #if(defined(GLM_PRECISION_LOWP_INT))
1070  typedef lowp_u16vec1 u16vec1;
1071  typedef lowp_u16vec2 u16vec2;
1072  typedef lowp_u16vec3 u16vec3;
1073  typedef lowp_u16vec4 u16vec4;
1074 #elif(defined(GLM_PRECISION_MEDIUMP_INT))
1075  typedef mediump_u16vec1 u16vec1;
1076  typedef mediump_u16vec2 u16vec2;
1077  typedef mediump_u16vec3 u16vec3;
1078  typedef mediump_u16vec4 u16vec4;
1079 #else
1080  typedef highp_u16vec1 u16vec1;
1083 
1086  typedef highp_u16vec2 u16vec2;
1087 
1090  typedef highp_u16vec3 u16vec3;
1091 
1094  typedef highp_u16vec4 u16vec4;
1095 #endif
1096 
1097 
1100  typedef tvec1<u32, lowp> lowp_u32vec1;
1101 
1104  typedef tvec2<u32, lowp> lowp_u32vec2;
1105 
1108  typedef tvec3<u32, lowp> lowp_u32vec3;
1109 
1112  typedef tvec4<u32, lowp> lowp_u32vec4;
1113 
1114 
1117  typedef tvec1<u32, mediump> mediump_u32vec1;
1118 
1121  typedef tvec2<u32, mediump> mediump_u32vec2;
1122 
1125  typedef tvec3<u32, mediump> mediump_u32vec3;
1126 
1129  typedef tvec4<u32, mediump> mediump_u32vec4;
1130 
1131 
1134  typedef tvec1<u32, highp> highp_u32vec1;
1135 
1138  typedef tvec2<u32, highp> highp_u32vec2;
1139 
1142  typedef tvec3<u32, highp> highp_u32vec3;
1143 
1146  typedef tvec4<u32, highp> highp_u32vec4;
1147 
1148 #if(defined(GLM_PRECISION_LOWP_INT))
1149  typedef lowp_u32vec1 u32vec1;
1150  typedef lowp_u32vec2 u32vec2;
1151  typedef lowp_u32vec3 u32vec3;
1152  typedef lowp_u32vec4 u32vec4;
1153 #elif(defined(GLM_PRECISION_MEDIUMP_INT))
1154  typedef mediump_u32vec1 u32vec1;
1155  typedef mediump_u32vec2 u32vec2;
1156  typedef mediump_u32vec3 u32vec3;
1157  typedef mediump_u32vec4 u32vec4;
1158 #else
1159  typedef highp_u32vec1 u32vec1;
1162 
1165  typedef highp_u32vec2 u32vec2;
1166 
1169  typedef highp_u32vec3 u32vec3;
1170 
1173  typedef highp_u32vec4 u32vec4;
1174 #endif
1175 
1176 
1179  typedef tvec1<u32, lowp> lowp_u32vec1;
1180 
1183  typedef tvec2<u32, lowp> lowp_u32vec2;
1184 
1187  typedef tvec3<u32, lowp> lowp_u32vec3;
1188 
1191  typedef tvec4<u32, lowp> lowp_u32vec4;
1192 
1193 
1196  typedef tvec1<u32, mediump> mediump_u32vec1;
1197 
1200  typedef tvec2<u32, mediump> mediump_u32vec2;
1201 
1204  typedef tvec3<u32, mediump> mediump_u32vec3;
1205 
1208  typedef tvec4<u32, mediump> mediump_u32vec4;
1209 
1210 
1213  typedef tvec1<u32, highp> highp_u32vec1;
1214 
1217  typedef tvec2<u32, highp> highp_u32vec2;
1218 
1221  typedef tvec3<u32, highp> highp_u32vec3;
1222 
1225  typedef tvec4<u32, highp> highp_u32vec4;
1226 
1227 #if(defined(GLM_PRECISION_LOWP_INT))
1228  typedef lowp_u32vec1 u32vec1;
1229  typedef lowp_u32vec2 u32vec2;
1230  typedef lowp_u32vec3 u32vec3;
1231  typedef lowp_u32vec4 u32vec4;
1232 #elif(defined(GLM_PRECISION_MEDIUMP_INT))
1233  typedef mediump_u32vec1 u32vec1;
1234  typedef mediump_u32vec2 u32vec2;
1235  typedef mediump_u32vec3 u32vec3;
1236  typedef mediump_u32vec4 u32vec4;
1237 #else
1238  typedef highp_u32vec1 u32vec1;
1241 
1244  typedef highp_u32vec2 u32vec2;
1245 
1248  typedef highp_u32vec3 u32vec3;
1249 
1252  typedef highp_u32vec4 u32vec4;
1253 #endif
1254 
1255 
1256 
1259  typedef tvec1<u64, lowp> lowp_u64vec1;
1260 
1263  typedef tvec2<u64, lowp> lowp_u64vec2;
1264 
1267  typedef tvec3<u64, lowp> lowp_u64vec3;
1268 
1271  typedef tvec4<u64, lowp> lowp_u64vec4;
1272 
1273 
1276  typedef tvec1<u64, mediump> mediump_u64vec1;
1277 
1280  typedef tvec2<u64, mediump> mediump_u64vec2;
1281 
1284  typedef tvec3<u64, mediump> mediump_u64vec3;
1285 
1288  typedef tvec4<u64, mediump> mediump_u64vec4;
1289 
1290 
1293  typedef tvec1<u64, highp> highp_u64vec1;
1294 
1297  typedef tvec2<u64, highp> highp_u64vec2;
1298 
1301  typedef tvec3<u64, highp> highp_u64vec3;
1302 
1305  typedef tvec4<u64, highp> highp_u64vec4;
1306 
1307 #if(defined(GLM_PRECISION_LOWP_UINT))
1308  typedef lowp_u64vec1 u64vec1;
1309  typedef lowp_u64vec2 u64vec2;
1310  typedef lowp_u64vec3 u64vec3;
1311  typedef lowp_u64vec4 u64vec4;
1312 #elif(defined(GLM_PRECISION_MEDIUMP_UINT))
1313  typedef mediump_u64vec1 u64vec1;
1314  typedef mediump_u64vec2 u64vec2;
1315  typedef mediump_u64vec3 u64vec3;
1316  typedef mediump_u64vec4 u64vec4;
1317 #else
1318  typedef highp_u64vec1 u64vec1;
1321 
1324  typedef highp_u64vec2 u64vec2;
1325 
1328  typedef highp_u64vec3 u64vec3;
1329 
1332  typedef highp_u64vec4 u64vec4;
1333 #endif
1334 
1335 
1337  // Float vector types
1338 
1341  typedef detail::float32 lowp_float32;
1342 
1345  typedef detail::float64 lowp_float64;
1346 
1349  typedef detail::float32 lowp_float32_t;
1350 
1353  typedef detail::float64 lowp_float64_t;
1354 
1357  typedef float32 lowp_f32;
1358 
1361  typedef float64 lowp_f64;
1362 
1365  typedef detail::float32 lowp_float32;
1366 
1369  typedef detail::float64 lowp_float64;
1370 
1373  typedef detail::float32 lowp_float32_t;
1374 
1377  typedef detail::float64 lowp_float64_t;
1378 
1381  typedef float32 lowp_f32;
1382 
1385  typedef float64 lowp_f64;
1386 
1387 
1390  typedef detail::float32 lowp_float32;
1391 
1394  typedef detail::float64 lowp_float64;
1395 
1398  typedef detail::float32 lowp_float32_t;
1399 
1402  typedef detail::float64 lowp_float64_t;
1403 
1406  typedef float32 lowp_f32;
1407 
1410  typedef float64 lowp_f64;
1411 
1412 
1415  typedef detail::float32 mediump_float32;
1416 
1419  typedef detail::float64 mediump_float64;
1420 
1423  typedef detail::float32 mediump_float32_t;
1424 
1427  typedef detail::float64 mediump_float64_t;
1428 
1431  typedef float32 mediump_f32;
1432 
1435  typedef float64 mediump_f64;
1436 
1437 
1440  typedef detail::float32 highp_float32;
1441 
1444  typedef detail::float64 highp_float64;
1445 
1448  typedef detail::float32 highp_float32_t;
1449 
1452  typedef detail::float64 highp_float64_t;
1453 
1456  typedef float32 highp_f32;
1457 
1460  typedef float64 highp_f64;
1461 
1462 
1463 #if(defined(GLM_PRECISION_LOWP_FLOAT))
1464  typedef lowp_float32 float32;
1467 
1470  typedef lowp_float64 float64;
1471 
1474  typedef lowp_float32_t float32_t;
1475 
1478  typedef lowp_float64_t float64_t;
1479 
1482  typedef lowp_f32 f32;
1483 
1486  typedef lowp_f64 f64;
1487 
1488 #elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
1489 
1492  typedef mediump_float32 float32;
1493 
1496  typedef mediump_float64 float64;
1497 
1500  typedef mediump_float32 float32_t;
1501 
1504  typedef mediump_float64 float64_t;
1505 
1508  typedef mediump_float32 f32;
1509 
1512  typedef mediump_float64 f64;
1513 
1514 #else//(defined(GLM_PRECISION_HIGHP_FLOAT))
1515 
1518  typedef highp_float32 float32;
1519 
1522  typedef highp_float64 float64;
1523 
1526  typedef highp_float32_t float32_t;
1527 
1530  typedef highp_float64_t float64_t;
1531 
1534  typedef highp_float32_t f32;
1535 
1538  typedef highp_float64_t f64;
1539 #endif
1540 
1541 
1544  typedef tvec1<float, lowp> lowp_vec1;
1545 
1548  typedef tvec2<float, lowp> lowp_vec2;
1549 
1552  typedef tvec3<float, lowp> lowp_vec3;
1553 
1556  typedef tvec4<float, lowp> lowp_vec4;
1557 
1560  typedef tvec1<float, lowp> lowp_fvec1;
1561 
1564  typedef tvec2<float, lowp> lowp_fvec2;
1565 
1568  typedef tvec3<float, lowp> lowp_fvec3;
1569 
1572  typedef tvec4<float, lowp> lowp_fvec4;
1573 
1574 
1577  typedef tvec1<float, mediump> mediump_vec1;
1578 
1581  typedef tvec2<float, mediump> mediump_vec2;
1582 
1585  typedef tvec3<float, mediump> mediump_vec3;
1586 
1589  typedef tvec4<float, mediump> mediump_vec4;
1590 
1593  typedef tvec1<float, mediump> mediump_fvec1;
1594 
1597  typedef tvec2<float, mediump> mediump_fvec2;
1598 
1601  typedef tvec3<float, mediump> mediump_fvec3;
1602 
1605  typedef tvec4<float, mediump> mediump_fvec4;
1606 
1607 
1610  typedef tvec1<float, highp> highp_vec1;
1611 
1614  typedef tvec2<float, highp> highp_vec2;
1615 
1618  typedef tvec3<float, highp> highp_vec3;
1619 
1622  typedef tvec4<float, highp> highp_vec4;
1623 
1626  typedef tvec1<float, highp> highp_fvec1;
1627 
1630  typedef tvec2<float, highp> highp_fvec2;
1631 
1634  typedef tvec3<float, highp> highp_fvec3;
1635 
1638  typedef tvec4<float, highp> highp_fvec4;
1639 
1640 
1643  typedef tvec1<f32, lowp> lowp_f32vec1;
1644 
1647  typedef tvec2<f32, lowp> lowp_f32vec2;
1648 
1651  typedef tvec3<f32, lowp> lowp_f32vec3;
1652 
1655  typedef tvec4<f32, lowp> lowp_f32vec4;
1656 
1659  typedef tvec1<f32, mediump> mediump_f32vec1;
1660 
1663  typedef tvec2<f32, mediump> mediump_f32vec2;
1664 
1667  typedef tvec3<f32, mediump> mediump_f32vec3;
1668 
1671  typedef tvec4<f32, mediump> mediump_f32vec4;
1672 
1675  typedef tvec1<f32, highp> highp_f32vec1;
1676 
1679  typedef tvec2<f32, highp> highp_f32vec2;
1680 
1683  typedef tvec3<f32, highp> highp_f32vec3;
1684 
1687  typedef tvec4<f32, highp> highp_f32vec4;
1688 
1689 
1692  typedef tvec1<f64, lowp> lowp_f64vec1;
1693 
1696  typedef tvec2<f64, lowp> lowp_f64vec2;
1697 
1700  typedef tvec3<f64, lowp> lowp_f64vec3;
1701 
1704  typedef tvec4<f64, lowp> lowp_f64vec4;
1705 
1708  typedef tvec1<f64, mediump> mediump_f64vec1;
1709 
1712  typedef tvec2<f64, mediump> mediump_f64vec2;
1713 
1716  typedef tvec3<f64, mediump> mediump_f64vec3;
1717 
1720  typedef tvec4<f64, mediump> mediump_f64vec4;
1721 
1724  typedef tvec1<f64, highp> highp_f64vec1;
1725 
1728  typedef tvec2<f64, highp> highp_f64vec2;
1729 
1732  typedef tvec3<f64, highp> highp_f64vec3;
1733 
1736  typedef tvec4<f64, highp> highp_f64vec4;
1737 
1738 
1740  // Float matrix types
1741 
1744  //typedef lowp_f32 lowp_fmat1x1;
1745 
1748  typedef tmat2x2<f32, lowp> lowp_fmat2x2;
1749 
1752  typedef tmat2x3<f32, lowp> lowp_fmat2x3;
1753 
1756  typedef tmat2x4<f32, lowp> lowp_fmat2x4;
1757 
1760  typedef tmat3x2<f32, lowp> lowp_fmat3x2;
1761 
1764  typedef tmat3x3<f32, lowp> lowp_fmat3x3;
1765 
1768  typedef tmat3x4<f32, lowp> lowp_fmat3x4;
1769 
1772  typedef tmat4x2<f32, lowp> lowp_fmat4x2;
1773 
1776  typedef tmat4x3<f32, lowp> lowp_fmat4x3;
1777 
1780  typedef tmat4x4<f32, lowp> lowp_fmat4x4;
1781 
1784  //typedef lowp_fmat1x1 lowp_fmat1;
1785 
1788  typedef lowp_fmat2x2 lowp_fmat2;
1789 
1792  typedef lowp_fmat3x3 lowp_fmat3;
1793 
1796  typedef lowp_fmat4x4 lowp_fmat4;
1797 
1798 
1801  //typedef mediump_f32 mediump_fmat1x1;
1802 
1805  typedef tmat2x2<f32, mediump> mediump_fmat2x2;
1806 
1809  typedef tmat2x3<f32, mediump> mediump_fmat2x3;
1810 
1813  typedef tmat2x4<f32, mediump> mediump_fmat2x4;
1814 
1817  typedef tmat3x2<f32, mediump> mediump_fmat3x2;
1818 
1821  typedef tmat3x3<f32, mediump> mediump_fmat3x3;
1822 
1825  typedef tmat3x4<f32, mediump> mediump_fmat3x4;
1826 
1829  typedef tmat4x2<f32, mediump> mediump_fmat4x2;
1830 
1833  typedef tmat4x3<f32, mediump> mediump_fmat4x3;
1834 
1837  typedef tmat4x4<f32, mediump> mediump_fmat4x4;
1838 
1841  //typedef mediump_fmat1x1 mediump_fmat1;
1842 
1845  typedef mediump_fmat2x2 mediump_fmat2;
1846 
1849  typedef mediump_fmat3x3 mediump_fmat3;
1850 
1853  typedef mediump_fmat4x4 mediump_fmat4;
1854 
1855 
1858  //typedef highp_f32 highp_fmat1x1;
1859 
1862  typedef tmat2x2<f32, highp> highp_fmat2x2;
1863 
1866  typedef tmat2x3<f32, highp> highp_fmat2x3;
1867 
1870  typedef tmat2x4<f32, highp> highp_fmat2x4;
1871 
1874  typedef tmat3x2<f32, highp> highp_fmat3x2;
1875 
1878  typedef tmat3x3<f32, highp> highp_fmat3x3;
1879 
1882  typedef tmat3x4<f32, highp> highp_fmat3x4;
1883 
1886  typedef tmat4x2<f32, highp> highp_fmat4x2;
1887 
1890  typedef tmat4x3<f32, highp> highp_fmat4x3;
1891 
1894  typedef tmat4x4<f32, highp> highp_fmat4x4;
1895 
1898  //typedef highp_fmat1x1 highp_fmat1;
1899 
1902  typedef highp_fmat2x2 highp_fmat2;
1903 
1906  typedef highp_fmat3x3 highp_fmat3;
1907 
1910  typedef highp_fmat4x4 highp_fmat4;
1911 
1912 
1915  //typedef f32 lowp_f32mat1x1;
1916 
1919  typedef tmat2x2<f32, lowp> lowp_f32mat2x2;
1920 
1923  typedef tmat2x3<f32, lowp> lowp_f32mat2x3;
1924 
1927  typedef tmat2x4<f32, lowp> lowp_f32mat2x4;
1928 
1931  typedef tmat3x2<f32, lowp> lowp_f32mat3x2;
1932 
1935  typedef tmat3x3<f32, lowp> lowp_f32mat3x3;
1936 
1939  typedef tmat3x4<f32, lowp> lowp_f32mat3x4;
1940 
1943  typedef tmat4x2<f32, lowp> lowp_f32mat4x2;
1944 
1947  typedef tmat4x3<f32, lowp> lowp_f32mat4x3;
1948 
1951  typedef tmat4x4<f32, lowp> lowp_f32mat4x4;
1952 
1955  //typedef detail::tmat1x1<f32, lowp> lowp_f32mat1;
1956 
1959  typedef lowp_f32mat2x2 lowp_f32mat2;
1960 
1963  typedef lowp_f32mat3x3 lowp_f32mat3;
1964 
1967  typedef lowp_f32mat4x4 lowp_f32mat4;
1968 
1969 
1972  //typedef f32 mediump_f32mat1x1;
1973 
1976  typedef tmat2x2<f32, mediump> mediump_f32mat2x2;
1977 
1980  typedef tmat2x3<f32, mediump> mediump_f32mat2x3;
1981 
1984  typedef tmat2x4<f32, mediump> mediump_f32mat2x4;
1985 
1988  typedef tmat3x2<f32, mediump> mediump_f32mat3x2;
1989 
1992  typedef tmat3x3<f32, mediump> mediump_f32mat3x3;
1993 
1996  typedef tmat3x4<f32, mediump> mediump_f32mat3x4;
1997 
2000  typedef tmat4x2<f32, mediump> mediump_f32mat4x2;
2001 
2004  typedef tmat4x3<f32, mediump> mediump_f32mat4x3;
2005 
2008  typedef tmat4x4<f32, mediump> mediump_f32mat4x4;
2009 
2012  //typedef detail::tmat1x1<f32, mediump> f32mat1;
2013 
2016  typedef mediump_f32mat2x2 mediump_f32mat2;
2017 
2020  typedef mediump_f32mat3x3 mediump_f32mat3;
2021 
2024  typedef mediump_f32mat4x4 mediump_f32mat4;
2025 
2026 
2029  //typedef f32 highp_f32mat1x1;
2030 
2033  typedef tmat2x2<f32, highp> highp_f32mat2x2;
2034 
2037  typedef tmat2x3<f32, highp> highp_f32mat2x3;
2038 
2041  typedef tmat2x4<f32, highp> highp_f32mat2x4;
2042 
2045  typedef tmat3x2<f32, highp> highp_f32mat3x2;
2046 
2049  typedef tmat3x3<f32, highp> highp_f32mat3x3;
2050 
2053  typedef tmat3x4<f32, highp> highp_f32mat3x4;
2054 
2057  typedef tmat4x2<f32, highp> highp_f32mat4x2;
2058 
2061  typedef tmat4x3<f32, highp> highp_f32mat4x3;
2062 
2065  typedef tmat4x4<f32, highp> highp_f32mat4x4;
2066 
2069  //typedef detail::tmat1x1<f32, highp> f32mat1;
2070 
2073  typedef highp_f32mat2x2 highp_f32mat2;
2074 
2077  typedef highp_f32mat3x3 highp_f32mat3;
2078 
2081  typedef highp_f32mat4x4 highp_f32mat4;
2082 
2083 
2086  //typedef f64 lowp_f64mat1x1;
2087 
2090  typedef tmat2x2<f64, lowp> lowp_f64mat2x2;
2091 
2094  typedef tmat2x3<f64, lowp> lowp_f64mat2x3;
2095 
2098  typedef tmat2x4<f64, lowp> lowp_f64mat2x4;
2099 
2102  typedef tmat3x2<f64, lowp> lowp_f64mat3x2;
2103 
2106  typedef tmat3x3<f64, lowp> lowp_f64mat3x3;
2107 
2110  typedef tmat3x4<f64, lowp> lowp_f64mat3x4;
2111 
2114  typedef tmat4x2<f64, lowp> lowp_f64mat4x2;
2115 
2118  typedef tmat4x3<f64, lowp> lowp_f64mat4x3;
2119 
2122  typedef tmat4x4<f64, lowp> lowp_f64mat4x4;
2123 
2126  //typedef lowp_f64mat1x1 lowp_f64mat1;
2127 
2130  typedef lowp_f64mat2x2 lowp_f64mat2;
2131 
2134  typedef lowp_f64mat3x3 lowp_f64mat3;
2135 
2138  typedef lowp_f64mat4x4 lowp_f64mat4;
2139 
2140 
2143  //typedef f64 Highp_f64mat1x1;
2144 
2147  typedef tmat2x2<f64, mediump> mediump_f64mat2x2;
2148 
2151  typedef tmat2x3<f64, mediump> mediump_f64mat2x3;
2152 
2155  typedef tmat2x4<f64, mediump> mediump_f64mat2x4;
2156 
2159  typedef tmat3x2<f64, mediump> mediump_f64mat3x2;
2160 
2163  typedef tmat3x3<f64, mediump> mediump_f64mat3x3;
2164 
2167  typedef tmat3x4<f64, mediump> mediump_f64mat3x4;
2168 
2171  typedef tmat4x2<f64, mediump> mediump_f64mat4x2;
2172 
2175  typedef tmat4x3<f64, mediump> mediump_f64mat4x3;
2176 
2179  typedef tmat4x4<f64, mediump> mediump_f64mat4x4;
2180 
2183  //typedef mediump_f64mat1x1 mediump_f64mat1;
2184 
2187  typedef mediump_f64mat2x2 mediump_f64mat2;
2188 
2191  typedef mediump_f64mat3x3 mediump_f64mat3;
2192 
2195  typedef mediump_f64mat4x4 mediump_f64mat4;
2196 
2199  //typedef f64 highp_f64mat1x1;
2200 
2203  typedef tmat2x2<f64, highp> highp_f64mat2x2;
2204 
2207  typedef tmat2x3<f64, highp> highp_f64mat2x3;
2208 
2211  typedef tmat2x4<f64, highp> highp_f64mat2x4;
2212 
2215  typedef tmat3x2<f64, highp> highp_f64mat3x2;
2216 
2219  typedef tmat3x3<f64, highp> highp_f64mat3x3;
2220 
2223  typedef tmat3x4<f64, highp> highp_f64mat3x4;
2224 
2227  typedef tmat4x2<f64, highp> highp_f64mat4x2;
2228 
2231  typedef tmat4x3<f64, highp> highp_f64mat4x3;
2232 
2235  typedef tmat4x4<f64, highp> highp_f64mat4x4;
2236 
2239  //typedef highp_f64mat1x1 highp_f64mat1;
2240 
2243  typedef highp_f64mat2x2 highp_f64mat2;
2244 
2247  typedef highp_f64mat3x3 highp_f64mat3;
2248 
2251  typedef highp_f64mat4x4 highp_f64mat4;
2252 
2254  // Quaternion types
2255 
2258  typedef tquat<f32, lowp> lowp_f32quat;
2259 
2262  typedef tquat<f64, lowp> lowp_f64quat;
2263 
2266  typedef tquat<f32, mediump> mediump_f32quat;
2267 
2270  typedef tquat<f64, mediump> mediump_f64quat;
2271 
2274  typedef tquat<f32, highp> highp_f32quat;
2275 
2278  typedef tquat<f64, highp> highp_f64quat;
2279 
2280 
2281 #if(defined(GLM_PRECISION_LOWP_FLOAT))
2282  typedef lowp_f32vec1 fvec1;
2283  typedef lowp_f32vec2 fvec2;
2284  typedef lowp_f32vec3 fvec3;
2285  typedef lowp_f32vec4 fvec4;
2286  typedef lowp_f32mat2 fmat2;
2287  typedef lowp_f32mat3 fmat3;
2288  typedef lowp_f32mat4 fmat4;
2289  typedef lowp_f32mat2x2 fmat2x2;
2290  typedef lowp_f32mat3x2 fmat3x2;
2291  typedef lowp_f32mat4x2 fmat4x2;
2292  typedef lowp_f32mat2x3 fmat2x3;
2293  typedef lowp_f32mat3x3 fmat3x3;
2294  typedef lowp_f32mat4x3 fmat4x3;
2295  typedef lowp_f32mat2x4 fmat2x4;
2296  typedef lowp_f32mat3x4 fmat3x4;
2297  typedef lowp_f32mat4x4 fmat4x4;
2298  typedef lowp_f32quat fquat;
2299 
2300  typedef lowp_f32vec1 f32vec1;
2301  typedef lowp_f32vec2 f32vec2;
2302  typedef lowp_f32vec3 f32vec3;
2303  typedef lowp_f32vec4 f32vec4;
2304  typedef lowp_f32mat2 f32mat2;
2305  typedef lowp_f32mat3 f32mat3;
2306  typedef lowp_f32mat4 f32mat4;
2307  typedef lowp_f32mat2x2 f32mat2x2;
2308  typedef lowp_f32mat3x2 f32mat3x2;
2309  typedef lowp_f32mat4x2 f32mat4x2;
2310  typedef lowp_f32mat2x3 f32mat2x3;
2311  typedef lowp_f32mat3x3 f32mat3x3;
2312  typedef lowp_f32mat4x3 f32mat4x3;
2313  typedef lowp_f32mat2x4 f32mat2x4;
2314  typedef lowp_f32mat3x4 f32mat3x4;
2315  typedef lowp_f32mat4x4 f32mat4x4;
2316  typedef lowp_f32quat f32quat;
2317 #elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
2318  typedef mediump_f32vec1 fvec1;
2319  typedef mediump_f32vec2 fvec2;
2320  typedef mediump_f32vec3 fvec3;
2321  typedef mediump_f32vec4 fvec4;
2322  typedef mediump_f32mat2 fmat2;
2323  typedef mediump_f32mat3 fmat3;
2324  typedef mediump_f32mat4 fmat4;
2325  typedef mediump_f32mat2x2 fmat2x2;
2326  typedef mediump_f32mat3x2 fmat3x2;
2327  typedef mediump_f32mat4x2 fmat4x2;
2328  typedef mediump_f32mat2x3 fmat2x3;
2329  typedef mediump_f32mat3x3 fmat3x3;
2330  typedef mediump_f32mat4x3 fmat4x3;
2331  typedef mediump_f32mat2x4 fmat2x4;
2332  typedef mediump_f32mat3x4 fmat3x4;
2333  typedef mediump_f32mat4x4 fmat4x4;
2334  typedef mediump_f32quat fquat;
2335 
2336  typedef mediump_f32vec1 f32vec1;
2337  typedef mediump_f32vec2 f32vec2;
2338  typedef mediump_f32vec3 f32vec3;
2339  typedef mediump_f32vec4 f32vec4;
2340  typedef mediump_f32mat2 f32mat2;
2341  typedef mediump_f32mat3 f32mat3;
2342  typedef mediump_f32mat4 f32mat4;
2343  typedef mediump_f32mat2x2 f32mat2x2;
2344  typedef mediump_f32mat3x2 f32mat3x2;
2345  typedef mediump_f32mat4x2 f32mat4x2;
2346  typedef mediump_f32mat2x3 f32mat2x3;
2347  typedef mediump_f32mat3x3 f32mat3x3;
2348  typedef mediump_f32mat4x3 f32mat4x3;
2349  typedef mediump_f32mat2x4 f32mat2x4;
2350  typedef mediump_f32mat3x4 f32mat3x4;
2351  typedef mediump_f32mat4x4 f32mat4x4;
2352  typedef mediump_f32quat f32quat;
2353 #else//if(defined(GLM_PRECISION_HIGHP_FLOAT))
2354  typedef highp_f32vec1 fvec1;
2357 
2360  typedef highp_f32vec2 fvec2;
2361 
2364  typedef highp_f32vec3 fvec3;
2365 
2368  typedef highp_f32vec4 fvec4;
2369 
2372  typedef highp_f32mat2x2 fmat2x2;
2373 
2376  typedef highp_f32mat2x3 fmat2x3;
2377 
2380  typedef highp_f32mat2x4 fmat2x4;
2381 
2384  typedef highp_f32mat3x2 fmat3x2;
2385 
2388  typedef highp_f32mat3x3 fmat3x3;
2389 
2392  typedef highp_f32mat3x4 fmat3x4;
2393 
2396  typedef highp_f32mat4x2 fmat4x2;
2397 
2400  typedef highp_f32mat4x3 fmat4x3;
2401 
2404  typedef highp_f32mat4x4 fmat4x4;
2405 
2408  typedef fmat2x2 fmat2;
2409 
2412  typedef fmat3x3 fmat3;
2413 
2416  typedef fmat4x4 fmat4;
2417 
2420  typedef highp_fquat fquat;
2421 
2422 
2423 
2426  typedef highp_f32vec1 f32vec1;
2427 
2430  typedef highp_f32vec2 f32vec2;
2431 
2434  typedef highp_f32vec3 f32vec3;
2435 
2438  typedef highp_f32vec4 f32vec4;
2439 
2442  typedef highp_f32mat2x2 f32mat2x2;
2443 
2446  typedef highp_f32mat2x3 f32mat2x3;
2447 
2450  typedef highp_f32mat2x4 f32mat2x4;
2451 
2454  typedef highp_f32mat3x2 f32mat3x2;
2455 
2458  typedef highp_f32mat3x3 f32mat3x3;
2459 
2462  typedef highp_f32mat3x4 f32mat3x4;
2463 
2466  typedef highp_f32mat4x2 f32mat4x2;
2467 
2470  typedef highp_f32mat4x3 f32mat4x3;
2471 
2474  typedef highp_f32mat4x4 f32mat4x4;
2475 
2478  typedef f32mat2x2 f32mat2;
2479 
2482  typedef f32mat3x3 f32mat3;
2483 
2486  typedef f32mat4x4 f32mat4;
2487 
2490  typedef highp_f32quat f32quat;
2491 #endif
2492 
2493 #if(defined(GLM_PRECISION_LOWP_DOUBLE))
2494  typedef lowp_f64vec1 f64vec1;
2495  typedef lowp_f64vec2 f64vec2;
2496  typedef lowp_f64vec3 f64vec3;
2497  typedef lowp_f64vec4 f64vec4;
2498  typedef lowp_f64mat2 f64mat2;
2499  typedef lowp_f64mat3 f64mat3;
2500  typedef lowp_f64mat4 f64mat4;
2501  typedef lowp_f64mat2x2 f64mat2x2;
2502  typedef lowp_f64mat3x2 f64mat3x2;
2503  typedef lowp_f64mat4x2 f64mat4x2;
2504  typedef lowp_f64mat2x3 f64mat2x3;
2505  typedef lowp_f64mat3x3 f64mat3x3;
2506  typedef lowp_f64mat4x3 f64mat4x3;
2507  typedef lowp_f64mat2x4 f64mat2x4;
2508  typedef lowp_f64mat3x4 f64mat3x4;
2509  typedef lowp_f64mat4x4 f64mat4x4;
2510  typedef lowp_f64quat f64quat;
2511 #elif(defined(GLM_PRECISION_MEDIUMP_DOUBLE))
2512  typedef mediump_f64vec1 f64vec1;
2513  typedef mediump_f64vec2 f64vec2;
2514  typedef mediump_f64vec3 f64vec3;
2515  typedef mediump_f64vec4 f64vec4;
2516  typedef mediump_f64mat2 f64mat2;
2517  typedef mediump_f64mat3 f64mat3;
2518  typedef mediump_f64mat4 f64mat4;
2519  typedef mediump_f64mat2x2 f64mat2x2;
2520  typedef mediump_f64mat3x2 f64mat3x2;
2521  typedef mediump_f64mat4x2 f64mat4x2;
2522  typedef mediump_f64mat2x3 f64mat2x3;
2523  typedef mediump_f64mat3x3 f64mat3x3;
2524  typedef mediump_f64mat4x3 f64mat4x3;
2525  typedef mediump_f64mat2x4 f64mat2x4;
2526  typedef mediump_f64mat3x4 f64mat3x4;
2527  typedef mediump_f64mat4x4 f64mat4x4;
2528  typedef mediump_f64quat f64quat;
2529 #else
2530  typedef highp_f64vec1 f64vec1;
2533 
2536  typedef highp_f64vec2 f64vec2;
2537 
2540  typedef highp_f64vec3 f64vec3;
2541 
2544  typedef highp_f64vec4 f64vec4;
2545 
2548  typedef highp_f64mat2x2 f64mat2x2;
2549 
2552  typedef highp_f64mat2x3 f64mat2x3;
2553 
2556  typedef highp_f64mat2x4 f64mat2x4;
2557 
2560  typedef highp_f64mat3x2 f64mat3x2;
2561 
2564  typedef highp_f64mat3x3 f64mat3x3;
2565 
2568  typedef highp_f64mat3x4 f64mat3x4;
2569 
2572  typedef highp_f64mat4x2 f64mat4x2;
2573 
2576  typedef highp_f64mat4x3 f64mat4x3;
2577 
2580  typedef highp_f64mat4x4 f64mat4x4;
2581 
2584  typedef f64mat2x2 f64mat2;
2585 
2588  typedef f64mat3x3 f64mat3;
2589 
2592  typedef f64mat4x4 f64mat4;
2593 
2596  typedef highp_f64quat f64quat;
2597 #endif
2598 
2599 }//namespace glm
glm::highp_vec2
tvec2< float, highp > highp_vec2
2 components vector of high single-precision floating-point numbers.
Definition: type_vec.hpp:69
glm::int8_t
detail::int8 int8_t
8 bit signed integer type.
Definition: fwd.hpp:297
glm::lowp_uint32
detail::uint32 lowp_uint32
Low precision 32 bit unsigned integer type.
Definition: fwd.hpp:740
glm::lowp_int64_t
detail::int64 lowp_int64_t
Low precision 64 bit signed integer type.
Definition: fwd.hpp:157
glm::lowp_int16
detail::int16 lowp_int16
Low precision 16 bit signed integer type.
Definition: fwd.hpp:133
glm::u16vec1
highp_u16vec1 u16vec1
Default precision 16 bit unsigned integer scalar type.
Definition: fwd.hpp:1082
glm::u32
detail::uint32 u32
32 bit unsigned integer type.
Definition: fwd.hpp:931
glm::mediump_vec3
tvec3< float, mediump > mediump_vec3
3 components vector of medium single-precision floating-point numbers.
Definition: type_vec.hpp:186
glm::lowp_uint16
detail::uint16 lowp_uint16
Low precision 16 bit unsigned integer type.
Definition: fwd.hpp:736
glm::fvec3
highp_f32vec3 fvec3
Default single-precision floating-point vector of 3 components.
Definition: fwd.hpp:2364
glm::fmat3x3
highp_f32mat3x3 fmat3x3
Default single-precision floating-point 3x3 matrix.
Definition: fwd.hpp:2388
glm::i64vec4
highp_i64vec4 i64vec4
Default precision 64 bit signed integer vector of 4 components type.
Definition: fwd.hpp:723
glm::f32mat3
f32mat3x3 f32mat3
Default single-precision floating-point 3x3 matrix.
Definition: fwd.hpp:2482
glm::mediump_u8
detail::uint8 mediump_u8
Medium precision 8 bit unsigned integer type.
Definition: fwd.hpp:816
glm::highp_i64
detail::int64 highp_i64
High precision 64 bit signed integer type.
Definition: fwd.hpp:269
glm::u32vec2
highp_u32vec2 u32vec2
Default precision 32 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:1165
glm::u8vec4
highp_u8vec4 u8vec4
Default precision 8 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:1014
glm::highp_int64_t
detail::int64 highp_int64_t
High precision 64 bit signed integer type.
Definition: fwd.hpp:253
glm::i64vec2
highp_i64vec2 i64vec2
Default precision 64 bit signed integer vector of 2 components type.
Definition: fwd.hpp:715
glm::int32_t
detail::int32 int32_t
32 bit signed integer type.
Definition: fwd.hpp:305
glm::i16vec4
highp_i16vec4 i16vec4
Default precision 16 bit signed integer vector of 4 components type.
Definition: fwd.hpp:485
glm::mediump_i32
detail::int32 mediump_i32
Medium precision 32 bit signed integer type.
Definition: fwd.hpp:217
glm::lowp_int8
detail::int8 lowp_int8
Low precision 8 bit signed integer type.
Definition: fwd.hpp:129
glm::mediump_vec2
tvec2< float, mediump > mediump_vec2
2 components vector of medium single-precision floating-point numbers.
Definition: type_vec.hpp:76
glm::u64
detail::uint64 u64
64 bit unsigned integer type.
Definition: fwd.hpp:935
glm::lowp_u8
detail::uint8 lowp_u8
Low precision 8 bit unsigned integer type.
Definition: fwd.hpp:766
glm::i8
detail::int8 i8
8 bit signed integer type.
Definition: fwd.hpp:314
glm::mediump_uint8
detail::uint8 mediump_uint8
Medium precision 8 bit unsigned integer type.
Definition: fwd.hpp:784
glm::f64mat4
f64mat4x4 f64mat4
Default double-precision floating-point 4x4 matrix.
Definition: fwd.hpp:2592
glm::lowp_uint32_t
detail::uint32 lowp_uint32_t
Low precision 32 bit unsigned integer type.
Definition: fwd.hpp:757
glm::mediump_i64
detail::int64 mediump_i64
Medium precision 64 bit signed integer type.
Definition: fwd.hpp:221
glm::int32
detail::int32 int32
32 bit signed integer type.
Definition: type_int.hpp:228
glm::i64vec3
highp_i64vec3 i64vec3
Default precision 64 bit signed integer vector of 3 components type.
Definition: fwd.hpp:719
glm::highp_i32
detail::int32 highp_i32
High precision 32 bit signed integer type.
Definition: fwd.hpp:265
glm::lowp_u32
detail::uint32 lowp_u32
Low precision 32 bit unsigned integer type.
Definition: fwd.hpp:774
glm::highp_i16
detail::int16 highp_i16
High precision 16 bit signed integer type.
Definition: fwd.hpp:261
glm::highp_i8
detail::int8 highp_i8
High precision 8 bit signed integer type.
Definition: fwd.hpp:257
glm::u32vec3
highp_u32vec3 u32vec3
Default precision 32 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:1169
glm::fmat4
fmat4x4 fmat4
Default single-precision floating-point 4x4 matrix.
Definition: fwd.hpp:2416
glm::mediump_u32
detail::uint32 mediump_u32
Medium precision 32 bit unsigned integer type.
Definition: fwd.hpp:824
glm::fvec2
highp_f32vec2 fvec2
Default single-precision floating-point vector of 2 components.
Definition: fwd.hpp:2360
glm::mediump_int8
detail::int8 mediump_int8
Medium precision 8 bit signed integer type.
Definition: fwd.hpp:177
glm::highp_u32
detail::uint32 highp_u32
Medium precision 32 bit unsigned integer type.
Definition: fwd.hpp:874
glm::highp_vec3
tvec3< float, highp > highp_vec3
3 components vector of high single-precision floating-point numbers.
Definition: type_vec.hpp:179
glm::mediump_uint64_t
detail::uint64 mediump_uint64_t
Medium precision 64 bit unsigned integer type.
Definition: fwd.hpp:812
glm::i32vec1
highp_i32vec1 i32vec1
Default precision 32 bit signed integer scalar type.
Definition: fwd.hpp:552
glm::highp_u8
detail::uint8 highp_u8
Medium precision 8 bit unsigned integer type.
Definition: fwd.hpp:866
glm::u16vec3
highp_u16vec3 u16vec3
Default precision 16 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:1090
glm::highp_vec4
tvec4< float, highp > highp_vec4
4 components vector of high single-precision floating-point numbers.
Definition: type_vec.hpp:285
glm::i16vec2
highp_i16vec2 i16vec2
Default precision 16 bit signed integer vector of 2 components type.
Definition: fwd.hpp:477
glm::f32mat2
f32mat2x2 f32mat2
Default single-precision floating-point 2x2 matrix.
Definition: fwd.hpp:2478
glm::i32vec4
highp_i32vec4 i32vec4
Default precision 32 bit signed integer vector of 4 components type.
Definition: fwd.hpp:564
glm::mediump_vec4
tvec4< float, mediump > mediump_vec4
4 components vector of medium single-precision floating-point numbers.
Definition: type_vec.hpp:291
glm::uint8
detail::uint8 uint8
8 bit unsigned integer type.
Definition: type_int.hpp:231
glm::lowp_int64
detail::int64 lowp_int64
Low precision 64 bit signed integer type.
Definition: fwd.hpp:141
glm::f32mat2x4
highp_f32mat2x4 f32mat2x4
Default single-precision floating-point 2x4 matrix.
Definition: fwd.hpp:2450
glm::f32mat3x2
highp_f32mat3x2 f32mat3x2
Default single-precision floating-point 3x2 matrix.
Definition: fwd.hpp:2454
glm::f64vec4
highp_f64vec4 f64vec4
Default double-precision floating-point vector of 4 components.
Definition: fwd.hpp:2544
glm::f64mat2
f64mat2x2 f64mat2
Default double-precision floating-point 2x2 matrix.
Definition: fwd.hpp:2584
glm::lowp_i32
detail::int32 lowp_i32
Low precision 32 bit signed integer type.
Definition: fwd.hpp:169
glm::mediump_uint64
detail::uint64 mediump_uint64
Medium precision 64 bit unsigned integer type.
Definition: fwd.hpp:796
glm::f32vec2
highp_f32vec2 f32vec2
Default single-precision floating-point vector of 2 components.
Definition: fwd.hpp:2430
glm::u16
detail::uint16 u16
16 bit unsigned integer type.
Definition: fwd.hpp:927
glm::f64
highp_float64_t f64
Default 64 bit double-precision floating-point scalar.
Definition: fwd.hpp:1538
glm::f64mat3
f64mat3x3 f64mat3
Default double-precision floating-point 3x3 matrix.
Definition: fwd.hpp:2588
glm::f64vec1
highp_f64vec1 f64vec1
Default double-precision floating-point vector of 1 components.
Definition: fwd.hpp:2532
glm::fvec4
highp_f32vec4 fvec4
Default single-precision floating-point vector of 4 components.
Definition: fwd.hpp:2368
glm::mediump_i8
detail::int8 mediump_i8
Medium precision 8 bit signed integer type.
Definition: fwd.hpp:209
glm::f32mat4x4
highp_f32mat4x4 f32mat4x4
Default single-precision floating-point 4x4 matrix.
Definition: fwd.hpp:2474
glm::f64mat2x2
highp_f64mat2x2 f64mat2x2
Default double-precision floating-point 2x2 matrix.
Definition: fwd.hpp:2548
glm::float64_t
highp_float64_t float64_t
Default 64 bit double-precision floating-point scalar.
Definition: fwd.hpp:1530
glm::u8vec1
highp_u8vec1 u8vec1
Default precision 8 bit unsigned integer scalar type.
Definition: fwd.hpp:1002
glm::fmat4x2
highp_f32mat4x2 fmat4x2
Default single-precision floating-point 4x2 matrix.
Definition: fwd.hpp:2396
glm::u8vec2
highp_u8vec2 u8vec2
Default precision 8 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:1006
glm::int8
detail::int8 int8
8 bit signed integer type.
Definition: type_int.hpp:226
glm::u64vec1
highp_u64vec1 u64vec1
Default precision 64 bit unsigned integer scalar type.
Definition: fwd.hpp:1320
glm::highp_uint8
detail::uint8 highp_uint8
Medium precision 8 bit unsigned integer type.
Definition: fwd.hpp:834
glm::mediump_u16
detail::uint16 mediump_u16
Medium precision 16 bit unsigned integer type.
Definition: fwd.hpp:820
glm::f64mat3x3
highp_f64mat3x3 f64mat3x3
Default double-precision floating-point 3x3 matrix.
Definition: fwd.hpp:2564
glm::mediump_uint32
detail::uint32 mediump_uint32
Medium precision 32 bit unsigned integer type.
Definition: fwd.hpp:792
glm::int16
detail::int16 int16
16 bit signed integer type.
Definition: type_int.hpp:227
glm::f32mat4x2
highp_f32mat4x2 f32mat4x2
Default single-precision floating-point 4x2 matrix.
Definition: fwd.hpp:2466
glm::highp_int16
detail::int16 highp_int16
High precision 16 bit signed integer type.
Definition: fwd.hpp:229
glm::float32
float float32
Default 32 bit single-precision floating-point scalar.
Definition: type_float.hpp:84
glm::highp_int32
detail::int32 highp_int32
High precision 32 bit signed integer type.
Definition: fwd.hpp:233
glm::mediump_int8_t
detail::int8 mediump_int8_t
Medium precision 8 bit signed integer type.
Definition: fwd.hpp:193
glm::f32quat
highp_f32quat f32quat
Default single-precision floating-point quaternion.
Definition: fwd.hpp:2490
glm::uint16
detail::uint16 uint16
16 bit unsigned integer type.
Definition: type_int.hpp:232
glm::i8vec4
highp_i8vec4 i8vec4
Default precision 8 bit signed integer vector of 4 components type.
Definition: fwd.hpp:405
glm::highp_int8
detail::int8 highp_int8
High precision 8 bit signed integer type.
Definition: fwd.hpp:225
glm::f64mat2x4
highp_f64mat2x4 f64mat2x4
Default double-precision floating-point 2x4 matrix.
Definition: fwd.hpp:2556
glm::u16vec4
highp_u16vec4 u16vec4
Default precision 16 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:1094
glm::u64vec2
highp_u64vec2 u64vec2
Default precision 64 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:1324
glm::highp_uint64_t
detail::uint64 highp_uint64_t
Medium precision 64 bit unsigned integer type.
Definition: fwd.hpp:862
glm::f32
highp_float32_t f32
Default 32 bit single-precision floating-point scalar.
Definition: fwd.hpp:1534
glm::lowp_i8
detail::int8 lowp_i8
Low precision 8 bit signed integer type.
Definition: fwd.hpp:161
glm::f32vec1
highp_f32vec1 f32vec1
Default single-precision floating-point vector of 1 components.
Definition: fwd.hpp:2426
glm::uint32_t
detail::uint32 uint32_t
32 bit unsigned integer type.
Definition: fwd.hpp:914
glm::u8
detail::uint8 u8
8 bit unsigned integer type.
Definition: fwd.hpp:923
glm::lowp_u16
detail::uint16 lowp_u16
Low precision 16 bit unsigned integer type.
Definition: fwd.hpp:770
glm::fmat2x4
highp_f32mat2x4 fmat2x4
Default single-precision floating-point 2x4 matrix.
Definition: fwd.hpp:2380
glm::fvec1
highp_f32vec1 fvec1
Default single-precision floating-point vector of 1 components.
Definition: fwd.hpp:2356
glm::lowp_i16
detail::int16 lowp_i16
Low precision 16 bit signed integer type.
Definition: fwd.hpp:165
glm::lowp_uint8_t
detail::uint8 lowp_uint8_t
Low precision 8 bit unsigned integer type.
Definition: fwd.hpp:749
glm::i32vec2
highp_i32vec2 i32vec2
Default precision 32 bit signed integer vector of 2 components type.
Definition: fwd.hpp:556
glm
Definition: _noise.hpp:40
glm::mediump_uint16
detail::uint16 mediump_uint16
Medium precision 16 bit unsigned integer type.
Definition: fwd.hpp:788
glm::f64quat
highp_f64quat f64quat
Default double-precision floating-point quaternion.
Definition: fwd.hpp:2596
glm::highp_int8_t
detail::int8 highp_int8_t
High precision 8 bit signed integer type.
Definition: fwd.hpp:241
glm::highp_uint8_t
detail::uint8 highp_uint8_t
Medium precision 8 bit unsigned integer type.
Definition: fwd.hpp:850
glm::i8vec1
highp_i8vec1 i8vec1
Default precision 8 bit signed integer scalar type.
Definition: fwd.hpp:393
glm::i16vec1
highp_i16vec1 i16vec1
Default precision 16 bit signed integer scalar type.
Definition: fwd.hpp:473
type_vec.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::mediump_int64_t
detail::int64 mediump_int64_t
Medium precision 64 bit signed integer type.
Definition: fwd.hpp:205
glm::fmat2x2
highp_f32mat2x2 fmat2x2
Default single-precision floating-point 2x2 matrix.
Definition: fwd.hpp:2372
glm::lowp_int8_t
detail::int8 lowp_int8_t
Low precision 8 bit signed integer type.
Definition: fwd.hpp:145
glm::highp_uint16
detail::uint16 highp_uint16
Medium precision 16 bit unsigned integer type.
Definition: fwd.hpp:838
glm::float64
double float64
Default 64 bit double-precision floating-point scalar.
Definition: type_float.hpp:85
type_mat.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::lowp_uint64
detail::uint64 lowp_uint64
Low precision 64 bit unsigned integer type.
Definition: fwd.hpp:744
glm::fmat2x3
highp_f32mat2x3 fmat2x3
Default single-precision floating-point 2x3 matrix.
Definition: fwd.hpp:2376
glm::float32_t
highp_float32_t float32_t
Default 32 bit single-precision floating-point scalar.
Definition: fwd.hpp:1526
glm::i8vec3
highp_i8vec3 i8vec3
Default precision 8 bit signed integer vector of 3 components type.
Definition: fwd.hpp:401
glm::fmat3x2
highp_f32mat3x2 fmat3x2
Default single-precision floating-point 3x2 matrix.
Definition: fwd.hpp:2384
glm::mediump_i16
detail::int16 mediump_i16
Medium precision 16 bit signed integer type.
Definition: fwd.hpp:213
glm::mediump_uint16_t
detail::uint16 mediump_uint16_t
Medium precision 16 bit unsigned integer type.
Definition: fwd.hpp:804
glm::u32vec4
highp_u32vec4 u32vec4
Default precision 32 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:1173
glm::f64mat3x4
highp_f64mat3x4 f64mat3x4
Default double-precision floating-point 3x4 matrix.
Definition: fwd.hpp:2568
glm::lowp_uint16_t
detail::uint16 lowp_uint16_t
Low precision 16 bit unsigned integer type.
Definition: fwd.hpp:753
glm::mediump_int16
detail::int16 mediump_int16
Medium precision 16 bit signed integer type.
Definition: fwd.hpp:181
glm::fmat3x4
highp_f32mat3x4 fmat3x4
Default single-precision floating-point 3x4 matrix.
Definition: fwd.hpp:2392
glm::fmat4x3
highp_f32mat4x3 fmat4x3
Default single-precision floating-point 4x3 matrix.
Definition: fwd.hpp:2400
glm::u8vec3
highp_u8vec3 u8vec3
Default precision 8 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:1010
glm::f64vec3
highp_f64vec3 f64vec3
Default double-precision floating-point vector of 3 components.
Definition: fwd.hpp:2540
glm::lowp_vec2
tvec2< float, lowp > lowp_vec2
2 components vector of low single-precision floating-point numbers.
Definition: type_vec.hpp:83
glm::u64vec4
highp_u64vec4 u64vec4
Default precision 64 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:1332
glm::mediump_int16_t
detail::int16 mediump_int16_t
Medium precision 16 bit signed integer type.
Definition: fwd.hpp:197
glm::uint32
detail::uint32 uint32
32 bit unsigned integer type.
Definition: type_int.hpp:233
glm::lowp_int16_t
detail::int16 lowp_int16_t
Low precision 16 bit signed integer type.
Definition: fwd.hpp:149
glm::f64mat4x3
highp_f64mat4x3 f64mat4x3
Default double-precision floating-point 4x3 matrix.
Definition: fwd.hpp:2576
glm::mediump_uint32_t
detail::uint32 mediump_uint32_t
Medium precision 32 bit unsigned integer type.
Definition: fwd.hpp:808
glm::mediump_int32_t
detail::int32 mediump_int32_t
Medium precision 32 bit signed integer type.
Definition: fwd.hpp:201
glm::uint8_t
detail::uint8 uint8_t
8 bit unsigned integer type.
Definition: fwd.hpp:906
glm::f64mat3x2
highp_f64mat3x2 f64mat3x2
Default double-precision floating-point 3x2 matrix.
Definition: fwd.hpp:2560
glm::f32mat2x2
highp_f32mat2x2 f32mat2x2
Default single-precision floating-point 2x2 matrix.
Definition: fwd.hpp:2442
glm::f32mat3x3
highp_f32mat3x3 f32mat3x3
Default single-precision floating-point 3x3 matrix.
Definition: fwd.hpp:2458
glm::highp_uint16_t
detail::uint16 highp_uint16_t
Medium precision 16 bit unsigned integer type.
Definition: fwd.hpp:854
glm::i8vec2
highp_i8vec2 i8vec2
Default precision 8 bit signed integer vector of 2 components type.
Definition: fwd.hpp:397
glm::highp_int16_t
detail::int16 highp_int16_t
High precision 16 bit signed integer type.
Definition: fwd.hpp:245
glm::lowp_int32
detail::int32 lowp_int32
Low precision 32 bit signed integer type.
Definition: fwd.hpp:137
glm::highp_u64
detail::uint64 highp_u64
Medium precision 64 bit unsigned integer type.
Definition: fwd.hpp:878
glm::f64mat4x2
highp_f64mat4x2 f64mat4x2
Default double-precision floating-point 4x2 matrix.
Definition: fwd.hpp:2572
glm::mediump_int32
detail::int32 mediump_int32
Medium precision 32 bit signed integer type.
Definition: fwd.hpp:185
glm::int64_t
detail::int64 int64_t
64 bit signed integer type.
Definition: fwd.hpp:309
glm::lowp_vec3
tvec3< float, lowp > lowp_vec3
3 components vector of low single-precision floating-point numbers.
Definition: type_vec.hpp:193
glm::f32mat4
f32mat4x4 f32mat4
Default single-precision floating-point 4x4 matrix.
Definition: fwd.hpp:2486
glm::lowp_u64
detail::uint64 lowp_u64
Low precision 64 bit unsigned integer type.
Definition: fwd.hpp:778
glm::uint64
detail::uint64 uint64
64 bit unsigned integer type.
Definition: type_int.hpp:234
glm::mediump_u64
detail::uint64 mediump_u64
Medium precision 64 bit unsigned integer type.
Definition: fwd.hpp:828
glm::int64
detail::int64 int64
64 bit signed integer type.
Definition: type_int.hpp:229
glm::lowp_uint64_t
detail::uint64 lowp_uint64_t
Low precision 64 bit unsigned integer type.
Definition: fwd.hpp:761
glm::highp_uint32_t
detail::uint32 highp_uint32_t
Medium precision 32 bit unsigned integer type.
Definition: fwd.hpp:858
glm::i16vec3
highp_i16vec3 i16vec3
Default precision 16 bit signed integer vector of 3 components type.
Definition: fwd.hpp:481
glm::fmat4x4
highp_f32mat4x4 fmat4x4
Default single-precision floating-point 4x4 matrix.
Definition: fwd.hpp:2404
glm::highp_int32_t
detail::int32 highp_int32_t
32 bit signed integer type.
Definition: fwd.hpp:249
glm::uint16_t
detail::uint16 uint16_t
16 bit unsigned integer type.
Definition: fwd.hpp:910
glm::f32vec3
highp_f32vec3 f32vec3
Default single-precision floating-point vector of 3 components.
Definition: fwd.hpp:2434
glm::f64mat4x4
highp_f64mat4x4 f64mat4x4
Default double-precision floating-point 4x4 matrix.
Definition: fwd.hpp:2580
glm::f64mat2x3
highp_f64mat2x3 f64mat2x3
Default double-precision floating-point 2x3 matrix.
Definition: fwd.hpp:2552
glm::highp_uint32
detail::uint32 highp_uint32
Medium precision 32 bit unsigned integer type.
Definition: fwd.hpp:842
glm::highp_u16
detail::uint16 highp_u16
Medium precision 16 bit unsigned integer type.
Definition: fwd.hpp:870
glm::f32mat2x3
highp_f32mat2x3 f32mat2x3
Default single-precision floating-point 2x3 matrix.
Definition: fwd.hpp:2446
glm::fmat2
fmat2x2 fmat2
Default single-precision floating-point 2x2 matrix.
Definition: fwd.hpp:2408
glm::mediump_uint8_t
detail::uint8 mediump_uint8_t
Medium precision 8 bit unsigned integer type.
Definition: fwd.hpp:800
glm::i32
detail::int32 i32
32 bit signed integer type.
Definition: fwd.hpp:322
glm::f32vec4
highp_f32vec4 f32vec4
Default single-precision floating-point vector of 4 components.
Definition: fwd.hpp:2438
glm::i32vec3
highp_i32vec3 i32vec3
Default precision 32 bit signed integer vector of 3 components type.
Definition: fwd.hpp:560
glm::u16vec2
highp_u16vec2 u16vec2
Default precision 16 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:1086
glm::lowp_uint8
detail::uint8 lowp_uint8
Low precision 8 bit unsigned integer type.
Definition: fwd.hpp:732
glm::i64vec1
highp_i64vec1 i64vec1
Default precision 64 bit signed integer scalar type.
Definition: fwd.hpp:711
glm::i16
detail::int16 i16
16 bit signed integer type.
Definition: fwd.hpp:318
glm::f32mat3x4
highp_f32mat3x4 f32mat3x4
Default single-precision floating-point 3x4 matrix.
Definition: fwd.hpp:2462
glm::uint64_t
detail::uint64 uint64_t
64 bit unsigned integer type.
Definition: fwd.hpp:918
type_float.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::highp_int64
detail::int64 highp_int64
High precision 64 bit signed integer type.
Definition: fwd.hpp:237
glm::u32vec1
highp_u32vec1 u32vec1
Default precision 32 bit unsigned integer scalar type.
Definition: fwd.hpp:1161
glm::int16_t
detail::int16 int16_t
16 bit signed integer type.
Definition: fwd.hpp:301
glm::f32mat4x3
highp_f32mat4x3 f32mat4x3
Default single-precision floating-point 4x3 matrix.
Definition: fwd.hpp:2470
glm::fmat3
fmat3x3 fmat3
Default single-precision floating-point 3x3 matrix.
Definition: fwd.hpp:2412
glm::mediump_int64
detail::int64 mediump_int64
Medium precision 64 bit signed integer type.
Definition: fwd.hpp:189
glm::lowp_int32_t
detail::int32 lowp_int32_t
Low precision 32 bit signed integer type.
Definition: fwd.hpp:153
glm::lowp_vec4
tvec4< float, lowp > lowp_vec4
4 components vector of low single-precision floating-point numbers.
Definition: type_vec.hpp:297
glm::f64vec2
highp_f64vec2 f64vec2
Default double-precision floating-point vector of 2 components.
Definition: fwd.hpp:2536
glm::highp_uint64
detail::uint64 highp_uint64
Medium precision 64 bit unsigned integer type.
Definition: fwd.hpp:846
glm::i64
detail::int64 i64
64 bit signed integer type.
Definition: fwd.hpp:326
glm::u64vec3
highp_u64vec3 u64vec3
Default precision 64 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:1328
type_int.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::lowp_i64
detail::int64 lowp_i64
Low precision 64 bit signed integer type.
Definition: fwd.hpp:173
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00039.html000066400000000000000000000101771356361734700216540ustar00rootroot00000000000000 0.9.7: geometric.hpp File Reference
geometric.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-12-24 / 2013-12-24
Author
Christophe Riccio

Definition in file geometric.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00039_source.html000066400000000000000000000062651356361734700232370ustar00rootroot00000000000000 0.9.7: geometric.hpp Source File
geometric.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "detail/func_geometric.hpp"
func_geometric.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00040.html000066400000000000000000000130011356361734700216310ustar00rootroot00000000000000 0.9.7: glm.hpp File Reference
glm.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Date
2009-05-01 / 2011-05-16
Author
Christophe Riccio

GLM Core (Dependence)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2005-01-14 / 2011-10-24
Author
Christophe Riccio

Definition in file glm.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00040_source.html000066400000000000000000000276661356361734700232370ustar00rootroot00000000000000 0.9.7: glm.hpp Source File
glm.hpp
Go to the documentation of this file.
1 
81 #include "detail/_fixes.hpp"
82 
83 #pragma once
84 
85 #include <cmath>
86 #include <climits>
87 #include <cfloat>
88 #include <limits>
89 #include <cassert>
90 #include "fwd.hpp"
91 
92 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_CORE_INCLUDED_DISPLAYED))
93 # define GLM_MESSAGE_CORE_INCLUDED_DISPLAYED
94 # pragma message("GLM: Core library included")
95 #endif//GLM_MESSAGE
96 
97 #include "vec2.hpp"
98 #include "vec3.hpp"
99 #include "vec4.hpp"
100 #include "mat2x2.hpp"
101 #include "mat2x3.hpp"
102 #include "mat2x4.hpp"
103 #include "mat3x2.hpp"
104 #include "mat3x3.hpp"
105 #include "mat3x4.hpp"
106 #include "mat4x2.hpp"
107 #include "mat4x3.hpp"
108 #include "mat4x4.hpp"
109 
110 #include "trigonometric.hpp"
111 #include "exponential.hpp"
112 #include "common.hpp"
113 #include "packing.hpp"
114 #include "geometric.hpp"
115 #include "matrix.hpp"
116 #include "vector_relational.hpp"
117 #include "integer.hpp"
exponential.hpp
OpenGL Mathematics (glm.g-truc.net)
geometric.hpp
OpenGL Mathematics (glm.g-truc.net)
vec2.hpp
OpenGL Mathematics (glm.g-truc.net)
vector_relational.hpp
OpenGL Mathematics (glm.g-truc.net)
packing.hpp
OpenGL Mathematics (glm.g-truc.net)
mat2x3.hpp
OpenGL Mathematics (glm.g-truc.net)
mat4x2.hpp
OpenGL Mathematics (glm.g-truc.net)
mat3x3.hpp
OpenGL Mathematics (glm.g-truc.net)
matrix.hpp
OpenGL Mathematics (glm.g-truc.net)
vec4.hpp
OpenGL Mathematics (glm.g-truc.net)
mat3x4.hpp
OpenGL Mathematics (glm.g-truc.net)
fwd.hpp
OpenGL Mathematics (glm.g-truc.net)
mat3x2.hpp
OpenGL Mathematics (glm.g-truc.net)
common.hpp
OpenGL Mathematics (glm.g-truc.net)
trigonometric.hpp
OpenGL Mathematics (glm.g-truc.net)
mat2x2.hpp
OpenGL Mathematics (glm.g-truc.net)
integer.hpp
OpenGL Mathematics (glm.g-truc.net)
mat4x4.hpp
OpenGL Mathematics (glm.g-truc.net)
vec3.hpp
OpenGL Mathematics (glm.g-truc.net)
mat2x4.hpp
OpenGL Mathematics (glm.g-truc.net)
_fixes.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00041.html000066400000000000000000000141601356361734700216410ustar00rootroot00000000000000 0.9.7: gradient_paint.hpp File Reference
Functions
gradient_paint.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P>
GLM_FUNC_DECL T linearGradient (tvec2< T, P > const &Point0, tvec2< T, P > const &Point1, tvec2< T, P > const &Position)
 
template<typename T , precision P>
GLM_FUNC_DECL T radialGradient (tvec2< T, P > const &Center, T const &Radius, tvec2< T, P > const &Focal, tvec2< T, P > const &Position)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_gradient_paint

Date
2009-03-06 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTX_optimum_pow (dependence)

Definition in file gradient_paint.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00041_source.html000066400000000000000000000174451356361734700232320ustar00rootroot00000000000000 0.9.7: gradient_paint.hpp Source File
gradient_paint.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../glm.hpp"
46 #include "../gtx/optimum_pow.hpp"
47 
48 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
49 # pragma message("GLM: GLM_GTX_gradient_paint extension included")
50 #endif
51 
52 namespace glm
53 {
56 
59  template <typename T, precision P>
60  GLM_FUNC_DECL T radialGradient(
61  tvec2<T, P> const & Center,
62  T const & Radius,
63  tvec2<T, P> const & Focal,
64  tvec2<T, P> const & Position);
65 
68  template <typename T, precision P>
69  GLM_FUNC_DECL T linearGradient(
70  tvec2<T, P> const & Point0,
71  tvec2<T, P> const & Point1,
72  tvec2<T, P> const & Position);
73 
75 }// namespace glm
76 
77 #include "gradient_paint.inl"
glm::linearGradient
GLM_FUNC_DECL T linearGradient(tvec2< T, P > const &Point0, tvec2< T, P > const &Point1, tvec2< T, P > const &Position)
Return a color from a linear gradient.
glm
Definition: _noise.hpp:40
glm::radialGradient
GLM_FUNC_DECL T radialGradient(tvec2< T, P > const &Center, T const &Radius, tvec2< T, P > const &Focal, tvec2< T, P > const &Position)
Return a color from a radial gradient.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00042.html000066400000000000000000000137741356361734700216540ustar00rootroot00000000000000 0.9.7: handed_coordinate_space.hpp File Reference
Functions
handed_coordinate_space.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P>
GLM_FUNC_DECL bool leftHanded (tvec3< T, P > const &tangent, tvec3< T, P > const &binormal, tvec3< T, P > const &normal)
 
template<typename T , precision P>
GLM_FUNC_DECL bool rightHanded (tvec3< T, P > const &tangent, tvec3< T, P > const &binormal, tvec3< T, P > const &normal)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_handed_coordinate_space

Date
2005-12-21 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file handed_coordinate_space.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00042_source.html000066400000000000000000000171011356361734700232200ustar00rootroot00000000000000 0.9.7: handed_coordinate_space.hpp Source File
handed_coordinate_space.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../glm.hpp"
46 
47 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
48 # pragma message("GLM: GLM_GTX_handed_coordinate_space extension included")
49 #endif
50 
51 namespace glm
52 {
55 
58  template <typename T, precision P>
59  GLM_FUNC_DECL bool rightHanded(
60  tvec3<T, P> const & tangent,
61  tvec3<T, P> const & binormal,
62  tvec3<T, P> const & normal);
63 
66  template <typename T, precision P>
67  GLM_FUNC_DECL bool leftHanded(
68  tvec3<T, P> const & tangent,
69  tvec3<T, P> const & binormal,
70  tvec3<T, P> const & normal);
71 
73 }// namespace glm
74 
75 #include "handed_coordinate_space.inl"
glm::rightHanded
GLM_FUNC_DECL bool rightHanded(tvec3< T, P > const &tangent, tvec3< T, P > const &binormal, tvec3< T, P > const &normal)
Return if a trihedron right handed or not.
glm::leftHanded
GLM_FUNC_DECL bool leftHanded(tvec3< T, P > const &tangent, tvec3< T, P > const &binormal, tvec3< T, P > const &normal)
Return if a trihedron left handed or not.
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00043.html000066400000000000000000000106611356361734700216450ustar00rootroot00000000000000 0.9.7: hash.hpp File Reference
hash.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_hash

Date
2015-03-07 / 2015-03-07
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file hash.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00043_source.html000066400000000000000000000517751356361734700232400ustar00rootroot00000000000000 0.9.7: hash.hpp Source File
hash.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 #if !GLM_HAS_CXX11_STL
45 # error "GLM_GTX_hash requires C++11 standard library support"
46 #endif
47 
48 #include <functional>
49 
50 #include "../vec2.hpp"
51 #include "../vec3.hpp"
52 #include "../vec4.hpp"
53 #include "../gtc/vec1.hpp"
54 
55 #include "../gtc/quaternion.hpp"
56 #include "../gtx/dual_quaternion.hpp"
57 
58 #include "../mat2x2.hpp"
59 #include "../mat2x3.hpp"
60 #include "../mat2x4.hpp"
61 
62 #include "../mat3x2.hpp"
63 #include "../mat3x3.hpp"
64 #include "../mat3x4.hpp"
65 
66 #include "../mat4x2.hpp"
67 #include "../mat4x3.hpp"
68 #include "../mat4x4.hpp"
69 
70 namespace std
71 {
72  template <typename T, glm::precision P>
73  struct hash<glm::tvec1<T,P>>
74  {
75  GLM_FUNC_DECL size_t operator()(const glm::tvec1<T,P> &v) const;
76  };
77 
78  template <typename T, glm::precision P>
79  struct hash<glm::tvec2<T,P>>
80  {
81  GLM_FUNC_DECL size_t operator()(const glm::tvec2<T,P> &v) const;
82  };
83 
84  template <typename T, glm::precision P>
85  struct hash<glm::tvec3<T,P>>
86  {
87  GLM_FUNC_DECL size_t operator()(const glm::tvec3<T,P> &v) const;
88  };
89 
90  template <typename T, glm::precision P>
91  struct hash<glm::tvec4<T,P>>
92  {
93  GLM_FUNC_DECL size_t operator()(const glm::tvec4<T,P> &v) const;
94  };
95 
96  template <typename T, glm::precision P>
97  struct hash<glm::tquat<T,P>>
98  {
99  GLM_FUNC_DECL size_t operator()(const glm::tquat<T,P> &q) const;
100  };
101 
102  template <typename T, glm::precision P>
103  struct hash<glm::tdualquat<T,P>>
104  {
105  GLM_FUNC_DECL size_t operator()(const glm::tdualquat<T,P> &q) const;
106  };
107 
108  template <typename T, glm::precision P>
109  struct hash<glm::tmat2x2<T,P>>
110  {
111  GLM_FUNC_DECL size_t operator()(const glm::tmat2x2<T,P> &m) const;
112  };
113 
114  template <typename T, glm::precision P>
115  struct hash<glm::tmat2x3<T,P>>
116  {
117  GLM_FUNC_DECL size_t operator()(const glm::tmat2x3<T,P> &m) const;
118  };
119 
120  template <typename T, glm::precision P>
121  struct hash<glm::tmat2x4<T,P>>
122  {
123  GLM_FUNC_DECL size_t operator()(const glm::tmat2x4<T,P> &m) const;
124  };
125 
126  template <typename T, glm::precision P>
127  struct hash<glm::tmat3x2<T,P>>
128  {
129  GLM_FUNC_DECL size_t operator()(const glm::tmat3x2<T,P> &m) const;
130  };
131 
132  template <typename T, glm::precision P>
133  struct hash<glm::tmat3x3<T,P>>
134  {
135  GLM_FUNC_DECL size_t operator()(const glm::tmat3x3<T,P> &m) const;
136  };
137 
138  template <typename T, glm::precision P>
139  struct hash<glm::tmat3x4<T,P>>
140  {
141  GLM_FUNC_DECL size_t operator()(const glm::tmat3x4<T,P> &m) const;
142  };
143 
144  template <typename T, glm::precision P>
145  struct hash<glm::tmat4x2<T,P>>
146  {
147  GLM_FUNC_DECL size_t operator()(const glm::tmat4x2<T,P> &m) const;
148  };
149 
150  template <typename T, glm::precision P>
151  struct hash<glm::tmat4x3<T,P>>
152  {
153  GLM_FUNC_DECL size_t operator()(const glm::tmat4x3<T,P> &m) const;
154  };
155 
156  template <typename T, glm::precision P>
157  struct hash<glm::tmat4x4<T,P>>
158  {
159  GLM_FUNC_DECL size_t operator()(const glm::tmat4x4<T,P> &m) const;
160  };
161 } // namespace std
162 
163 #include "hash.inl"
std
Definition: hash.hpp:70
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00044.html000066400000000000000000000162271356361734700216520ustar00rootroot00000000000000 0.9.7: integer.hpp File Reference
Functions
gtc/integer.hpp File Reference

Go to the source code of this file.

Functions

template<typename genIUType >
GLM_FUNC_DECL genIUType log2 (genIUType x)
 
template<typename genIUType >
GLM_FUNC_DECL genIUType mod (genIUType x, genIUType y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > mod (vecType< T, P > const &x, T y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > mod (vecType< T, P > const &x, vecType< T, P > const &y)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTC_integer

Date
2014-11-17 / 2014-11-17
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTC_integer (dependence)

Definition in file gtc/integer.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00044_source.html000066400000000000000000000206721356361734700232310ustar00rootroot00000000000000 0.9.7: integer.hpp Source File
gtc/integer.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependencies
46 #include "../detail/setup.hpp"
47 #include "../detail/precision.hpp"
48 #include "../detail/func_common.hpp"
49 #include "../detail/func_integer.hpp"
50 #include "../detail/func_exponential.hpp"
51 #include <limits>
52 
53 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
54 # pragma message("GLM: GLM_GTC_integer extension included")
55 #endif
56 
57 namespace glm
58 {
61 
64  template <typename genIUType>
65  GLM_FUNC_DECL genIUType log2(genIUType x);
66 
75  template <typename genIUType>
76  GLM_FUNC_DECL genIUType mod(genIUType x, genIUType y);
77 
87  template <typename T, precision P, template <typename, precision> class vecType>
88  GLM_FUNC_DECL vecType<T, P> mod(vecType<T, P> const & x, T y);
89 
99  template <typename T, precision P, template <typename, precision> class vecType>
100  GLM_FUNC_DECL vecType<T, P> mod(vecType<T, P> const & x, vecType<T, P> const & y);
101 
103 } //namespace glm
104 
105 #include "integer.inl"
glm::log2
GLM_FUNC_DECL genIUType log2(genIUType x)
Returns the log2 of x for integer values.
glm
Definition: _noise.hpp:40
glm::mod
GLM_FUNC_DECL genIUType mod(genIUType x, genIUType y)
Modulus.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00045.html000066400000000000000000000214501356361734700216450ustar00rootroot00000000000000 0.9.7: integer.hpp File Reference
Typedefs | Functions
gtx/integer.hpp File Reference

Go to the source code of this file.

Typedefs

typedef signed int sint
 

Functions

template<typename genType >
GLM_FUNC_DECL genType factorial (genType const &x)
 
GLM_FUNC_DECL unsigned int floor_log2 (unsigned int x)
 
GLM_FUNC_DECL int mod (int x, int y)
 
GLM_FUNC_DECL uint mod (uint x, uint y)
 
GLM_FUNC_DECL uint nlz (uint x)
 
GLM_FUNC_DECL int pow (int x, int y)
 
GLM_FUNC_DECL uint pow (uint x, uint y)
 
GLM_FUNC_DECL int sqrt (int x)
 
GLM_FUNC_DECL uint sqrt (uint x)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_integer

Date
2005-12-24 / 2011-10-13
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file gtx/integer.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00045_source.html000066400000000000000000000273211356361734700232300ustar00rootroot00000000000000 0.9.7: integer.hpp Source File
gtx/integer.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../glm.hpp"
46 #include "../gtc/integer.hpp"
47 
48 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
49 # pragma message("GLM: GLM_GTX_integer extension included")
50 #endif
51 
52 namespace glm
53 {
56 
59  GLM_FUNC_DECL int pow(int x, int y);
60 
63  GLM_FUNC_DECL int sqrt(int x);
64 
67  GLM_FUNC_DECL unsigned int floor_log2(unsigned int x);
68 
71  GLM_FUNC_DECL int mod(int x, int y);
72 
75  template <typename genType>
76  GLM_FUNC_DECL genType factorial(genType const & x);
77 
80  typedef signed int sint;
81 
84  GLM_FUNC_DECL uint pow(uint x, uint y);
85 
88  GLM_FUNC_DECL uint sqrt(uint x);
89 
92  GLM_FUNC_DECL uint mod(uint x, uint y);
93 
96  GLM_FUNC_DECL uint nlz(uint x);
97 
99 }//namespace glm
100 
101 #include "integer.inl"
glm::pow
GLM_FUNC_DECL uint pow(uint x, uint y)
Returns x raised to the y power.
glm::sint
signed int sint
32bit signed integer.
Definition: gtx/integer.hpp:80
glm::uint
unsigned int uint
Unsigned integer type.
Definition: type_int.hpp:308
glm
Definition: _noise.hpp:40
glm::sqrt
GLM_FUNC_DECL uint sqrt(uint x)
Returns the positive square root of x.
glm::factorial
GLM_FUNC_DECL genType factorial(genType const &x)
Return the factorial value of a number (!12 max, integer only) From GLM_GTX_integer extension...
glm::mod
GLM_FUNC_DECL uint mod(uint x, uint y)
Modulus.
glm::floor_log2
GLM_FUNC_DECL unsigned int floor_log2(unsigned int x)
Returns the floor log2 of x.
glm::nlz
GLM_FUNC_DECL uint nlz(uint x)
Returns the number of leading zeros.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00046.html000066400000000000000000000101711356361734700216440ustar00rootroot00000000000000 0.9.7: integer.hpp File Reference
integer.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-12-24 / 2013-12-24
Author
Christophe Riccio

Definition in file integer.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00046_source.html000066400000000000000000000062551356361734700232340ustar00rootroot00000000000000 0.9.7: integer.hpp Source File
integer.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "detail/func_integer.hpp"
func_integer.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00047.html000066400000000000000000000222261356361734700216510ustar00rootroot00000000000000 0.9.7: intersect.hpp File Reference
Functions
intersect.hpp File Reference

Go to the source code of this file.

Functions

template<typename genType >
GLM_FUNC_DECL bool intersectLineSphere (genType const &point0, genType const &point1, genType const &sphereCenter, typename genType::value_type sphereRadius, genType &intersectionPosition1, genType &intersectionNormal1, genType &intersectionPosition2=genType(), genType &intersectionNormal2=genType())
 
template<typename genType >
GLM_FUNC_DECL bool intersectLineTriangle (genType const &orig, genType const &dir, genType const &vert0, genType const &vert1, genType const &vert2, genType &position)
 
template<typename genType >
GLM_FUNC_DECL bool intersectRayPlane (genType const &orig, genType const &dir, genType const &planeOrig, genType const &planeNormal, typename genType::value_type &intersectionDistance)
 
template<typename genType >
GLM_FUNC_DECL bool intersectRaySphere (genType const &rayStarting, genType const &rayNormalizedDirection, genType const &sphereCenter, typename genType::value_type const sphereRadiusSquered, typename genType::value_type &intersectionDistance)
 
template<typename genType >
GLM_FUNC_DECL bool intersectRaySphere (genType const &rayStarting, genType const &rayNormalizedDirection, genType const &sphereCenter, const typename genType::value_type sphereRadius, genType &intersectionPosition, genType &intersectionNormal)
 
template<typename genType >
GLM_FUNC_DECL bool intersectRayTriangle (genType const &orig, genType const &dir, genType const &vert0, genType const &vert1, genType const &vert2, genType &baryPosition)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_intersect

Date
2007-04-03 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTX_closest_point (dependence)

Definition in file intersect.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00047_source.html000066400000000000000000000345141356361734700232340ustar00rootroot00000000000000 0.9.7: intersect.hpp Source File
intersect.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependency:
46 #include "../glm.hpp"
47 #include "../gtx/closest_point.hpp"
48 
49 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
50 # pragma message("GLM: GLM_GTX_closest_point extension included")
51 #endif
52 
53 namespace glm
54 {
57 
61  template <typename genType>
62  GLM_FUNC_DECL bool intersectRayPlane(
63  genType const & orig, genType const & dir,
64  genType const & planeOrig, genType const & planeNormal,
65  typename genType::value_type & intersectionDistance);
66 
69  template <typename genType>
70  GLM_FUNC_DECL bool intersectRayTriangle(
71  genType const & orig, genType const & dir,
72  genType const & vert0, genType const & vert1, genType const & vert2,
73  genType & baryPosition);
74 
77  template <typename genType>
78  GLM_FUNC_DECL bool intersectLineTriangle(
79  genType const & orig, genType const & dir,
80  genType const & vert0, genType const & vert1, genType const & vert2,
81  genType & position);
82 
86  template <typename genType>
87  GLM_FUNC_DECL bool intersectRaySphere(
88  genType const & rayStarting, genType const & rayNormalizedDirection,
89  genType const & sphereCenter, typename genType::value_type const sphereRadiusSquered,
90  typename genType::value_type & intersectionDistance);
91 
94  template <typename genType>
95  GLM_FUNC_DECL bool intersectRaySphere(
96  genType const & rayStarting, genType const & rayNormalizedDirection,
97  genType const & sphereCenter, const typename genType::value_type sphereRadius,
98  genType & intersectionPosition, genType & intersectionNormal);
99 
102  template <typename genType>
103  GLM_FUNC_DECL bool intersectLineSphere(
104  genType const & point0, genType const & point1,
105  genType const & sphereCenter, typename genType::value_type sphereRadius,
106  genType & intersectionPosition1, genType & intersectionNormal1,
107  genType & intersectionPosition2 = genType(), genType & intersectionNormal2 = genType());
108 
110 }//namespace glm
111 
112 #include "intersect.inl"
glm::intersectRayTriangle
GLM_FUNC_DECL bool intersectRayTriangle(genType const &orig, genType const &dir, genType const &vert0, genType const &vert1, genType const &vert2, genType &baryPosition)
Compute the intersection of a ray and a triangle.
glm::intersectRaySphere
GLM_FUNC_DECL bool intersectRaySphere(genType const &rayStarting, genType const &rayNormalizedDirection, genType const &sphereCenter, const typename genType::value_type sphereRadius, genType &intersectionPosition, genType &intersectionNormal)
Compute the intersection of a ray and a sphere.
glm
Definition: _noise.hpp:40
glm::intersectRayPlane
GLM_FUNC_DECL bool intersectRayPlane(genType const &orig, genType const &dir, genType const &planeOrig, genType const &planeNormal, typename genType::value_type &intersectionDistance)
Compute the intersection of a ray and a plane.
glm::intersectLineTriangle
GLM_FUNC_DECL bool intersectLineTriangle(genType const &orig, genType const &dir, genType const &vert0, genType const &vert1, genType const &vert2, genType &position)
Compute the intersection of a line and a triangle.
glm::intersectLineSphere
GLM_FUNC_DECL bool intersectLineSphere(genType const &point0, genType const &point1, genType const &sphereCenter, typename genType::value_type sphereRadius, genType &intersectionPosition1, genType &intersectionNormal1, genType &intersectionPosition2=genType(), genType &intersectionNormal2=genType())
Compute the intersection of a line and a sphere.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00048.html000066400000000000000000000126411356361734700216520ustar00rootroot00000000000000 0.9.7: intrinsic_common.hpp File Reference
intrinsic_common.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2009-05-11 / 2011-06-15
Author
Christophe Riccio

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2009-06-05 / 2011-06-15
Author
Christophe Riccio

Definition in file intrinsic_common.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00048_source.html000066400000000000000000000233411356361734700232310ustar00rootroot00000000000000 0.9.7: intrinsic_common.hpp Source File
intrinsic_common.hpp
Go to the documentation of this file.
1 
29 #pragma once
30 
31 #include "setup.hpp"
32 
33 #if(!(GLM_ARCH & GLM_ARCH_SSE2))
34 # error "SSE2 instructions not supported or enabled"
35 #else
36 
37 namespace glm{
38 namespace detail
39 {
40  __m128 sse_abs_ps(__m128 x);
41 
42  __m128 sse_sgn_ps(__m128 x);
43 
44  //floor
45  __m128 sse_flr_ps(__m128 v);
46 
47  //trunc
48  __m128 sse_trc_ps(__m128 v);
49 
50  //round
51  __m128 sse_nd_ps(__m128 v);
52 
53  //roundEven
54  __m128 sse_rde_ps(__m128 v);
55 
56  __m128 sse_rnd_ps(__m128 x);
57 
58  __m128 sse_ceil_ps(__m128 v);
59 
60  __m128 sse_frc_ps(__m128 x);
61 
62  __m128 sse_mod_ps(__m128 x, __m128 y);
63 
64  __m128 sse_modf_ps(__m128 x, __m128i & i);
65 
66  //GLM_FUNC_QUALIFIER __m128 sse_min_ps(__m128 x, __m128 y)
67 
68  //GLM_FUNC_QUALIFIER __m128 sse_max_ps(__m128 x, __m128 y)
69 
70  __m128 sse_clp_ps(__m128 v, __m128 minVal, __m128 maxVal);
71 
72  __m128 sse_mix_ps(__m128 v1, __m128 v2, __m128 a);
73 
74  __m128 sse_stp_ps(__m128 edge, __m128 x);
75 
76  __m128 sse_ssp_ps(__m128 edge0, __m128 edge1, __m128 x);
77 
78  __m128 sse_nan_ps(__m128 x);
79 
80  __m128 sse_inf_ps(__m128 x);
81 
82 }//namespace detail
83 }//namespace glm
84 
85 #include "intrinsic_common.inl"
86 
87 #endif//GLM_ARCH
glm
Definition: _noise.hpp:40
setup.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00049.html000066400000000000000000000102271356361734700216510ustar00rootroot00000000000000 0.9.7: intrinsic_exponential.hpp File Reference
intrinsic_exponential.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2009-05-11 / 2011-06-15
Author
Christophe Riccio

Definition in file intrinsic_exponential.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00049_source.html000066400000000000000000000236541356361734700232410ustar00rootroot00000000000000 0.9.7: intrinsic_exponential.hpp Source File
intrinsic_exponential.hpp
Go to the documentation of this file.
1 
29 #pragma once
30 
31 #include "setup.hpp"
32 
33 #if(!(GLM_ARCH & GLM_ARCH_SSE2))
34 # error "SSE2 instructions not supported or enabled"
35 #else
36 
37 namespace glm{
38 namespace detail
39 {
40 /*
41 GLM_FUNC_QUALIFIER __m128 sse_rsqrt_nr_ss(__m128 const x)
42 {
43  __m128 recip = _mm_rsqrt_ss( x ); // "estimate" opcode
44  const static __m128 three = { 3, 3, 3, 3 }; // aligned consts for fast load
45  const static __m128 half = { 0.5,0.5,0.5,0.5 };
46  __m128 halfrecip = _mm_mul_ss( half, recip );
47  __m128 threeminus_xrr = _mm_sub_ss( three, _mm_mul_ss( x, _mm_mul_ss ( recip, recip ) ) );
48  return _mm_mul_ss( halfrecip, threeminus_xrr );
49 }
50 
51 GLM_FUNC_QUALIFIER __m128 sse_normalize_fast_ps( float * RESTRICT vOut, float * RESTRICT vIn )
52 {
53  __m128 x = _mm_load_ss(&vIn[0]);
54  __m128 y = _mm_load_ss(&vIn[1]);
55  __m128 z = _mm_load_ss(&vIn[2]);
56 
57  const __m128 l = // compute x*x + y*y + z*z
58  _mm_add_ss(
59  _mm_add_ss( _mm_mul_ss(x,x),
60  _mm_mul_ss(y,y)
61  ),
62  _mm_mul_ss( z, z )
63  );
64 
65 
66  const __m128 rsqt = _mm_rsqrt_nr_ss( l );
67  _mm_store_ss( &vOut[0] , _mm_mul_ss( rsqt, x ) );
68  _mm_store_ss( &vOut[1] , _mm_mul_ss( rsqt, y ) );
69  _mm_store_ss( &vOut[2] , _mm_mul_ss( rsqt, z ) );
70 
71  return _mm_mul_ss( l , rsqt );
72 }
73 */
74 }//namespace detail
75 }//namespace glm
76 
77 #endif//GLM_ARCH
glm
Definition: _noise.hpp:40
setup.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00050.html000066400000000000000000000102211356361734700216330ustar00rootroot00000000000000 0.9.7: intrinsic_geometric.hpp File Reference
intrinsic_geometric.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2009-05-08 / 2011-06-15
Author
Christophe Riccio

Definition in file intrinsic_geometric.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00050_source.html000066400000000000000000000212611356361734700232210ustar00rootroot00000000000000 0.9.7: intrinsic_geometric.hpp Source File
intrinsic_geometric.hpp
Go to the documentation of this file.
1 
29 #pragma once
30 
31 #include "setup.hpp"
32 
33 #if(!(GLM_ARCH & GLM_ARCH_SSE2))
34 # error "SSE2 instructions not supported or enabled"
35 #else
36 
37 #include "intrinsic_common.hpp"
38 
39 namespace glm{
40 namespace detail
41 {
42  //length
43  __m128 sse_len_ps(__m128 x);
44 
45  //distance
46  __m128 sse_dst_ps(__m128 p0, __m128 p1);
47 
48  //dot
49  __m128 sse_dot_ps(__m128 v1, __m128 v2);
50 
51  // SSE1
52  __m128 sse_dot_ss(__m128 v1, __m128 v2);
53 
54  //cross
55  __m128 sse_xpd_ps(__m128 v1, __m128 v2);
56 
57  //normalize
58  __m128 sse_nrm_ps(__m128 v);
59 
60  //faceforward
61  __m128 sse_ffd_ps(__m128 N, __m128 I, __m128 Nref);
62 
63  //reflect
64  __m128 sse_rfe_ps(__m128 I, __m128 N);
65 
66  //refract
67  __m128 sse_rfa_ps(__m128 I, __m128 N, __m128 eta);
68 
69 }//namespace detail
70 }//namespace glm
71 
72 #include "intrinsic_geometric.inl"
73 
74 #endif//GLM_ARCH
glm
Definition: _noise.hpp:40
setup.hpp
OpenGL Mathematics (glm.g-truc.net)
intrinsic_common.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00051.html000066400000000000000000000102131356361734700216350ustar00rootroot00000000000000 0.9.7: intrinsic_integer.hpp File Reference
intrinsic_integer.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2009-05-11 / 2011-06-15
Author
Christophe Riccio

Definition in file intrinsic_integer.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00051_source.html000066400000000000000000000130251356361734700232210ustar00rootroot00000000000000 0.9.7: intrinsic_integer.hpp Source File
intrinsic_integer.hpp
Go to the documentation of this file.
1 
29 #pragma once
30 
31 #include "glm/glm.hpp"
32 
33 #if(!(GLM_ARCH & GLM_ARCH_SSE2))
34 # error "SSE2 instructions not supported or enabled"
35 #else
36 
37 namespace glm{
38 namespace detail
39 {
40  __m128i _mm_bit_interleave_si128(__m128i x);
41  __m128i _mm_bit_interleave_si128(__m128i x, __m128i y);
42 
43 }//namespace detail
44 }//namespace glm
45 
46 #include "intrinsic_integer.inl"
47 
48 #endif//GLM_ARCH
glm
Definition: _noise.hpp:40
glm.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00052_source.html000066400000000000000000000204761356361734700232320ustar00rootroot00000000000000 0.9.7: intrinsic_matrix.hpp Source File
intrinsic_matrix.hpp
1 
29 #pragma once
30 
31 #include "setup.hpp"
32 
33 #if(!(GLM_ARCH & GLM_ARCH_SSE2))
34 # error "SSE2 instructions not supported or enabled"
35 #else
36 
37 #include "intrinsic_geometric.hpp"
38 
39 namespace glm{
40 namespace detail
41 {
42  void sse_add_ps(__m128 in1[4], __m128 in2[4], __m128 out[4]);
43 
44  void sse_sub_ps(__m128 in1[4], __m128 in2[4], __m128 out[4]);
45 
46  __m128 sse_mul_ps(__m128 m[4], __m128 v);
47 
48  __m128 sse_mul_ps(__m128 v, __m128 m[4]);
49 
50  void sse_mul_ps(__m128 const in1[4], __m128 const in2[4], __m128 out[4]);
51 
52  void sse_transpose_ps(__m128 const in[4], __m128 out[4]);
53 
54  void sse_inverse_ps(__m128 const in[4], __m128 out[4]);
55 
56  void sse_rotate_ps(__m128 const in[4], float Angle, float const v[3], __m128 out[4]);
57 
58  __m128 sse_det_ps(__m128 const m[4]);
59 
60  __m128 sse_slow_det_ps(__m128 const m[4]);
61 
62 }//namespace detail
63 }//namespace glm
64 
65 #include "intrinsic_matrix.inl"
66 
67 #endif//GLM_ARCH
intrinsic_geometric.hpp
OpenGL Mathematics (glm.g-truc.net)
glm
Definition: _noise.hpp:40
setup.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00053.html000066400000000000000000000102351356361734700216430ustar00rootroot00000000000000 0.9.7: intrinsic_trigonometric.hpp File Reference
intrinsic_trigonometric.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2009-06-09 / 2011-06-15
Author
Christophe Riccio

Definition in file intrinsic_trigonometric.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00053_source.html000066400000000000000000000124121356361734700232220ustar00rootroot00000000000000 0.9.7: intrinsic_trigonometric.hpp Source File
intrinsic_trigonometric.hpp
Go to the documentation of this file.
1 
29 #pragma once
30 
31 #include "setup.hpp"
32 
33 #if(!(GLM_ARCH & GLM_ARCH_SSE2))
34 # error "SSE2 instructions not supported or enabled"
35 #else
36 
37 namespace glm{
38 namespace detail
39 {
40 
41 }//namespace detail
42 }//namespace glm
43 
44 #include "intrinsic_trigonometric.inl"
45 
46 #endif//GLM_ARCH
glm
Definition: _noise.hpp:40
setup.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00054.html000066400000000000000000000102511356361734700216420ustar00rootroot00000000000000 0.9.7: intrinsic_vector_relational.hpp File Reference
intrinsic_vector_relational.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2009-06-09 / 2011-06-15
Author
Christophe Riccio

Definition in file intrinsic_vector_relational.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00054_source.html000066400000000000000000000124261356361734700232300ustar00rootroot00000000000000 0.9.7: intrinsic_vector_relational.hpp Source File
intrinsic_vector_relational.hpp
Go to the documentation of this file.
1 
29 #pragma once
30 
31 #include "setup.hpp"
32 
33 #if(!(GLM_ARCH & GLM_ARCH_SSE2))
34 # error "SSE2 instructions not supported or enabled"
35 #else
36 
37 namespace glm{
38 namespace detail
39 {
40 
41 }//namespace detail
42 }//namespace glm
43 
44 #include "intrinsic_vector_relational.inl"
45 
46 #endif//GLM_ARCH
glm
Definition: _noise.hpp:40
setup.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00055.html000066400000000000000000000115731356361734700216530ustar00rootroot00000000000000 0.9.7: io.hpp File Reference
io.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_io

Date
2013-11-22 / 2014-11-25
Author
Jan P Springer (regni.nosp@m.rpsj.nosp@m.@gmai.nosp@m.l.co.nosp@m.m)
See also
GLM Core (dependence)
GLM_GTC_quaternion (dependence)

Definition in file io.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00055_source.html000066400000000000000000001006411356361734700232260ustar00rootroot00000000000000 0.9.7: io.hpp Source File
io.hpp
Go to the documentation of this file.
1 
47 #pragma once
48 
49 // Dependency:
50 #include "../glm.hpp"
51 #include "../gtx/quaternion.hpp"
52 
53 #if(defined(GLM_MESSAGES) && !defined(glm_ext))
54 # pragma message("GLM: GLM_GTX_io extension included")
55 #endif
56 
57 #include <iosfwd> // std::basic_ostream<> (fwd)
58 #include <locale> // std::locale, std::locale::facet, std::locale::id
59 #include <utility> // std::pair<>
60 
61 namespace glm
62 {
65 
66  namespace io
67  {
68  enum order_type { column_major, row_major};
69 
70  template <typename CTy>
71  class format_punct : public std::locale::facet
72  {
73  typedef CTy char_type;
74 
75  public:
76 
77  static std::locale::id id;
78 
79  bool formatted;
80  unsigned precision;
81  unsigned width;
82  char_type separator;
83  char_type delim_left;
84  char_type delim_right;
85  char_type space;
86  char_type newline;
87  order_type order;
88 
89  explicit format_punct(size_t a = 0);
90  explicit format_punct(format_punct const&);
91  };
92 
93  template <typename CTy, typename CTr = std::char_traits<CTy> >
94  class basic_state_saver {
95 
96  public:
97 
98  explicit basic_state_saver(std::basic_ios<CTy,CTr>&);
99  ~basic_state_saver();
100 
101  private:
102 
103  typedef ::std::basic_ios<CTy,CTr> state_type;
104  typedef typename state_type::char_type char_type;
105  typedef ::std::ios_base::fmtflags flags_type;
106  typedef ::std::streamsize streamsize_type;
107  typedef ::std::locale const locale_type;
108 
109  state_type& state_;
110  flags_type flags_;
111  streamsize_type precision_;
112  streamsize_type width_;
113  char_type fill_;
114  locale_type locale_;
115 
116  basic_state_saver& operator=(basic_state_saver const&);
117  };
118 
119  typedef basic_state_saver<char> state_saver;
120  typedef basic_state_saver<wchar_t> wstate_saver;
121 
122  template <typename CTy, typename CTr = std::char_traits<CTy> >
123  class basic_format_saver
124  {
125  public:
126 
127  explicit basic_format_saver(std::basic_ios<CTy,CTr>&);
128  ~basic_format_saver();
129 
130  private:
131 
132  basic_state_saver<CTy> const bss_;
133 
134  basic_format_saver& operator=(basic_format_saver const&);
135  };
136 
137  typedef basic_format_saver<char> format_saver;
138  typedef basic_format_saver<wchar_t> wformat_saver;
139 
140  struct precision
141  {
142  unsigned value;
143 
144  explicit precision(unsigned);
145  };
146 
147  struct width
148  {
149  unsigned value;
150 
151  explicit width(unsigned);
152  };
153 
154  template <typename CTy>
155  struct delimeter
156  {
157  CTy value[3];
158 
159  explicit delimeter(CTy /* left */, CTy /* right */, CTy /* separator */ = ',');
160  };
161 
162  struct order
163  {
164  order_type value;
165 
166  explicit order(order_type);
167  };
168 
169  // functions, inlined (inline)
170 
171  template <typename FTy, typename CTy, typename CTr>
172  FTy const& get_facet(std::basic_ios<CTy,CTr>&);
173  template <typename FTy, typename CTy, typename CTr>
174  std::basic_ios<CTy,CTr>& formatted(std::basic_ios<CTy,CTr>&);
175  template <typename FTy, typename CTy, typename CTr>
176  std::basic_ios<CTy,CTr>& unformattet(std::basic_ios<CTy,CTr>&);
177 
178  template <typename CTy, typename CTr>
179  std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, precision const&);
180  template <typename CTy, typename CTr>
181  std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, width const&);
182  template <typename CTy, typename CTr>
183  std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, delimeter<CTy> const&);
184  template <typename CTy, typename CTr>
185  std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, order const&);
186  }//namespace io
187 
188  template <typename CTy, typename CTr, typename T, precision P>
189  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tquat<T,P> const&);
190  template <typename CTy, typename CTr, typename T, precision P>
191  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec1<T,P> const&);
192  template <typename CTy, typename CTr, typename T, precision P>
193  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec2<T,P> const&);
194  template <typename CTy, typename CTr, typename T, precision P>
195  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec3<T,P> const&);
196  template <typename CTy, typename CTr, typename T, precision P>
197  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec4<T,P> const&);
198  template <typename CTy, typename CTr, typename T, precision P>
199  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x2<T,P> const&);
200  template <typename CTy, typename CTr, typename T, precision P>
201  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x3<T,P> const&);
202  template <typename CTy, typename CTr, typename T, precision P>
203  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x4<T,P> const&);
204  template <typename CTy, typename CTr, typename T, precision P>
205  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x2<T,P> const&);
206  template <typename CTy, typename CTr, typename T, precision P>
207  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x3<T,P> const&);
208  template <typename CTy, typename CTr, typename T, precision P>
209  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x4<T,P> const&);
210  template <typename CTy, typename CTr, typename T, precision P>
211  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x2<T,P> const&);
212  template <typename CTy, typename CTr, typename T, precision P>
213  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x3<T,P> const&);
214  template <typename CTy, typename CTr, typename T, precision P>
215  GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x4<T,P> const&);
216 
217  template <typename CTy, typename CTr, typename T, precision P>
218  GLM_FUNC_DECL std::basic_ostream<CTy,CTr> & operator<<(
219  std::basic_ostream<CTy,CTr> &,
220  std::pair<tmat4x4<T,P> const,
221  tmat4x4<T,P> const> const &);
222 
223  template <typename CTy, typename CTr, typename T, precision P>
224  GLM_FUNC_DECL std::basic_ostream<CTy,CTr> & operator<<(
225  std::basic_ostream<CTy,CTr> &,
226  std::pair<tmat4x4<T,P>,
227  tmat4x4<T,P> > const &);
228 
230 }//namespace glm
231 
232 #include "io.inl"
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00056.html000066400000000000000000000135501356361734700216510ustar00rootroot00000000000000 0.9.7: log_base.hpp File Reference
Functions
log_base.hpp File Reference

Go to the source code of this file.

Functions

template<typename genType >
GLM_FUNC_DECL genType log (genType x, genType base)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > sign (vecType< T, P > const &x, vecType< T, P > const &base)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_log_base

Date
2008-10-24 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file log_base.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00056_source.html000066400000000000000000000157151356361734700232360ustar00rootroot00000000000000 0.9.7: log_base.hpp Source File
log_base.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../glm.hpp"
46 
47 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
48 # pragma message("GLM: GLM_GTX_log_base extension included")
49 #endif
50 
51 namespace glm
52 {
55 
58  template <typename genType>
59  GLM_FUNC_DECL genType log(
60  genType x,
61  genType base);
62 
65  template <typename T, precision P, template <typename, precision> class vecType>
66  GLM_FUNC_DECL vecType<T, P> sign(
67  vecType<T, P> const & x,
68  vecType<T, P> const & base);
69 
71 }//namespace glm
72 
73 #include "log_base.inl"
glm
Definition: _noise.hpp:40
glm::sign
GLM_FUNC_DECL vecType< T, P > sign(vecType< T, P > const &x, vecType< T, P > const &base)
Logarithm for any base.
glm::log
GLM_FUNC_DECL genType log(genType x, genType base)
Logarithm for any base.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00057_source.html000066400000000000000000013303561356361734700232410ustar00rootroot00000000000000 0.9.7: man.doxy Source File
man.doxy
1 # Doxyfile 1.8.10
2 
3 # This file describes the settings to be used by the documentation system
4 # doxygen (www.doxygen.org) for a project.
5 #
6 # All text after a double hash (##) is considered a comment and is placed in
7 # front of the TAG it is preceding.
8 #
9 # All text after a single hash (#) is considered a comment and will be ignored.
10 # The format is:
11 # TAG = value [value, ...]
12 # For lists, items can also be appended using:
13 # TAG += value [value, ...]
14 # Values that contain spaces should be placed between quotes (\" \").
15 
16 #---------------------------------------------------------------------------
17 # Project related configuration options
18 #---------------------------------------------------------------------------
19 
20 # This tag specifies the encoding used for all characters in the config file
21 # that follow. The default is UTF-8 which is also the encoding used for all text
22 # before the first occurrence of this tag. Doxygen uses libiconv (or the iconv
23 # built into libc) for the transcoding. See http://www.gnu.org/software/libiconv
24 # for the list of possible encodings.
25 # The default value is: UTF-8.
26 
27 DOXYFILE_ENCODING = UTF-8
28 
29 # The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
30 # double-quotes, unless you are using Doxywizard) that should identify the
31 # project for which the documentation is generated. This name is used in the
32 # title of most generated pages and in a few other places.
33 # The default value is: My Project.
34 
35 PROJECT_NAME = 0.9.7
36 
37 # The PROJECT_NUMBER tag can be used to enter a project or revision number. This
38 # could be handy for archiving the generated documentation or if some version
39 # control system is used.
40 
41 PROJECT_NUMBER =
42 
43 # Using the PROJECT_BRIEF tag one can provide an optional one line description
44 # for a project that appears at the top of each page and should give viewer a
45 # quick idea about the purpose of the project. Keep the description short.
46 
47 PROJECT_BRIEF =
48 
49 # With the PROJECT_LOGO tag one can specify a logo or an icon that is included
50 # in the documentation. The maximum height of the logo should not exceed 55
51 # pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
52 # the logo to the output directory.
53 
54 PROJECT_LOGO = E:/Source/G-Truc/glm/doc/logo.png
55 
56 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
57 # into which the generated documentation will be written. If a relative path is
58 # entered, it will be relative to the location where doxygen was started. If
59 # left blank the current directory will be used.
60 
61 OUTPUT_DIRECTORY = .
62 
63 # If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
64 # directories (in 2 levels) under the output directory of each output format and
65 # will distribute the generated files over these directories. Enabling this
66 # option can be useful when feeding doxygen a huge amount of source files, where
67 # putting all generated files in the same directory would otherwise causes
68 # performance problems for the file system.
69 # The default value is: NO.
70 
71 CREATE_SUBDIRS = NO
72 
73 # If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
74 # characters to appear in the names of generated files. If set to NO, non-ASCII
75 # characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
76 # U+3044.
77 # The default value is: NO.
78 
79 ALLOW_UNICODE_NAMES = NO
80 
81 # The OUTPUT_LANGUAGE tag is used to specify the language in which all
82 # documentation generated by doxygen is written. Doxygen will use this
83 # information to generate all constant output in the proper language.
84 # Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
85 # Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
86 # Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
87 # Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
88 # Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
89 # Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
90 # Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
91 # Ukrainian and Vietnamese.
92 # The default value is: English.
93 
94 OUTPUT_LANGUAGE = English
95 
96 # If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
97 # descriptions after the members that are listed in the file and class
98 # documentation (similar to Javadoc). Set to NO to disable this.
99 # The default value is: YES.
100 
101 BRIEF_MEMBER_DESC = NO
102 
103 # If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief
104 # description of a member or function before the detailed description
105 #
106 # Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
107 # brief descriptions will be completely suppressed.
108 # The default value is: YES.
109 
110 REPEAT_BRIEF = YES
111 
112 # This tag implements a quasi-intelligent brief description abbreviator that is
113 # used to form the text in various listings. Each string in this list, if found
114 # as the leading text of the brief description, will be stripped from the text
115 # and the result, after processing the whole list, is used as the annotated
116 # text. Otherwise, the brief description is used as-is. If left blank, the
117 # following values are used ($name is automatically replaced with the name of
118 # the entity):The $name class, The $name widget, The $name file, is, provides,
119 # specifies, contains, represents, a, an and the.
120 
121 ABBREVIATE_BRIEF = "The $name class " \
122  "The $name widget " \
123  "The $name file " \
124  is \
125  provides \
126  specifies \
127  contains \
128  represents \
129  a \
130  an \
131  the
132 
133 # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
134 # doxygen will generate a detailed section even if there is only a brief
135 # description.
136 # The default value is: NO.
137 
138 ALWAYS_DETAILED_SEC = NO
139 
140 # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
141 # inherited members of a class in the documentation of that class as if those
142 # members were ordinary class members. Constructors, destructors and assignment
143 # operators of the base classes will not be shown.
144 # The default value is: NO.
145 
146 INLINE_INHERITED_MEMB = NO
147 
148 # If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path
149 # before files name in the file list and in the header files. If set to NO the
150 # shortest path that makes the file name unique will be used
151 # The default value is: YES.
152 
153 FULL_PATH_NAMES = NO
154 
155 # The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
156 # Stripping is only done if one of the specified strings matches the left-hand
157 # part of the path. The tag can be used to show relative paths in the file list.
158 # If left blank the directory from which doxygen is run is used as the path to
159 # strip.
160 #
161 # Note that you can specify absolute paths here, but also relative paths, which
162 # will be relative from the directory where doxygen is started.
163 # This tag requires that the tag FULL_PATH_NAMES is set to YES.
164 
165 STRIP_FROM_PATH = "C:/Documents and Settings/Groove/ "
166 
167 # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
168 # path mentioned in the documentation of a class, which tells the reader which
169 # header file to include in order to use a class. If left blank only the name of
170 # the header file containing the class definition is used. Otherwise one should
171 # specify the list of include paths that are normally passed to the compiler
172 # using the -I flag.
173 
174 STRIP_FROM_INC_PATH =
175 
176 # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
177 # less readable) file names. This can be useful is your file systems doesn't
178 # support long names like on DOS, Mac, or CD-ROM.
179 # The default value is: NO.
180 
181 SHORT_NAMES = YES
182 
183 # If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
184 # first line (until the first dot) of a Javadoc-style comment as the brief
185 # description. If set to NO, the Javadoc-style will behave just like regular Qt-
186 # style comments (thus requiring an explicit @brief command for a brief
187 # description.)
188 # The default value is: NO.
189 
190 JAVADOC_AUTOBRIEF = YES
191 
192 # If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
193 # line (until the first dot) of a Qt-style comment as the brief description. If
194 # set to NO, the Qt-style will behave just like regular Qt-style comments (thus
195 # requiring an explicit \brief command for a brief description.)
196 # The default value is: NO.
197 
198 QT_AUTOBRIEF = NO
199 
200 # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
201 # multi-line C++ special comment block (i.e. a block of
202 # a brief description. This used to be the default behavior. The new default is
203 # to treat a multi-line C++ comment block as a detailed description. Set this
204 # tag to YES if you prefer the old behavior instead.
205 #
206 # Note that setting this tag to YES also means that rational rose comments are
207 # not recognized any more.
208 # The default value is: NO.
209 
210 MULTILINE_CPP_IS_BRIEF = NO
211 
212 # If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
213 # documentation from any documented member that it re-implements.
214 # The default value is: YES.
215 
216 INHERIT_DOCS = YES
217 
218 # If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new
219 # page for each member. If set to NO, the documentation of a member will be part
220 # of the file/class/namespace that contains it.
221 # The default value is: NO.
222 
223 SEPARATE_MEMBER_PAGES = NO
224 
225 # The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
226 # uses this value to replace tabs by spaces in code fragments.
227 # Minimum value: 1, maximum value: 16, default value: 4.
228 
229 TAB_SIZE = 8
230 
231 # This tag can be used to specify a number of aliases that act as commands in
232 # the documentation. An alias has the form:
233 # name=value
234 # For example adding
235 # "sideeffect=@par Side Effects:\n"
236 # will allow you to put the command \sideeffect (or @sideeffect) in the
237 # documentation, which will result in a user-defined paragraph with heading
238 # "Side Effects:". You can put \n's in the value part of an alias to insert
239 # newlines.
240 
241 ALIASES =
242 
243 # This tag can be used to specify a number of word-keyword mappings (TCL only).
244 # A mapping has the form "name=value". For example adding "class=itcl::class"
245 # will allow you to use the command class in the itcl::class meaning.
246 
247 TCL_SUBST =
248 
249 # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
250 # only. Doxygen will then generate output that is more tailored for C. For
251 # instance, some of the names that are used will be different. The list of all
252 # members will be omitted, etc.
253 # The default value is: NO.
254 
255 OPTIMIZE_OUTPUT_FOR_C = NO
256 
257 # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
258 # Python sources only. Doxygen will then generate output that is more tailored
259 # for that language. For instance, namespaces will be presented as packages,
260 # qualified scopes will look different, etc.
261 # The default value is: NO.
262 
263 OPTIMIZE_OUTPUT_JAVA = NO
264 
265 # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
266 # sources. Doxygen will then generate output that is tailored for Fortran.
267 # The default value is: NO.
268 
269 OPTIMIZE_FOR_FORTRAN = NO
270 
271 # Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
272 # sources. Doxygen will then generate output that is tailored for VHDL.
273 # The default value is: NO.
274 
275 OPTIMIZE_OUTPUT_VHDL = NO
276 
277 # Doxygen selects the parser to use depending on the extension of the files it
278 # parses. With this tag you can assign which parser to use for a given
279 # extension. Doxygen has a built-in mapping, but you can override or extend it
280 # using this tag. The format is ext=language, where ext is a file extension, and
281 # language is one of the parsers supported by doxygen: IDL, Java, Javascript,
282 # C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran:
283 # FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran:
284 # Fortran. In the later case the parser tries to guess whether the code is fixed
285 # or free formatted code, this is the default for Fortran type files), VHDL. For
286 # instance to make doxygen treat .inc files as Fortran files (default is PHP),
287 # and .f files as C (default is Fortran), use: inc=Fortran f=C.
288 #
289 # Note: For files without extension you can use no_extension as a placeholder.
290 #
291 # Note that for custom extensions you also need to set FILE_PATTERNS otherwise
292 # the files are not read by doxygen.
293 
294 EXTENSION_MAPPING =
295 
296 # If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
297 # according to the Markdown format, which allows for more readable
298 # documentation. See http://daringfireball.net/projects/markdown/ for details.
299 # The output of markdown processing is further processed by doxygen, so you can
300 # mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
301 # case of backward compatibilities issues.
302 # The default value is: YES.
303 
304 MARKDOWN_SUPPORT = YES
305 
306 # When enabled doxygen tries to link words that correspond to documented
307 # classes, or namespaces to their corresponding documentation. Such a link can
308 # be prevented in individual cases by putting a % sign in front of the word or
309 # globally by setting AUTOLINK_SUPPORT to NO.
310 # The default value is: YES.
311 
312 AUTOLINK_SUPPORT = YES
313 
314 # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
315 # to include (a tag file for) the STL sources as input, then you should set this
316 # tag to YES in order to let doxygen match functions declarations and
317 # definitions whose arguments contain STL classes (e.g. func(std::string);
318 # versus func(std::string) {}). This also make the inheritance and collaboration
319 # diagrams that involve STL classes more complete and accurate.
320 # The default value is: NO.
321 
322 BUILTIN_STL_SUPPORT = NO
323 
324 # If you use Microsoft's C++/CLI language, you should set this option to YES to
325 # enable parsing support.
326 # The default value is: NO.
327 
328 CPP_CLI_SUPPORT = NO
329 
330 # Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
331 # http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen
332 # will parse them like normal C++ but will assume all classes use public instead
333 # of private inheritance when no explicit protection keyword is present.
334 # The default value is: NO.
335 
336 SIP_SUPPORT = NO
337 
338 # For Microsoft's IDL there are propget and propput attributes to indicate
339 # getter and setter methods for a property. Setting this option to YES will make
340 # doxygen to replace the get and set methods by a property in the documentation.
341 # This will only work if the methods are indeed getting or setting a simple
342 # type. If this is not the case, or you want to show the methods anyway, you
343 # should set this option to NO.
344 # The default value is: YES.
345 
346 IDL_PROPERTY_SUPPORT = YES
347 
348 # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
349 # tag is set to YES then doxygen will reuse the documentation of the first
350 # member in the group (if any) for the other members of the group. By default
351 # all members of a group must be documented explicitly.
352 # The default value is: NO.
353 
354 DISTRIBUTE_GROUP_DOC = NO
355 
356 # If one adds a struct or class to a group and this option is enabled, then also
357 # any nested class or struct is added to the same group. By default this option
358 # is disabled and one has to add nested compounds explicitly via \ingroup.
359 # The default value is: NO.
360 
361 GROUP_NESTED_COMPOUNDS = NO
362 
363 # Set the SUBGROUPING tag to YES to allow class member groups of the same type
364 # (for instance a group of public functions) to be put as a subgroup of that
365 # type (e.g. under the Public Functions section). Set it to NO to prevent
366 # subgrouping. Alternatively, this can be done per class using the
367 # \nosubgrouping command.
368 # The default value is: YES.
369 
370 SUBGROUPING = NO
371 
372 # When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
373 # are shown inside the group in which they are included (e.g. using \ingroup)
374 # instead of on a separate page (for HTML and Man pages) or section (for LaTeX
375 # and RTF).
376 #
377 # Note that this feature does not work in combination with
378 # SEPARATE_MEMBER_PAGES.
379 # The default value is: NO.
380 
381 INLINE_GROUPED_CLASSES = NO
382 
383 # When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
384 # with only public data fields or simple typedef fields will be shown inline in
385 # the documentation of the scope in which they are defined (i.e. file,
386 # namespace, or group documentation), provided this scope is documented. If set
387 # to NO, structs, classes, and unions are shown on a separate page (for HTML and
388 # Man pages) or section (for LaTeX and RTF).
389 # The default value is: NO.
390 
391 INLINE_SIMPLE_STRUCTS = NO
392 
393 # When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
394 # enum is documented as struct, union, or enum with the name of the typedef. So
395 # typedef struct TypeS {} TypeT, will appear in the documentation as a struct
396 # with name TypeT. When disabled the typedef will appear as a member of a file,
397 # namespace, or class. And the struct will be named TypeS. This can typically be
398 # useful for C code in case the coding convention dictates that all compound
399 # types are typedef'ed and only the typedef is referenced, never the tag name.
400 # The default value is: NO.
401 
402 TYPEDEF_HIDES_STRUCT = NO
403 
404 # The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
405 # cache is used to resolve symbols given their name and scope. Since this can be
406 # an expensive process and often the same symbol appears multiple times in the
407 # code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
408 # doxygen will become slower. If the cache is too large, memory is wasted. The
409 # cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
410 # is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
411 # symbols. At the end of a run doxygen will report the cache usage and suggest
412 # the optimal cache size from a speed point of view.
413 # Minimum value: 0, maximum value: 9, default value: 0.
414 
415 LOOKUP_CACHE_SIZE = 0
416 
417 #---------------------------------------------------------------------------
418 # Build related configuration options
419 #---------------------------------------------------------------------------
420 
421 # If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in
422 # documentation are documented, even if no documentation was available. Private
423 # class members and static file members will be hidden unless the
424 # EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
425 # Note: This will also disable the warnings about undocumented members that are
426 # normally produced when WARNINGS is set to YES.
427 # The default value is: NO.
428 
429 EXTRACT_ALL = NO
430 
431 # If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will
432 # be included in the documentation.
433 # The default value is: NO.
434 
435 EXTRACT_PRIVATE = NO
436 
437 # If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
438 # scope will be included in the documentation.
439 # The default value is: NO.
440 
441 EXTRACT_PACKAGE = NO
442 
443 # If the EXTRACT_STATIC tag is set to YES, all static members of a file will be
444 # included in the documentation.
445 # The default value is: NO.
446 
447 EXTRACT_STATIC = YES
448 
449 # If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined
450 # locally in source files will be included in the documentation. If set to NO,
451 # only classes defined in header files are included. Does not have any effect
452 # for Java sources.
453 # The default value is: YES.
454 
455 EXTRACT_LOCAL_CLASSES = NO
456 
457 # This flag is only useful for Objective-C code. If set to YES, local methods,
458 # which are defined in the implementation section but not in the interface are
459 # included in the documentation. If set to NO, only methods in the interface are
460 # included.
461 # The default value is: NO.
462 
463 EXTRACT_LOCAL_METHODS = NO
464 
465 # If this flag is set to YES, the members of anonymous namespaces will be
466 # extracted and appear in the documentation as a namespace called
467 # 'anonymous_namespace{file}', where file will be replaced with the base name of
468 # the file that contains the anonymous namespace. By default anonymous namespace
469 # are hidden.
470 # The default value is: NO.
471 
472 EXTRACT_ANON_NSPACES = NO
473 
474 # If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
475 # undocumented members inside documented classes or files. If set to NO these
476 # members will be included in the various overviews, but no documentation
477 # section is generated. This option has no effect if EXTRACT_ALL is enabled.
478 # The default value is: NO.
479 
480 HIDE_UNDOC_MEMBERS = YES
481 
482 # If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
483 # undocumented classes that are normally visible in the class hierarchy. If set
484 # to NO, these classes will be included in the various overviews. This option
485 # has no effect if EXTRACT_ALL is enabled.
486 # The default value is: NO.
487 
488 HIDE_UNDOC_CLASSES = YES
489 
490 # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
491 # (class|struct|union) declarations. If set to NO, these declarations will be
492 # included in the documentation.
493 # The default value is: NO.
494 
495 HIDE_FRIEND_COMPOUNDS = YES
496 
497 # If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
498 # documentation blocks found inside the body of a function. If set to NO, these
499 # blocks will be appended to the function's detailed documentation block.
500 # The default value is: NO.
501 
502 HIDE_IN_BODY_DOCS = YES
503 
504 # The INTERNAL_DOCS tag determines if documentation that is typed after a
505 # \internal command is included. If the tag is set to NO then the documentation
506 # will be excluded. Set it to YES to include the internal documentation.
507 # The default value is: NO.
508 
509 INTERNAL_DOCS = NO
510 
511 # If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
512 # names in lower-case letters. If set to YES, upper-case letters are also
513 # allowed. This is useful if you have classes or files whose names only differ
514 # in case and if your file system supports case sensitive file names. Windows
515 # and Mac users are advised to set this option to NO.
516 # The default value is: system dependent.
517 
518 CASE_SENSE_NAMES = YES
519 
520 # If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
521 # their full class and namespace scopes in the documentation. If set to YES, the
522 # scope will be hidden.
523 # The default value is: NO.
524 
525 HIDE_SCOPE_NAMES = YES
526 
527 # If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will
528 # append additional text to a page's title, such as Class Reference. If set to
529 # YES the compound reference will be hidden.
530 # The default value is: NO.
531 
532 HIDE_COMPOUND_REFERENCE= NO
533 
534 # If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
535 # the files that are included by a file in the documentation of that file.
536 # The default value is: YES.
537 
538 SHOW_INCLUDE_FILES = NO
539 
540 # If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
541 # grouped member an include statement to the documentation, telling the reader
542 # which file to include in order to use the member.
543 # The default value is: NO.
544 
545 SHOW_GROUPED_MEMB_INC = NO
546 
547 # If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
548 # files with double quotes in the documentation rather than with sharp brackets.
549 # The default value is: NO.
550 
551 FORCE_LOCAL_INCLUDES = NO
552 
553 # If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
554 # documentation for inline members.
555 # The default value is: YES.
556 
557 INLINE_INFO = NO
558 
559 # If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
560 # (detailed) documentation of file and class members alphabetically by member
561 # name. If set to NO, the members will appear in declaration order.
562 # The default value is: YES.
563 
564 SORT_MEMBER_DOCS = YES
565 
566 # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
567 # descriptions of file, namespace and class members alphabetically by member
568 # name. If set to NO, the members will appear in declaration order. Note that
569 # this will also influence the order of the classes in the class list.
570 # The default value is: NO.
571 
572 SORT_BRIEF_DOCS = YES
573 
574 # If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
575 # (brief and detailed) documentation of class members so that constructors and
576 # destructors are listed first. If set to NO the constructors will appear in the
577 # respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
578 # Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
579 # member documentation.
580 # Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
581 # detailed member documentation.
582 # The default value is: NO.
583 
584 SORT_MEMBERS_CTORS_1ST = NO
585 
586 # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
587 # of group names into alphabetical order. If set to NO the group names will
588 # appear in their defined order.
589 # The default value is: NO.
590 
591 SORT_GROUP_NAMES = NO
592 
593 # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
594 # fully-qualified names, including namespaces. If set to NO, the class list will
595 # be sorted only by class name, not including the namespace part.
596 # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
597 # Note: This option applies only to the class list, not to the alphabetical
598 # list.
599 # The default value is: NO.
600 
601 SORT_BY_SCOPE_NAME = YES
602 
603 # If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
604 # type resolution of all parameters of a function it will reject a match between
605 # the prototype and the implementation of a member function even if there is
606 # only one candidate or it is obvious which candidate to choose by doing a
607 # simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
608 # accept a match between prototype and implementation in such cases.
609 # The default value is: NO.
610 
611 STRICT_PROTO_MATCHING = NO
612 
613 # The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo
614 # list. This list is created by putting \todo commands in the documentation.
615 # The default value is: YES.
616 
617 GENERATE_TODOLIST = YES
618 
619 # The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test
620 # list. This list is created by putting \test commands in the documentation.
621 # The default value is: YES.
622 
623 GENERATE_TESTLIST = YES
624 
625 # The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug
626 # list. This list is created by putting \bug commands in the documentation.
627 # The default value is: YES.
628 
629 GENERATE_BUGLIST = YES
630 
631 # The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO)
632 # the deprecated list. This list is created by putting \deprecated commands in
633 # the documentation.
634 # The default value is: YES.
635 
636 GENERATE_DEPRECATEDLIST= YES
637 
638 # The ENABLED_SECTIONS tag can be used to enable conditional documentation
639 # sections, marked by \if <section_label> ... \endif and \cond <section_label>
640 # ... \endcond blocks.
641 
642 ENABLED_SECTIONS =
643 
644 # The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
645 # initial value of a variable or macro / define can have for it to appear in the
646 # documentation. If the initializer consists of more lines than specified here
647 # it will be hidden. Use a value of 0 to hide initializers completely. The
648 # appearance of the value of individual variables and macros / defines can be
649 # controlled using \showinitializer or \hideinitializer command in the
650 # documentation regardless of this setting.
651 # Minimum value: 0, maximum value: 10000, default value: 30.
652 
653 MAX_INITIALIZER_LINES = 30
654 
655 # Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
656 # the bottom of the documentation of classes and structs. If set to YES, the
657 # list will mention the files that were used to generate the documentation.
658 # The default value is: YES.
659 
660 SHOW_USED_FILES = NO
661 
662 # Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
663 # will remove the Files entry from the Quick Index and from the Folder Tree View
664 # (if specified).
665 # The default value is: YES.
666 
667 SHOW_FILES = YES
668 
669 # Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
670 # page. This will remove the Namespaces entry from the Quick Index and from the
671 # Folder Tree View (if specified).
672 # The default value is: YES.
673 
674 SHOW_NAMESPACES = YES
675 
676 # The FILE_VERSION_FILTER tag can be used to specify a program or script that
677 # doxygen should invoke to get the current version for each file (typically from
678 # the version control system). Doxygen will invoke the program by executing (via
679 # popen()) the command command input-file, where command is the value of the
680 # FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
681 # by doxygen. Whatever the program writes to standard output is used as the file
682 # version. For an example see the documentation.
683 
684 FILE_VERSION_FILTER =
685 
686 # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
687 # by doxygen. The layout file controls the global structure of the generated
688 # output files in an output format independent way. To create the layout file
689 # that represents doxygen's defaults, run doxygen with the -l option. You can
690 # optionally specify a file name after the option, if omitted DoxygenLayout.xml
691 # will be used as the name of the layout file.
692 #
693 # Note that if you run doxygen from a directory containing a file called
694 # DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
695 # tag is left empty.
696 
697 LAYOUT_FILE =
698 
699 # The CITE_BIB_FILES tag can be used to specify one or more bib files containing
700 # the reference definitions. This must be a list of .bib files. The .bib
701 # extension is automatically appended if omitted. This requires the bibtex tool
702 # to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info.
703 # For LaTeX the style of the bibliography can be controlled using
704 # LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
705 # search path. See also \cite for info how to create references.
706 
707 CITE_BIB_FILES =
708 
709 #---------------------------------------------------------------------------
710 # Configuration options related to warning and progress messages
711 #---------------------------------------------------------------------------
712 
713 # The QUIET tag can be used to turn on/off the messages that are generated to
714 # standard output by doxygen. If QUIET is set to YES this implies that the
715 # messages are off.
716 # The default value is: NO.
717 
718 QUIET = NO
719 
720 # The WARNINGS tag can be used to turn on/off the warning messages that are
721 # generated to standard error (stderr) by doxygen. If WARNINGS is set to YES
722 # this implies that the warnings are on.
723 #
724 # Tip: Turn warnings on while writing the documentation.
725 # The default value is: YES.
726 
727 WARNINGS = YES
728 
729 # If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate
730 # warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
731 # will automatically be disabled.
732 # The default value is: YES.
733 
734 WARN_IF_UNDOCUMENTED = YES
735 
736 # If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
737 # potential errors in the documentation, such as not documenting some parameters
738 # in a documented function, or documenting parameters that don't exist or using
739 # markup commands wrongly.
740 # The default value is: YES.
741 
742 WARN_IF_DOC_ERROR = YES
743 
744 # This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
745 # are documented, but have no documentation for their parameters or return
746 # value. If set to NO, doxygen will only warn about wrong or incomplete
747 # parameter documentation, but not about the absence of documentation.
748 # The default value is: NO.
749 
750 WARN_NO_PARAMDOC = NO
751 
752 # The WARN_FORMAT tag determines the format of the warning messages that doxygen
753 # can produce. The string should contain the $file, $line, and $text tags, which
754 # will be replaced by the file and line number from which the warning originated
755 # and the warning text. Optionally the format may contain $version, which will
756 # be replaced by the version of the file (if it could be obtained via
757 # FILE_VERSION_FILTER)
758 # The default value is: $file:$line: $text.
759 
760 WARN_FORMAT = "$file:$line: $text"
761 
762 # The WARN_LOGFILE tag can be used to specify a file to which warning and error
763 # messages should be written. If left blank the output is written to standard
764 # error (stderr).
765 
766 WARN_LOGFILE =
767 
768 #---------------------------------------------------------------------------
769 # Configuration options related to the input files
770 #---------------------------------------------------------------------------
771 
772 # The INPUT tag is used to specify the files and/or directories that contain
773 # documented source files. You may enter file names like myfile.cpp or
774 # directories like /usr/src/myproject. Separate the files or directories with
775 # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
776 # Note: If this tag is empty the current directory is searched.
777 
778 INPUT = ../glm \
779  .
780 
781 # This tag can be used to specify the character encoding of the source files
782 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
783 # libiconv (or the iconv built into libc) for the transcoding. See the libiconv
784 # documentation (see: http://www.gnu.org/software/libiconv) for the list of
785 # possible encodings.
786 # The default value is: UTF-8.
787 
788 INPUT_ENCODING = UTF-8
789 
790 # If the value of the INPUT tag contains directories, you can use the
791 # FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
792 # *.h) to filter out the source-files in the directories.
793 #
794 # Note that for custom extensions or not directly supported extensions you also
795 # need to set EXTENSION_MAPPING for the extension otherwise the files are not
796 # read by doxygen.
797 #
798 # If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
799 # *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
800 # *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
801 # *.m, *.markdown, *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd,
802 # *.vhdl, *.ucf, *.qsf, *.as and *.js.
803 
804 FILE_PATTERNS = *.hpp \
805  *.doxy
806 
807 # The RECURSIVE tag can be used to specify whether or not subdirectories should
808 # be searched for input files as well.
809 # The default value is: NO.
810 
811 RECURSIVE = YES
812 
813 # The EXCLUDE tag can be used to specify files and/or directories that should be
814 # excluded from the INPUT source files. This way you can easily exclude a
815 # subdirectory from a directory tree whose root is specified with the INPUT tag.
816 #
817 # Note that relative paths are relative to the directory from which doxygen is
818 # run.
819 
820 EXCLUDE =
821 
822 # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
823 # directories that are symbolic links (a Unix file system feature) are excluded
824 # from the input.
825 # The default value is: NO.
826 
827 EXCLUDE_SYMLINKS = NO
828 
829 # If the value of the INPUT tag contains directories, you can use the
830 # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
831 # certain files from those directories.
832 #
833 # Note that the wildcards are matched against the file with absolute path, so to
834 # exclude all test directories for example use the pattern */test/*
835 
836 EXCLUDE_PATTERNS =
837 
838 # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
839 # (namespaces, classes, functions, etc.) that should be excluded from the
840 # output. The symbol name can be a fully qualified name, a word, or if the
841 # wildcard * is used, a substring. Examples: ANamespace, AClass,
842 # AClass::ANamespace, ANamespace::*Test
843 #
844 # Note that the wildcards are matched against the file with absolute path, so to
845 # exclude all test directories use the pattern */test/*
846 
847 EXCLUDE_SYMBOLS =
848 
849 # The EXAMPLE_PATH tag can be used to specify one or more files or directories
850 # that contain example code fragments that are included (see the \include
851 # command).
852 
853 EXAMPLE_PATH =
854 
855 # If the value of the EXAMPLE_PATH tag contains directories, you can use the
856 # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
857 # *.h) to filter out the source-files in the directories. If left blank all
858 # files are included.
859 
860 EXAMPLE_PATTERNS = *
861 
862 # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
863 # searched for input files to be used with the \include or \dontinclude commands
864 # irrespective of the value of the RECURSIVE tag.
865 # The default value is: NO.
866 
867 EXAMPLE_RECURSIVE = NO
868 
869 # The IMAGE_PATH tag can be used to specify one or more files or directories
870 # that contain images that are to be included in the documentation (see the
871 # \image command).
872 
873 IMAGE_PATH =
874 
875 # The INPUT_FILTER tag can be used to specify a program that doxygen should
876 # invoke to filter for each input file. Doxygen will invoke the filter program
877 # by executing (via popen()) the command:
878 #
879 # <filter> <input-file>
880 #
881 # where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
882 # name of an input file. Doxygen will then use the output that the filter
883 # program writes to standard output. If FILTER_PATTERNS is specified, this tag
884 # will be ignored.
885 #
886 # Note that the filter must not add or remove lines; it is applied before the
887 # code is scanned, but not when the output code is generated. If lines are added
888 # or removed, the anchors will not be placed correctly.
889 
890 INPUT_FILTER =
891 
892 # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
893 # basis. Doxygen will compare the file name with each pattern and apply the
894 # filter if there is a match. The filters are a list of the form: pattern=filter
895 # (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
896 # filters are used. If the FILTER_PATTERNS tag is empty or if none of the
897 # patterns match the file name, INPUT_FILTER is applied.
898 
899 FILTER_PATTERNS =
900 
901 # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
902 # INPUT_FILTER) will also be used to filter the input files that are used for
903 # producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
904 # The default value is: NO.
905 
906 FILTER_SOURCE_FILES = NO
907 
908 # The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
909 # pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
910 # it is also possible to disable source filtering for a specific pattern using
911 # *.ext= (so without naming a filter).
912 # This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
913 
914 FILTER_SOURCE_PATTERNS =
915 
916 # If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
917 # is part of the input, its contents will be placed on the main page
918 # (index.html). This can be useful if you have a project on for instance GitHub
919 # and want to reuse the introduction page also for the doxygen output.
920 
921 USE_MDFILE_AS_MAINPAGE =
922 
923 #---------------------------------------------------------------------------
924 # Configuration options related to source browsing
925 #---------------------------------------------------------------------------
926 
927 # If the SOURCE_BROWSER tag is set to YES then a list of source files will be
928 # generated. Documented entities will be cross-referenced with these sources.
929 #
930 # Note: To get rid of all source code in the generated output, make sure that
931 # also VERBATIM_HEADERS is set to NO.
932 # The default value is: NO.
933 
934 SOURCE_BROWSER = YES
935 
936 # Setting the INLINE_SOURCES tag to YES will include the body of functions,
937 # classes and enums directly into the documentation.
938 # The default value is: NO.
939 
940 INLINE_SOURCES = NO
941 
942 # Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
943 # special comment blocks from generated source code fragments. Normal C, C++ and
944 # Fortran comments will always remain visible.
945 # The default value is: YES.
946 
947 STRIP_CODE_COMMENTS = YES
948 
949 # If the REFERENCED_BY_RELATION tag is set to YES then for each documented
950 # function all documented functions referencing it will be listed.
951 # The default value is: NO.
952 
953 REFERENCED_BY_RELATION = YES
954 
955 # If the REFERENCES_RELATION tag is set to YES then for each documented function
956 # all documented entities called/used by that function will be listed.
957 # The default value is: NO.
958 
959 REFERENCES_RELATION = YES
960 
961 # If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
962 # to YES then the hyperlinks from functions in REFERENCES_RELATION and
963 # REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
964 # link to the documentation.
965 # The default value is: YES.
966 
967 REFERENCES_LINK_SOURCE = YES
968 
969 # If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
970 # source code will show a tooltip with additional information such as prototype,
971 # brief description and links to the definition and documentation. Since this
972 # will make the HTML file larger and loading of large files a bit slower, you
973 # can opt to disable this feature.
974 # The default value is: YES.
975 # This tag requires that the tag SOURCE_BROWSER is set to YES.
976 
977 SOURCE_TOOLTIPS = YES
978 
979 # If the USE_HTAGS tag is set to YES then the references to source code will
980 # point to the HTML generated by the htags(1) tool instead of doxygen built-in
981 # source browser. The htags tool is part of GNU's global source tagging system
982 # (see http://www.gnu.org/software/global/global.html). You will need version
983 # 4.8.6 or higher.
984 #
985 # To use it do the following:
986 # - Install the latest version of global
987 # - Enable SOURCE_BROWSER and USE_HTAGS in the config file
988 # - Make sure the INPUT points to the root of the source tree
989 # - Run doxygen as normal
990 #
991 # Doxygen will invoke htags (and that will in turn invoke gtags), so these
992 # tools must be available from the command line (i.e. in the search path).
993 #
994 # The result: instead of the source browser generated by doxygen, the links to
995 # source code will now point to the output of htags.
996 # The default value is: NO.
997 # This tag requires that the tag SOURCE_BROWSER is set to YES.
998 
999 USE_HTAGS = NO
1000 
1001 # If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
1002 # verbatim copy of the header file for each class for which an include is
1003 # specified. Set to NO to disable this.
1004 # See also: Section \class.
1005 # The default value is: YES.
1006 
1007 VERBATIM_HEADERS = YES
1008 
1009 #---------------------------------------------------------------------------
1010 # Configuration options related to the alphabetical class index
1011 #---------------------------------------------------------------------------
1012 
1013 # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
1014 # compounds will be generated. Enable this if the project contains a lot of
1015 # classes, structs, unions or interfaces.
1016 # The default value is: YES.
1017 
1018 ALPHABETICAL_INDEX = NO
1019 
1020 # The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
1021 # which the alphabetical index list will be split.
1022 # Minimum value: 1, maximum value: 20, default value: 5.
1023 # This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
1024 
1025 COLS_IN_ALPHA_INDEX = 5
1026 
1027 # In case all classes in a project start with a common prefix, all classes will
1028 # be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
1029 # can be used to specify a prefix (or a list of prefixes) that should be ignored
1030 # while generating the index headers.
1031 # This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
1032 
1033 IGNORE_PREFIX =
1034 
1035 #---------------------------------------------------------------------------
1036 # Configuration options related to the HTML output
1037 #---------------------------------------------------------------------------
1038 
1039 # If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output
1040 # The default value is: YES.
1041 
1042 GENERATE_HTML = YES
1043 
1044 # The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
1045 # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
1046 # it.
1047 # The default directory is: html.
1048 # This tag requires that the tag GENERATE_HTML is set to YES.
1049 
1050 HTML_OUTPUT = html
1051 
1052 # The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
1053 # generated HTML page (for example: .htm, .php, .asp).
1054 # The default value is: .html.
1055 # This tag requires that the tag GENERATE_HTML is set to YES.
1056 
1057 HTML_FILE_EXTENSION = .html
1058 
1059 # The HTML_HEADER tag can be used to specify a user-defined HTML header file for
1060 # each generated HTML page. If the tag is left blank doxygen will generate a
1061 # standard header.
1062 #
1063 # To get valid HTML the header file that includes any scripts and style sheets
1064 # that doxygen needs, which is dependent on the configuration options used (e.g.
1065 # the setting GENERATE_TREEVIEW). It is highly recommended to start with a
1066 # default header using
1067 # doxygen -w html new_header.html new_footer.html new_stylesheet.css
1068 # YourConfigFile
1069 # and then modify the file new_header.html. See also section "Doxygen usage"
1070 # for information on how to generate the default header that doxygen normally
1071 # uses.
1072 # Note: The header is subject to change so you typically have to regenerate the
1073 # default header when upgrading to a newer version of doxygen. For a description
1074 # of the possible markers and block names see the documentation.
1075 # This tag requires that the tag GENERATE_HTML is set to YES.
1076 
1077 HTML_HEADER =
1078 
1079 # The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
1080 # generated HTML page. If the tag is left blank doxygen will generate a standard
1081 # footer. See HTML_HEADER for more information on how to generate a default
1082 # footer and what special commands can be used inside the footer. See also
1083 # section "Doxygen usage" for information on how to generate the default footer
1084 # that doxygen normally uses.
1085 # This tag requires that the tag GENERATE_HTML is set to YES.
1086 
1087 HTML_FOOTER =
1088 
1089 # The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
1090 # sheet that is used by each HTML page. It can be used to fine-tune the look of
1091 # the HTML output. If left blank doxygen will generate a default style sheet.
1092 # See also section "Doxygen usage" for information on how to generate the style
1093 # sheet that doxygen normally uses.
1094 # Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
1095 # it is more robust and this tag (HTML_STYLESHEET) will in the future become
1096 # obsolete.
1097 # This tag requires that the tag GENERATE_HTML is set to YES.
1098 
1099 HTML_STYLESHEET =
1100 
1101 # The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
1102 # cascading style sheets that are included after the standard style sheets
1103 # created by doxygen. Using this option one can overrule certain style aspects.
1104 # This is preferred over using HTML_STYLESHEET since it does not replace the
1105 # standard style sheet and is therefore more robust against future updates.
1106 # Doxygen will copy the style sheet files to the output directory.
1107 # Note: The order of the extra style sheet files is of importance (e.g. the last
1108 # style sheet in the list overrules the setting of the previous ones in the
1109 # list). For an example see the documentation.
1110 # This tag requires that the tag GENERATE_HTML is set to YES.
1111 
1112 HTML_EXTRA_STYLESHEET =
1113 
1114 # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
1115 # other source files which should be copied to the HTML output directory. Note
1116 # that these files will be copied to the base HTML output directory. Use the
1117 # $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
1118 # files. In the HTML_STYLESHEET file, use the file name only. Also note that the
1119 # files will be copied as-is; there are no commands or markers available.
1120 # This tag requires that the tag GENERATE_HTML is set to YES.
1121 
1122 HTML_EXTRA_FILES =
1123 
1124 # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
1125 # will adjust the colors in the style sheet and background images according to
1126 # this color. Hue is specified as an angle on a colorwheel, see
1127 # http://en.wikipedia.org/wiki/Hue for more information. For instance the value
1128 # 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
1129 # purple, and 360 is red again.
1130 # Minimum value: 0, maximum value: 359, default value: 220.
1131 # This tag requires that the tag GENERATE_HTML is set to YES.
1132 
1133 HTML_COLORSTYLE_HUE = 220
1134 
1135 # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
1136 # in the HTML output. For a value of 0 the output will use grayscales only. A
1137 # value of 255 will produce the most vivid colors.
1138 # Minimum value: 0, maximum value: 255, default value: 100.
1139 # This tag requires that the tag GENERATE_HTML is set to YES.
1140 
1141 HTML_COLORSTYLE_SAT = 100
1142 
1143 # The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
1144 # luminance component of the colors in the HTML output. Values below 100
1145 # gradually make the output lighter, whereas values above 100 make the output
1146 # darker. The value divided by 100 is the actual gamma applied, so 80 represents
1147 # a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
1148 # change the gamma.
1149 # Minimum value: 40, maximum value: 240, default value: 80.
1150 # This tag requires that the tag GENERATE_HTML is set to YES.
1151 
1152 HTML_COLORSTYLE_GAMMA = 80
1153 
1154 # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
1155 # page will contain the date and time when the page was generated. Setting this
1156 # to YES can help to show when doxygen was last run and thus if the
1157 # documentation is up to date.
1158 # The default value is: NO.
1159 # This tag requires that the tag GENERATE_HTML is set to YES.
1160 
1161 HTML_TIMESTAMP = NO
1162 
1163 # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
1164 # documentation will contain sections that can be hidden and shown after the
1165 # page has loaded.
1166 # The default value is: NO.
1167 # This tag requires that the tag GENERATE_HTML is set to YES.
1168 
1169 HTML_DYNAMIC_SECTIONS = NO
1170 
1171 # With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
1172 # shown in the various tree structured indices initially; the user can expand
1173 # and collapse entries dynamically later on. Doxygen will expand the tree to
1174 # such a level that at most the specified number of entries are visible (unless
1175 # a fully collapsed tree already exceeds this amount). So setting the number of
1176 # entries 1 will produce a full collapsed tree by default. 0 is a special value
1177 # representing an infinite number of entries and will result in a full expanded
1178 # tree by default.
1179 # Minimum value: 0, maximum value: 9999, default value: 100.
1180 # This tag requires that the tag GENERATE_HTML is set to YES.
1181 
1182 HTML_INDEX_NUM_ENTRIES = 100
1183 
1184 # If the GENERATE_DOCSET tag is set to YES, additional index files will be
1185 # generated that can be used as input for Apple's Xcode 3 integrated development
1186 # environment (see: http://developer.apple.com/tools/xcode/), introduced with
1187 # OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a
1188 # Makefile in the HTML output directory. Running make will produce the docset in
1189 # that directory and running make install will install the docset in
1190 # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
1191 # startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
1192 # for more information.
1193 # The default value is: NO.
1194 # This tag requires that the tag GENERATE_HTML is set to YES.
1195 
1196 GENERATE_DOCSET = NO
1197 
1198 # This tag determines the name of the docset feed. A documentation feed provides
1199 # an umbrella under which multiple documentation sets from a single provider
1200 # (such as a company or product suite) can be grouped.
1201 # The default value is: Doxygen generated docs.
1202 # This tag requires that the tag GENERATE_DOCSET is set to YES.
1203 
1204 DOCSET_FEEDNAME = "Doxygen generated docs"
1205 
1206 # This tag specifies a string that should uniquely identify the documentation
1207 # set bundle. This should be a reverse domain-name style string, e.g.
1208 # com.mycompany.MyDocSet. Doxygen will append .docset to the name.
1209 # The default value is: org.doxygen.Project.
1210 # This tag requires that the tag GENERATE_DOCSET is set to YES.
1211 
1212 DOCSET_BUNDLE_ID = org.doxygen.Project
1213 
1214 # The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
1215 # the documentation publisher. This should be a reverse domain-name style
1216 # string, e.g. com.mycompany.MyDocSet.documentation.
1217 # The default value is: org.doxygen.Publisher.
1218 # This tag requires that the tag GENERATE_DOCSET is set to YES.
1219 
1220 DOCSET_PUBLISHER_ID = org.doxygen.Publisher
1221 
1222 # The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
1223 # The default value is: Publisher.
1224 # This tag requires that the tag GENERATE_DOCSET is set to YES.
1225 
1226 DOCSET_PUBLISHER_NAME = Publisher
1227 
1228 # If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
1229 # additional HTML index files: index.hhp, index.hhc, and index.hhk. The
1230 # index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
1231 # (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on
1232 # Windows.
1233 #
1234 # The HTML Help Workshop contains a compiler that can convert all HTML output
1235 # generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
1236 # files are now used as the Windows 98 help format, and will replace the old
1237 # Windows help format (.hlp) on all Windows platforms in the future. Compressed
1238 # HTML files also contain an index, a table of contents, and you can search for
1239 # words in the documentation. The HTML workshop also contains a viewer for
1240 # compressed HTML files.
1241 # The default value is: NO.
1242 # This tag requires that the tag GENERATE_HTML is set to YES.
1243 
1244 GENERATE_HTMLHELP = NO
1245 
1246 # The CHM_FILE tag can be used to specify the file name of the resulting .chm
1247 # file. You can add a path in front of the file if the result should not be
1248 # written to the html output directory.
1249 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
1250 
1251 CHM_FILE =
1252 
1253 # The HHC_LOCATION tag can be used to specify the location (absolute path
1254 # including file name) of the HTML help compiler (hhc.exe). If non-empty,
1255 # doxygen will try to run the HTML help compiler on the generated index.hhp.
1256 # The file has to be specified with full path.
1257 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
1258 
1259 HHC_LOCATION =
1260 
1261 # The GENERATE_CHI flag controls if a separate .chi index file is generated
1262 # (YES) or that it should be included in the master .chm file (NO).
1263 # The default value is: NO.
1264 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
1265 
1266 GENERATE_CHI = NO
1267 
1268 # The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc)
1269 # and project file content.
1270 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
1271 
1272 CHM_INDEX_ENCODING =
1273 
1274 # The BINARY_TOC flag controls whether a binary table of contents is generated
1275 # (YES) or a normal table of contents (NO) in the .chm file. Furthermore it
1276 # enables the Previous and Next buttons.
1277 # The default value is: NO.
1278 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
1279 
1280 BINARY_TOC = NO
1281 
1282 # The TOC_EXPAND flag can be set to YES to add extra items for group members to
1283 # the table of contents of the HTML help documentation and to the tree view.
1284 # The default value is: NO.
1285 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
1286 
1287 TOC_EXPAND = NO
1288 
1289 # If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
1290 # QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
1291 # can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
1292 # (.qch) of the generated HTML documentation.
1293 # The default value is: NO.
1294 # This tag requires that the tag GENERATE_HTML is set to YES.
1295 
1296 GENERATE_QHP = NO
1297 
1298 # If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
1299 # the file name of the resulting .qch file. The path specified is relative to
1300 # the HTML output folder.
1301 # This tag requires that the tag GENERATE_QHP is set to YES.
1302 
1303 QCH_FILE =
1304 
1305 # The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
1306 # Project output. For more information please see Qt Help Project / Namespace
1307 # (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace).
1308 # The default value is: org.doxygen.Project.
1309 # This tag requires that the tag GENERATE_QHP is set to YES.
1310 
1311 QHP_NAMESPACE = org.doxygen.Project
1312 
1313 # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
1314 # Help Project output. For more information please see Qt Help Project / Virtual
1315 # Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual-
1316 # folders).
1317 # The default value is: doc.
1318 # This tag requires that the tag GENERATE_QHP is set to YES.
1319 
1320 QHP_VIRTUAL_FOLDER = doc
1321 
1322 # If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
1323 # filter to add. For more information please see Qt Help Project / Custom
1324 # Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
1325 # filters).
1326 # This tag requires that the tag GENERATE_QHP is set to YES.
1327 
1328 QHP_CUST_FILTER_NAME =
1329 
1330 # The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
1331 # custom filter to add. For more information please see Qt Help Project / Custom
1332 # Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
1333 # filters).
1334 # This tag requires that the tag GENERATE_QHP is set to YES.
1335 
1336 QHP_CUST_FILTER_ATTRS =
1337 
1338 # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
1339 # project's filter section matches. Qt Help Project / Filter Attributes (see:
1340 # http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes).
1341 # This tag requires that the tag GENERATE_QHP is set to YES.
1342 
1343 QHP_SECT_FILTER_ATTRS =
1344 
1345 # The QHG_LOCATION tag can be used to specify the location of Qt's
1346 # qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
1347 # generated .qhp file.
1348 # This tag requires that the tag GENERATE_QHP is set to YES.
1349 
1350 QHG_LOCATION =
1351 
1352 # If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
1353 # generated, together with the HTML files, they form an Eclipse help plugin. To
1354 # install this plugin and make it available under the help contents menu in
1355 # Eclipse, the contents of the directory containing the HTML and XML files needs
1356 # to be copied into the plugins directory of eclipse. The name of the directory
1357 # within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
1358 # After copying Eclipse needs to be restarted before the help appears.
1359 # The default value is: NO.
1360 # This tag requires that the tag GENERATE_HTML is set to YES.
1361 
1362 GENERATE_ECLIPSEHELP = NO
1363 
1364 # A unique identifier for the Eclipse help plugin. When installing the plugin
1365 # the directory name containing the HTML and XML files should also have this
1366 # name. Each documentation set should have its own identifier.
1367 # The default value is: org.doxygen.Project.
1368 # This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
1369 
1370 ECLIPSE_DOC_ID = org.doxygen.Project
1371 
1372 # If you want full control over the layout of the generated HTML pages it might
1373 # be necessary to disable the index and replace it with your own. The
1374 # DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
1375 # of each HTML page. A value of NO enables the index and the value YES disables
1376 # it. Since the tabs in the index contain the same information as the navigation
1377 # tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
1378 # The default value is: NO.
1379 # This tag requires that the tag GENERATE_HTML is set to YES.
1380 
1381 DISABLE_INDEX = NO
1382 
1383 # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
1384 # structure should be generated to display hierarchical information. If the tag
1385 # value is set to YES, a side panel will be generated containing a tree-like
1386 # index structure (just like the one that is generated for HTML Help). For this
1387 # to work a browser that supports JavaScript, DHTML, CSS and frames is required
1388 # (i.e. any modern browser). Windows users are probably better off using the
1389 # HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can
1390 # further fine-tune the look of the index. As an example, the default style
1391 # sheet generated by doxygen has an example that shows how to put an image at
1392 # the root of the tree instead of the PROJECT_NAME. Since the tree basically has
1393 # the same information as the tab index, you could consider setting
1394 # DISABLE_INDEX to YES when enabling this option.
1395 # The default value is: NO.
1396 # This tag requires that the tag GENERATE_HTML is set to YES.
1397 
1398 GENERATE_TREEVIEW = NO
1399 
1400 # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
1401 # doxygen will group on one line in the generated HTML documentation.
1402 #
1403 # Note that a value of 0 will completely suppress the enum values from appearing
1404 # in the overview section.
1405 # Minimum value: 0, maximum value: 20, default value: 4.
1406 # This tag requires that the tag GENERATE_HTML is set to YES.
1407 
1408 ENUM_VALUES_PER_LINE = 4
1409 
1410 # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
1411 # to set the initial width (in pixels) of the frame in which the tree is shown.
1412 # Minimum value: 0, maximum value: 1500, default value: 250.
1413 # This tag requires that the tag GENERATE_HTML is set to YES.
1414 
1415 TREEVIEW_WIDTH = 250
1416 
1417 # If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to
1418 # external symbols imported via tag files in a separate window.
1419 # The default value is: NO.
1420 # This tag requires that the tag GENERATE_HTML is set to YES.
1421 
1422 EXT_LINKS_IN_WINDOW = NO
1423 
1424 # Use this tag to change the font size of LaTeX formulas included as images in
1425 # the HTML documentation. When you change the font size after a successful
1426 # doxygen run you need to manually remove any form_*.png images from the HTML
1427 # output directory to force them to be regenerated.
1428 # Minimum value: 8, maximum value: 50, default value: 10.
1429 # This tag requires that the tag GENERATE_HTML is set to YES.
1430 
1431 FORMULA_FONTSIZE = 10
1432 
1433 # Use the FORMULA_TRANPARENT tag to determine whether or not the images
1434 # generated for formulas are transparent PNGs. Transparent PNGs are not
1435 # supported properly for IE 6.0, but are supported on all modern browsers.
1436 #
1437 # Note that when changing this option you need to delete any form_*.png files in
1438 # the HTML output directory before the changes have effect.
1439 # The default value is: YES.
1440 # This tag requires that the tag GENERATE_HTML is set to YES.
1441 
1442 FORMULA_TRANSPARENT = YES
1443 
1444 # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
1445 # http://www.mathjax.org) which uses client side Javascript for the rendering
1446 # instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
1447 # installed or if you want to formulas look prettier in the HTML output. When
1448 # enabled you may also need to install MathJax separately and configure the path
1449 # to it using the MATHJAX_RELPATH option.
1450 # The default value is: NO.
1451 # This tag requires that the tag GENERATE_HTML is set to YES.
1452 
1453 USE_MATHJAX = NO
1454 
1455 # When MathJax is enabled you can set the default output format to be used for
1456 # the MathJax output. See the MathJax site (see:
1457 # http://docs.mathjax.org/en/latest/output.html) for more details.
1458 # Possible values are: HTML-CSS (which is slower, but has the best
1459 # compatibility), NativeMML (i.e. MathML) and SVG.
1460 # The default value is: HTML-CSS.
1461 # This tag requires that the tag USE_MATHJAX is set to YES.
1462 
1463 MATHJAX_FORMAT = HTML-CSS
1464 
1465 # When MathJax is enabled you need to specify the location relative to the HTML
1466 # output directory using the MATHJAX_RELPATH option. The destination directory
1467 # should contain the MathJax.js script. For instance, if the mathjax directory
1468 # is located at the same level as the HTML output directory, then
1469 # MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
1470 # Content Delivery Network so you can quickly see the result without installing
1471 # MathJax. However, it is strongly recommended to install a local copy of
1472 # MathJax from http://www.mathjax.org before deployment.
1473 # The default value is: http://cdn.mathjax.org/mathjax/latest.
1474 # This tag requires that the tag USE_MATHJAX is set to YES.
1475 
1476 MATHJAX_RELPATH = http://www.mathjax.org/mathjax
1477 
1478 # The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
1479 # extension names that should be enabled during MathJax rendering. For example
1480 # MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
1481 # This tag requires that the tag USE_MATHJAX is set to YES.
1482 
1483 MATHJAX_EXTENSIONS =
1484 
1485 # The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
1486 # of code that will be used on startup of the MathJax code. See the MathJax site
1487 # (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
1488 # example see the documentation.
1489 # This tag requires that the tag USE_MATHJAX is set to YES.
1490 
1491 MATHJAX_CODEFILE =
1492 
1493 # When the SEARCHENGINE tag is enabled doxygen will generate a search box for
1494 # the HTML output. The underlying search engine uses javascript and DHTML and
1495 # should work on any modern browser. Note that when using HTML help
1496 # (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
1497 # there is already a search function so this one should typically be disabled.
1498 # For large projects the javascript based search engine can be slow, then
1499 # enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
1500 # search using the keyboard; to jump to the search box use <access key> + S
1501 # (what the <access key> is depends on the OS and browser, but it is typically
1502 # <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
1503 # key> to jump into the search results window, the results can be navigated
1504 # using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
1505 # the search. The filter options can be selected when the cursor is inside the
1506 # search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
1507 # to select a filter and <Enter> or <escape> to activate or cancel the filter
1508 # option.
1509 # The default value is: YES.
1510 # This tag requires that the tag GENERATE_HTML is set to YES.
1511 
1512 SEARCHENGINE = NO
1513 
1514 # When the SERVER_BASED_SEARCH tag is enabled the search engine will be
1515 # implemented using a web server instead of a web client using Javascript. There
1516 # are two flavors of web server based searching depending on the EXTERNAL_SEARCH
1517 # setting. When disabled, doxygen will generate a PHP script for searching and
1518 # an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
1519 # and searching needs to be provided by external tools. See the section
1520 # "External Indexing and Searching" for details.
1521 # The default value is: NO.
1522 # This tag requires that the tag SEARCHENGINE is set to YES.
1523 
1524 SERVER_BASED_SEARCH = NO
1525 
1526 # When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
1527 # script for searching. Instead the search results are written to an XML file
1528 # which needs to be processed by an external indexer. Doxygen will invoke an
1529 # external search engine pointed to by the SEARCHENGINE_URL option to obtain the
1530 # search results.
1531 #
1532 # Doxygen ships with an example indexer (doxyindexer) and search engine
1533 # (doxysearch.cgi) which are based on the open source search engine library
1534 # Xapian (see: http://xapian.org/).
1535 #
1536 # See the section "External Indexing and Searching" for details.
1537 # The default value is: NO.
1538 # This tag requires that the tag SEARCHENGINE is set to YES.
1539 
1540 EXTERNAL_SEARCH = NO
1541 
1542 # The SEARCHENGINE_URL should point to a search engine hosted by a web server
1543 # which will return the search results when EXTERNAL_SEARCH is enabled.
1544 #
1545 # Doxygen ships with an example indexer (doxyindexer) and search engine
1546 # (doxysearch.cgi) which are based on the open source search engine library
1547 # Xapian (see: http://xapian.org/). See the section "External Indexing and
1548 # Searching" for details.
1549 # This tag requires that the tag SEARCHENGINE is set to YES.
1550 
1551 SEARCHENGINE_URL =
1552 
1553 # When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
1554 # search data is written to a file for indexing by an external tool. With the
1555 # SEARCHDATA_FILE tag the name of this file can be specified.
1556 # The default file is: searchdata.xml.
1557 # This tag requires that the tag SEARCHENGINE is set to YES.
1558 
1559 SEARCHDATA_FILE = searchdata.xml
1560 
1561 # When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
1562 # EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
1563 # useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
1564 # projects and redirect the results back to the right project.
1565 # This tag requires that the tag SEARCHENGINE is set to YES.
1566 
1567 EXTERNAL_SEARCH_ID =
1568 
1569 # The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
1570 # projects other than the one defined by this configuration file, but that are
1571 # all added to the same external search index. Each project needs to have a
1572 # unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
1573 # to a relative location where the documentation can be found. The format is:
1574 # EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
1575 # This tag requires that the tag SEARCHENGINE is set to YES.
1576 
1577 EXTRA_SEARCH_MAPPINGS =
1578 
1579 #---------------------------------------------------------------------------
1580 # Configuration options related to the LaTeX output
1581 #---------------------------------------------------------------------------
1582 
1583 # If the GENERATE_LATEX tag is set to YES, doxygen will generate LaTeX output.
1584 # The default value is: YES.
1585 
1586 GENERATE_LATEX = NO
1587 
1588 # The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
1589 # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
1590 # it.
1591 # The default directory is: latex.
1592 # This tag requires that the tag GENERATE_LATEX is set to YES.
1593 
1594 LATEX_OUTPUT = latex
1595 
1596 # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
1597 # invoked.
1598 #
1599 # Note that when enabling USE_PDFLATEX this option is only used for generating
1600 # bitmaps for formulas in the HTML output, but not in the Makefile that is
1601 # written to the output directory.
1602 # The default file is: latex.
1603 # This tag requires that the tag GENERATE_LATEX is set to YES.
1604 
1605 LATEX_CMD_NAME = latex
1606 
1607 # The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
1608 # index for LaTeX.
1609 # The default file is: makeindex.
1610 # This tag requires that the tag GENERATE_LATEX is set to YES.
1611 
1612 MAKEINDEX_CMD_NAME = makeindex
1613 
1614 # If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
1615 # documents. This may be useful for small projects and may help to save some
1616 # trees in general.
1617 # The default value is: NO.
1618 # This tag requires that the tag GENERATE_LATEX is set to YES.
1619 
1620 COMPACT_LATEX = NO
1621 
1622 # The PAPER_TYPE tag can be used to set the paper type that is used by the
1623 # printer.
1624 # Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
1625 # 14 inches) and executive (7.25 x 10.5 inches).
1626 # The default value is: a4.
1627 # This tag requires that the tag GENERATE_LATEX is set to YES.
1628 
1629 PAPER_TYPE = a4wide
1630 
1631 # The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
1632 # that should be included in the LaTeX output. The package can be specified just
1633 # by its name or with the correct syntax as to be used with the LaTeX
1634 # \usepackage command. To get the times font for instance you can specify :
1635 # EXTRA_PACKAGES=times or EXTRA_PACKAGES={times}
1636 # To use the option intlimits with the amsmath package you can specify:
1637 # EXTRA_PACKAGES=[intlimits]{amsmath}
1638 # If left blank no extra packages will be included.
1639 # This tag requires that the tag GENERATE_LATEX is set to YES.
1640 
1641 EXTRA_PACKAGES =
1642 
1643 # The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
1644 # generated LaTeX document. The header should contain everything until the first
1645 # chapter. If it is left blank doxygen will generate a standard header. See
1646 # section "Doxygen usage" for information on how to let doxygen write the
1647 # default header to a separate file.
1648 #
1649 # Note: Only use a user-defined header if you know what you are doing! The
1650 # following commands have a special meaning inside the header: $title,
1651 # $datetime, $date, $doxygenversion, $projectname, $projectnumber,
1652 # $projectbrief, $projectlogo. Doxygen will replace $title with the empty
1653 # string, for the replacement values of the other commands the user is referred
1654 # to HTML_HEADER.
1655 # This tag requires that the tag GENERATE_LATEX is set to YES.
1656 
1657 LATEX_HEADER =
1658 
1659 # The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
1660 # generated LaTeX document. The footer should contain everything after the last
1661 # chapter. If it is left blank doxygen will generate a standard footer. See
1662 # LATEX_HEADER for more information on how to generate a default footer and what
1663 # special commands can be used inside the footer.
1664 #
1665 # Note: Only use a user-defined footer if you know what you are doing!
1666 # This tag requires that the tag GENERATE_LATEX is set to YES.
1667 
1668 LATEX_FOOTER =
1669 
1670 # The LATEX_EXTRA_STYLESHEET tag can be used to specify additional user-defined
1671 # LaTeX style sheets that are included after the standard style sheets created
1672 # by doxygen. Using this option one can overrule certain style aspects. Doxygen
1673 # will copy the style sheet files to the output directory.
1674 # Note: The order of the extra style sheet files is of importance (e.g. the last
1675 # style sheet in the list overrules the setting of the previous ones in the
1676 # list).
1677 # This tag requires that the tag GENERATE_LATEX is set to YES.
1678 
1679 LATEX_EXTRA_STYLESHEET =
1680 
1681 # The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
1682 # other source files which should be copied to the LATEX_OUTPUT output
1683 # directory. Note that the files will be copied as-is; there are no commands or
1684 # markers available.
1685 # This tag requires that the tag GENERATE_LATEX is set to YES.
1686 
1687 LATEX_EXTRA_FILES =
1688 
1689 # If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
1690 # prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
1691 # contain links (just like the HTML output) instead of page references. This
1692 # makes the output suitable for online browsing using a PDF viewer.
1693 # The default value is: YES.
1694 # This tag requires that the tag GENERATE_LATEX is set to YES.
1695 
1696 PDF_HYPERLINKS = NO
1697 
1698 # If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
1699 # the PDF file directly from the LaTeX files. Set this option to YES, to get a
1700 # higher quality PDF documentation.
1701 # The default value is: YES.
1702 # This tag requires that the tag GENERATE_LATEX is set to YES.
1703 
1704 USE_PDFLATEX = YES
1705 
1706 # If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
1707 # command to the generated LaTeX files. This will instruct LaTeX to keep running
1708 # if errors occur, instead of asking the user for help. This option is also used
1709 # when generating formulas in HTML.
1710 # The default value is: NO.
1711 # This tag requires that the tag GENERATE_LATEX is set to YES.
1712 
1713 LATEX_BATCHMODE = NO
1714 
1715 # If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
1716 # index chapters (such as File Index, Compound Index, etc.) in the output.
1717 # The default value is: NO.
1718 # This tag requires that the tag GENERATE_LATEX is set to YES.
1719 
1720 LATEX_HIDE_INDICES = NO
1721 
1722 # If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
1723 # code with syntax highlighting in the LaTeX output.
1724 #
1725 # Note that which sources are shown also depends on other settings such as
1726 # SOURCE_BROWSER.
1727 # The default value is: NO.
1728 # This tag requires that the tag GENERATE_LATEX is set to YES.
1729 
1730 LATEX_SOURCE_CODE = NO
1731 
1732 # The LATEX_BIB_STYLE tag can be used to specify the style to use for the
1733 # bibliography, e.g. plainnat, or ieeetr. See
1734 # http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
1735 # The default value is: plain.
1736 # This tag requires that the tag GENERATE_LATEX is set to YES.
1737 
1738 LATEX_BIB_STYLE = plain
1739 
1740 #---------------------------------------------------------------------------
1741 # Configuration options related to the RTF output
1742 #---------------------------------------------------------------------------
1743 
1744 # If the GENERATE_RTF tag is set to YES, doxygen will generate RTF output. The
1745 # RTF output is optimized for Word 97 and may not look too pretty with other RTF
1746 # readers/editors.
1747 # The default value is: NO.
1748 
1749 GENERATE_RTF = NO
1750 
1751 # The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
1752 # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
1753 # it.
1754 # The default directory is: rtf.
1755 # This tag requires that the tag GENERATE_RTF is set to YES.
1756 
1757 RTF_OUTPUT = glm.rtf
1758 
1759 # If the COMPACT_RTF tag is set to YES, doxygen generates more compact RTF
1760 # documents. This may be useful for small projects and may help to save some
1761 # trees in general.
1762 # The default value is: NO.
1763 # This tag requires that the tag GENERATE_RTF is set to YES.
1764 
1765 COMPACT_RTF = NO
1766 
1767 # If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
1768 # contain hyperlink fields. The RTF file will contain links (just like the HTML
1769 # output) instead of page references. This makes the output suitable for online
1770 # browsing using Word or some other Word compatible readers that support those
1771 # fields.
1772 #
1773 # Note: WordPad (write) and others do not support links.
1774 # The default value is: NO.
1775 # This tag requires that the tag GENERATE_RTF is set to YES.
1776 
1777 RTF_HYPERLINKS = YES
1778 
1779 # Load stylesheet definitions from file. Syntax is similar to doxygen's config
1780 # file, i.e. a series of assignments. You only have to provide replacements,
1781 # missing definitions are set to their default value.
1782 #
1783 # See also section "Doxygen usage" for information on how to generate the
1784 # default style sheet that doxygen normally uses.
1785 # This tag requires that the tag GENERATE_RTF is set to YES.
1786 
1787 RTF_STYLESHEET_FILE =
1788 
1789 # Set optional variables used in the generation of an RTF document. Syntax is
1790 # similar to doxygen's config file. A template extensions file can be generated
1791 # using doxygen -e rtf extensionFile.
1792 # This tag requires that the tag GENERATE_RTF is set to YES.
1793 
1794 RTF_EXTENSIONS_FILE =
1795 
1796 # If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
1797 # with syntax highlighting in the RTF output.
1798 #
1799 # Note that which sources are shown also depends on other settings such as
1800 # SOURCE_BROWSER.
1801 # The default value is: NO.
1802 # This tag requires that the tag GENERATE_RTF is set to YES.
1803 
1804 RTF_SOURCE_CODE = NO
1805 
1806 #---------------------------------------------------------------------------
1807 # Configuration options related to the man page output
1808 #---------------------------------------------------------------------------
1809 
1810 # If the GENERATE_MAN tag is set to YES, doxygen will generate man pages for
1811 # classes and files.
1812 # The default value is: NO.
1813 
1814 GENERATE_MAN = NO
1815 
1816 # The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
1817 # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
1818 # it. A directory man3 will be created inside the directory specified by
1819 # MAN_OUTPUT.
1820 # The default directory is: man.
1821 # This tag requires that the tag GENERATE_MAN is set to YES.
1822 
1823 MAN_OUTPUT = man
1824 
1825 # The MAN_EXTENSION tag determines the extension that is added to the generated
1826 # man pages. In case the manual section does not start with a number, the number
1827 # 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
1828 # optional.
1829 # The default value is: .3.
1830 # This tag requires that the tag GENERATE_MAN is set to YES.
1831 
1832 MAN_EXTENSION = .3
1833 
1834 # The MAN_SUBDIR tag determines the name of the directory created within
1835 # MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
1836 # MAN_EXTENSION with the initial . removed.
1837 # This tag requires that the tag GENERATE_MAN is set to YES.
1838 
1839 MAN_SUBDIR =
1840 
1841 # If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
1842 # will generate one additional man file for each entity documented in the real
1843 # man page(s). These additional files only source the real man page, but without
1844 # them the man command would be unable to find the correct page.
1845 # The default value is: NO.
1846 # This tag requires that the tag GENERATE_MAN is set to YES.
1847 
1848 MAN_LINKS = NO
1849 
1850 #---------------------------------------------------------------------------
1851 # Configuration options related to the XML output
1852 #---------------------------------------------------------------------------
1853 
1854 # If the GENERATE_XML tag is set to YES, doxygen will generate an XML file that
1855 # captures the structure of the code including all documentation.
1856 # The default value is: NO.
1857 
1858 GENERATE_XML = NO
1859 
1860 # The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
1861 # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
1862 # it.
1863 # The default directory is: xml.
1864 # This tag requires that the tag GENERATE_XML is set to YES.
1865 
1866 XML_OUTPUT = xml
1867 
1868 # If the XML_PROGRAMLISTING tag is set to YES, doxygen will dump the program
1869 # listings (including syntax highlighting and cross-referencing information) to
1870 # the XML output. Note that enabling this will significantly increase the size
1871 # of the XML output.
1872 # The default value is: YES.
1873 # This tag requires that the tag GENERATE_XML is set to YES.
1874 
1875 XML_PROGRAMLISTING = YES
1876 
1877 #---------------------------------------------------------------------------
1878 # Configuration options related to the DOCBOOK output
1879 #---------------------------------------------------------------------------
1880 
1881 # If the GENERATE_DOCBOOK tag is set to YES, doxygen will generate Docbook files
1882 # that can be used to generate PDF.
1883 # The default value is: NO.
1884 
1885 GENERATE_DOCBOOK = NO
1886 
1887 # The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
1888 # If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
1889 # front of it.
1890 # The default directory is: docbook.
1891 # This tag requires that the tag GENERATE_DOCBOOK is set to YES.
1892 
1893 DOCBOOK_OUTPUT = docbook
1894 
1895 # If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
1896 # program listings (including syntax highlighting and cross-referencing
1897 # information) to the DOCBOOK output. Note that enabling this will significantly
1898 # increase the size of the DOCBOOK output.
1899 # The default value is: NO.
1900 # This tag requires that the tag GENERATE_DOCBOOK is set to YES.
1901 
1902 DOCBOOK_PROGRAMLISTING = NO
1903 
1904 #---------------------------------------------------------------------------
1905 # Configuration options for the AutoGen Definitions output
1906 #---------------------------------------------------------------------------
1907 
1908 # If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
1909 # AutoGen Definitions (see http://autogen.sf.net) file that captures the
1910 # structure of the code including all documentation. Note that this feature is
1911 # still experimental and incomplete at the moment.
1912 # The default value is: NO.
1913 
1914 GENERATE_AUTOGEN_DEF = NO
1915 
1916 #---------------------------------------------------------------------------
1917 # Configuration options related to the Perl module output
1918 #---------------------------------------------------------------------------
1919 
1920 # If the GENERATE_PERLMOD tag is set to YES, doxygen will generate a Perl module
1921 # file that captures the structure of the code including all documentation.
1922 #
1923 # Note that this feature is still experimental and incomplete at the moment.
1924 # The default value is: NO.
1925 
1926 GENERATE_PERLMOD = NO
1927 
1928 # If the PERLMOD_LATEX tag is set to YES, doxygen will generate the necessary
1929 # Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
1930 # output from the Perl module output.
1931 # The default value is: NO.
1932 # This tag requires that the tag GENERATE_PERLMOD is set to YES.
1933 
1934 PERLMOD_LATEX = NO
1935 
1936 # If the PERLMOD_PRETTY tag is set to YES, the Perl module output will be nicely
1937 # formatted so it can be parsed by a human reader. This is useful if you want to
1938 # understand what is going on. On the other hand, if this tag is set to NO, the
1939 # size of the Perl module output will be much smaller and Perl will parse it
1940 # just the same.
1941 # The default value is: YES.
1942 # This tag requires that the tag GENERATE_PERLMOD is set to YES.
1943 
1944 PERLMOD_PRETTY = YES
1945 
1946 # The names of the make variables in the generated doxyrules.make file are
1947 # prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
1948 # so different doxyrules.make files included by the same Makefile don't
1949 # overwrite each other's variables.
1950 # This tag requires that the tag GENERATE_PERLMOD is set to YES.
1951 
1952 PERLMOD_MAKEVAR_PREFIX =
1953 
1954 #---------------------------------------------------------------------------
1955 # Configuration options related to the preprocessor
1956 #---------------------------------------------------------------------------
1957 
1958 # If the ENABLE_PREPROCESSING tag is set to YES, doxygen will evaluate all
1959 # C-preprocessor directives found in the sources and include files.
1960 # The default value is: YES.
1961 
1962 ENABLE_PREPROCESSING = YES
1963 
1964 # If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
1965 # in the source code. If set to NO, only conditional compilation will be
1966 # performed. Macro expansion can be done in a controlled way by setting
1967 # EXPAND_ONLY_PREDEF to YES.
1968 # The default value is: NO.
1969 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
1970 
1971 MACRO_EXPANSION = NO
1972 
1973 # If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
1974 # the macro expansion is limited to the macros specified with the PREDEFINED and
1975 # EXPAND_AS_DEFINED tags.
1976 # The default value is: NO.
1977 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
1978 
1979 EXPAND_ONLY_PREDEF = NO
1980 
1981 # If the SEARCH_INCLUDES tag is set to YES, the include files in the
1982 # INCLUDE_PATH will be searched if a #include is found.
1983 # The default value is: YES.
1984 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
1985 
1986 SEARCH_INCLUDES = YES
1987 
1988 # The INCLUDE_PATH tag can be used to specify one or more directories that
1989 # contain include files that are not input files but should be processed by the
1990 # preprocessor.
1991 # This tag requires that the tag SEARCH_INCLUDES is set to YES.
1992 
1993 INCLUDE_PATH =
1994 
1995 # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
1996 # patterns (like *.h and *.hpp) to filter out the header-files in the
1997 # directories. If left blank, the patterns specified with FILE_PATTERNS will be
1998 # used.
1999 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
2000 
2001 INCLUDE_FILE_PATTERNS =
2002 
2003 # The PREDEFINED tag can be used to specify one or more macro names that are
2004 # defined before the preprocessor is started (similar to the -D option of e.g.
2005 # gcc). The argument of the tag is a list of macros of the form: name or
2006 # name=definition (no spaces). If the definition and the "=" are omitted, "=1"
2007 # is assumed. To prevent a macro definition from being undefined via #undef or
2008 # recursively expanded use the := operator instead of the = operator.
2009 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
2010 
2011 PREDEFINED =
2012 
2013 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
2014 # tag can be used to specify a list of macro names that should be expanded. The
2015 # macro definition that is found in the sources will be used. Use the PREDEFINED
2016 # tag if you want to use a different macro definition that overrules the
2017 # definition found in the source code.
2018 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
2019 
2020 EXPAND_AS_DEFINED =
2021 
2022 # If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
2023 # remove all references to function-like macros that are alone on a line, have
2024 # an all uppercase name, and do not end with a semicolon. Such function macros
2025 # are typically used for boiler-plate code, and will confuse the parser if not
2026 # removed.
2027 # The default value is: YES.
2028 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
2029 
2030 SKIP_FUNCTION_MACROS = YES
2031 
2032 #---------------------------------------------------------------------------
2033 # Configuration options related to external references
2034 #---------------------------------------------------------------------------
2035 
2036 # The TAGFILES tag can be used to specify one or more tag files. For each tag
2037 # file the location of the external documentation should be added. The format of
2038 # a tag file without this location is as follows:
2039 # TAGFILES = file1 file2 ...
2040 # Adding location for the tag files is done as follows:
2041 # TAGFILES = file1=loc1 "file2 = loc2" ...
2042 # where loc1 and loc2 can be relative or absolute paths or URLs. See the
2043 # section "Linking to external documentation" for more information about the use
2044 # of tag files.
2045 # Note: Each tag file must have a unique name (where the name does NOT include
2046 # the path). If a tag file is not located in the directory in which doxygen is
2047 # run, you must also specify the path to the tagfile here.
2048 
2049 TAGFILES =
2050 
2051 # When a file name is specified after GENERATE_TAGFILE, doxygen will create a
2052 # tag file that is based on the input files it reads. See section "Linking to
2053 # external documentation" for more information about the usage of tag files.
2054 
2055 GENERATE_TAGFILE =
2056 
2057 # If the ALLEXTERNALS tag is set to YES, all external class will be listed in
2058 # the class index. If set to NO, only the inherited external classes will be
2059 # listed.
2060 # The default value is: NO.
2061 
2062 ALLEXTERNALS = NO
2063 
2064 # If the EXTERNAL_GROUPS tag is set to YES, all external groups will be listed
2065 # in the modules index. If set to NO, only the current project's groups will be
2066 # listed.
2067 # The default value is: YES.
2068 
2069 EXTERNAL_GROUPS = YES
2070 
2071 # If the EXTERNAL_PAGES tag is set to YES, all external pages will be listed in
2072 # the related pages index. If set to NO, only the current project's pages will
2073 # be listed.
2074 # The default value is: YES.
2075 
2076 EXTERNAL_PAGES = YES
2077 
2078 # The PERL_PATH should be the absolute path and name of the perl script
2079 # interpreter (i.e. the result of 'which perl').
2080 # The default file (with absolute path) is: /usr/bin/perl.
2081 
2082 PERL_PATH = /usr/bin/perl
2083 
2084 #---------------------------------------------------------------------------
2085 # Configuration options related to the dot tool
2086 #---------------------------------------------------------------------------
2087 
2088 # If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
2089 # (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
2090 # NO turns the diagrams off. Note that this option also works with HAVE_DOT
2091 # disabled, but it is recommended to install and use dot, since it yields more
2092 # powerful graphs.
2093 # The default value is: YES.
2094 
2095 CLASS_DIAGRAMS = YES
2096 
2097 # You can define message sequence charts within doxygen comments using the \msc
2098 # command. Doxygen will then run the mscgen tool (see:
2099 # http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
2100 # documentation. The MSCGEN_PATH tag allows you to specify the directory where
2101 # the mscgen tool resides. If left empty the tool is assumed to be found in the
2102 # default search path.
2103 
2104 MSCGEN_PATH =
2105 
2106 # You can include diagrams made with dia in doxygen documentation. Doxygen will
2107 # then run dia to produce the diagram and insert it in the documentation. The
2108 # DIA_PATH tag allows you to specify the directory where the dia binary resides.
2109 # If left empty dia is assumed to be found in the default search path.
2110 
2111 DIA_PATH =
2112 
2113 # If set to YES the inheritance and collaboration graphs will hide inheritance
2114 # and usage relations if the target is undocumented or is not a class.
2115 # The default value is: YES.
2116 
2117 HIDE_UNDOC_RELATIONS = YES
2118 
2119 # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
2120 # available from the path. This tool is part of Graphviz (see:
2121 # http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
2122 # Bell Labs. The other options in this section have no effect if this option is
2123 # set to NO
2124 # The default value is: NO.
2125 
2126 HAVE_DOT = NO
2127 
2128 # The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
2129 # to run in parallel. When set to 0 doxygen will base this on the number of
2130 # processors available in the system. You can set it explicitly to a value
2131 # larger than 0 to get control over the balance between CPU load and processing
2132 # speed.
2133 # Minimum value: 0, maximum value: 32, default value: 0.
2134 # This tag requires that the tag HAVE_DOT is set to YES.
2135 
2136 DOT_NUM_THREADS = 0
2137 
2138 # When you want a differently looking font in the dot files that doxygen
2139 # generates you can specify the font name using DOT_FONTNAME. You need to make
2140 # sure dot is able to find the font, which can be done by putting it in a
2141 # standard location or by setting the DOTFONTPATH environment variable or by
2142 # setting DOT_FONTPATH to the directory containing the font.
2143 # The default value is: Helvetica.
2144 # This tag requires that the tag HAVE_DOT is set to YES.
2145 
2146 DOT_FONTNAME = Helvetica
2147 
2148 # The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
2149 # dot graphs.
2150 # Minimum value: 4, maximum value: 24, default value: 10.
2151 # This tag requires that the tag HAVE_DOT is set to YES.
2152 
2153 DOT_FONTSIZE = 10
2154 
2155 # By default doxygen will tell dot to use the default font as specified with
2156 # DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
2157 # the path where dot can find it using this tag.
2158 # This tag requires that the tag HAVE_DOT is set to YES.
2159 
2160 DOT_FONTPATH =
2161 
2162 # If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
2163 # each documented class showing the direct and indirect inheritance relations.
2164 # Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
2165 # The default value is: YES.
2166 # This tag requires that the tag HAVE_DOT is set to YES.
2167 
2168 CLASS_GRAPH = YES
2169 
2170 # If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
2171 # graph for each documented class showing the direct and indirect implementation
2172 # dependencies (inheritance, containment, and class references variables) of the
2173 # class with other documented classes.
2174 # The default value is: YES.
2175 # This tag requires that the tag HAVE_DOT is set to YES.
2176 
2177 COLLABORATION_GRAPH = YES
2178 
2179 # If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
2180 # groups, showing the direct groups dependencies.
2181 # The default value is: YES.
2182 # This tag requires that the tag HAVE_DOT is set to YES.
2183 
2184 GROUP_GRAPHS = YES
2185 
2186 # If the UML_LOOK tag is set to YES, doxygen will generate inheritance and
2187 # collaboration diagrams in a style similar to the OMG's Unified Modeling
2188 # Language.
2189 # The default value is: NO.
2190 # This tag requires that the tag HAVE_DOT is set to YES.
2191 
2192 UML_LOOK = NO
2193 
2194 # If the UML_LOOK tag is enabled, the fields and methods are shown inside the
2195 # class node. If there are many fields or methods and many nodes the graph may
2196 # become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
2197 # number of items for each type to make the size more manageable. Set this to 0
2198 # for no limit. Note that the threshold may be exceeded by 50% before the limit
2199 # is enforced. So when you set the threshold to 10, up to 15 fields may appear,
2200 # but if the number exceeds 15, the total amount of fields shown is limited to
2201 # 10.
2202 # Minimum value: 0, maximum value: 100, default value: 10.
2203 # This tag requires that the tag HAVE_DOT is set to YES.
2204 
2205 UML_LIMIT_NUM_FIELDS = 10
2206 
2207 # If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
2208 # collaboration graphs will show the relations between templates and their
2209 # instances.
2210 # The default value is: NO.
2211 # This tag requires that the tag HAVE_DOT is set to YES.
2212 
2213 TEMPLATE_RELATIONS = NO
2214 
2215 # If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
2216 # YES then doxygen will generate a graph for each documented file showing the
2217 # direct and indirect include dependencies of the file with other documented
2218 # files.
2219 # The default value is: YES.
2220 # This tag requires that the tag HAVE_DOT is set to YES.
2221 
2222 INCLUDE_GRAPH = YES
2223 
2224 # If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
2225 # set to YES then doxygen will generate a graph for each documented file showing
2226 # the direct and indirect include dependencies of the file with other documented
2227 # files.
2228 # The default value is: YES.
2229 # This tag requires that the tag HAVE_DOT is set to YES.
2230 
2231 INCLUDED_BY_GRAPH = YES
2232 
2233 # If the CALL_GRAPH tag is set to YES then doxygen will generate a call
2234 # dependency graph for every global function or class method.
2235 #
2236 # Note that enabling this option will significantly increase the time of a run.
2237 # So in most cases it will be better to enable call graphs for selected
2238 # functions only using the \callgraph command. Disabling a call graph can be
2239 # accomplished by means of the command \hidecallgraph.
2240 # The default value is: NO.
2241 # This tag requires that the tag HAVE_DOT is set to YES.
2242 
2243 CALL_GRAPH = YES
2244 
2245 # If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
2246 # dependency graph for every global function or class method.
2247 #
2248 # Note that enabling this option will significantly increase the time of a run.
2249 # So in most cases it will be better to enable caller graphs for selected
2250 # functions only using the \callergraph command. Disabling a caller graph can be
2251 # accomplished by means of the command \hidecallergraph.
2252 # The default value is: NO.
2253 # This tag requires that the tag HAVE_DOT is set to YES.
2254 
2255 CALLER_GRAPH = YES
2256 
2257 # If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
2258 # hierarchy of all classes instead of a textual one.
2259 # The default value is: YES.
2260 # This tag requires that the tag HAVE_DOT is set to YES.
2261 
2262 GRAPHICAL_HIERARCHY = YES
2263 
2264 # If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
2265 # dependencies a directory has on other directories in a graphical way. The
2266 # dependency relations are determined by the #include relations between the
2267 # files in the directories.
2268 # The default value is: YES.
2269 # This tag requires that the tag HAVE_DOT is set to YES.
2270 
2271 DIRECTORY_GRAPH = YES
2272 
2273 # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
2274 # generated by dot. For an explanation of the image formats see the section
2275 # output formats in the documentation of the dot tool (Graphviz (see:
2276 # http://www.graphviz.org/)).
2277 # Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
2278 # to make the SVG files visible in IE 9+ (other browsers do not have this
2279 # requirement).
2280 # Possible values are: png, jpg, gif, svg, png:gd, png:gd:gd, png:cairo,
2281 # png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
2282 # png:gdiplus:gdiplus.
2283 # The default value is: png.
2284 # This tag requires that the tag HAVE_DOT is set to YES.
2285 
2286 DOT_IMAGE_FORMAT = png
2287 
2288 # If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
2289 # enable generation of interactive SVG images that allow zooming and panning.
2290 #
2291 # Note that this requires a modern browser other than Internet Explorer. Tested
2292 # and working are Firefox, Chrome, Safari, and Opera.
2293 # Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
2294 # the SVG files visible. Older versions of IE do not have SVG support.
2295 # The default value is: NO.
2296 # This tag requires that the tag HAVE_DOT is set to YES.
2297 
2298 INTERACTIVE_SVG = NO
2299 
2300 # The DOT_PATH tag can be used to specify the path where the dot tool can be
2301 # found. If left blank, it is assumed the dot tool can be found in the path.
2302 # This tag requires that the tag HAVE_DOT is set to YES.
2303 
2304 DOT_PATH =
2305 
2306 # The DOTFILE_DIRS tag can be used to specify one or more directories that
2307 # contain dot files that are included in the documentation (see the \dotfile
2308 # command).
2309 # This tag requires that the tag HAVE_DOT is set to YES.
2310 
2311 DOTFILE_DIRS =
2312 
2313 # The MSCFILE_DIRS tag can be used to specify one or more directories that
2314 # contain msc files that are included in the documentation (see the \mscfile
2315 # command).
2316 
2317 MSCFILE_DIRS =
2318 
2319 # The DIAFILE_DIRS tag can be used to specify one or more directories that
2320 # contain dia files that are included in the documentation (see the \diafile
2321 # command).
2322 
2323 DIAFILE_DIRS =
2324 
2325 # When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
2326 # path where java can find the plantuml.jar file. If left blank, it is assumed
2327 # PlantUML is not used or called during a preprocessing step. Doxygen will
2328 # generate a warning when it encounters a \startuml command in this case and
2329 # will not generate output for the diagram.
2330 
2331 PLANTUML_JAR_PATH =
2332 
2333 # When using plantuml, the specified paths are searched for files specified by
2334 # the !include statement in a plantuml block.
2335 
2336 PLANTUML_INCLUDE_PATH =
2337 
2338 # The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
2339 # that will be shown in the graph. If the number of nodes in a graph becomes
2340 # larger than this value, doxygen will truncate the graph, which is visualized
2341 # by representing a node as a red box. Note that doxygen if the number of direct
2342 # children of the root node in a graph is already larger than
2343 # DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
2344 # the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
2345 # Minimum value: 0, maximum value: 10000, default value: 50.
2346 # This tag requires that the tag HAVE_DOT is set to YES.
2347 
2348 DOT_GRAPH_MAX_NODES = 50
2349 
2350 # The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
2351 # generated by dot. A depth value of 3 means that only nodes reachable from the
2352 # root by following a path via at most 3 edges will be shown. Nodes that lay
2353 # further from the root node will be omitted. Note that setting this option to 1
2354 # or 2 may greatly reduce the computation time needed for large code bases. Also
2355 # note that the size of a graph can be further restricted by
2356 # DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
2357 # Minimum value: 0, maximum value: 1000, default value: 0.
2358 # This tag requires that the tag HAVE_DOT is set to YES.
2359 
2360 MAX_DOT_GRAPH_DEPTH = 1000
2361 
2362 # Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
2363 # background. This is disabled by default, because dot on Windows does not seem
2364 # to support this out of the box.
2365 #
2366 # Warning: Depending on the platform used, enabling this option may lead to
2367 # badly anti-aliased labels on the edges of a graph (i.e. they become hard to
2368 # read).
2369 # The default value is: NO.
2370 # This tag requires that the tag HAVE_DOT is set to YES.
2371 
2372 DOT_TRANSPARENT = NO
2373 
2374 # Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
2375 # files in one run (i.e. multiple -o and -T options on the command line). This
2376 # makes dot run faster, but since only newer versions of dot (>1.8.10) support
2377 # this, this feature is disabled by default.
2378 # The default value is: NO.
2379 # This tag requires that the tag HAVE_DOT is set to YES.
2380 
2381 DOT_MULTI_TARGETS = NO
2382 
2383 # If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
2384 # explaining the meaning of the various boxes and arrows in the dot generated
2385 # graphs.
2386 # The default value is: YES.
2387 # This tag requires that the tag HAVE_DOT is set to YES.
2388 
2389 GENERATE_LEGEND = YES
2390 
2391 # If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate dot
2392 # files that are used to generate the various graphs.
2393 # The default value is: YES.
2394 # This tag requires that the tag HAVE_DOT is set to YES.
2395 
2396 DOT_CLEANUP = YES
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00058.html000066400000000000000000000101661356361734700216530ustar00rootroot00000000000000 0.9.7: mat2x2.hpp File Reference
mat2x2.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-12-24 / 2013-12-24
Author
Christophe Riccio

Definition in file mat2x2.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00058_source.html000066400000000000000000000207201356361734700232300ustar00rootroot00000000000000 0.9.7: mat2x2.hpp Source File
mat2x2.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "detail/type_mat2x2.hpp"
36 
37 namespace glm
38 {
44  typedef tmat2x2<float, lowp> lowp_mat2;
45 
51  typedef tmat2x2<float, mediump> mediump_mat2;
52 
58  typedef tmat2x2<float, highp> highp_mat2;
59 
65  typedef tmat2x2<float, lowp> lowp_mat2x2;
66 
72  typedef tmat2x2<float, mediump> mediump_mat2x2;
73 
79  typedef tmat2x2<float, highp> highp_mat2x2;
80 
81 }//namespace glm
glm::mediump_mat2
tmat2x2< float, mediump > mediump_mat2
2 columns of 2 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:72
type_mat2x2.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::mediump_mat2x2
tmat2x2< float, mediump > mediump_mat2x2
2 columns of 2 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:93
glm
Definition: _noise.hpp:40
glm::lowp_mat2x2
tmat2x2< float, lowp > lowp_mat2x2
2 columns of 2 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:86
glm::highp_mat2
tmat2x2< float, highp > highp_mat2
2 columns of 2 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:79
glm::highp_mat2x2
tmat2x2< float, highp > highp_mat2x2
2 columns of 2 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:100
glm::lowp_mat2
tmat2x2< float, lowp > lowp_mat2
2 columns of 2 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:65
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00059.html000066400000000000000000000101661356361734700216540ustar00rootroot00000000000000 0.9.7: mat2x3.hpp File Reference
mat2x3.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-12-24 / 2013-12-24
Author
Christophe Riccio

Definition in file mat2x3.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00059_source.html000066400000000000000000000143231356361734700232330ustar00rootroot00000000000000 0.9.7: mat2x3.hpp Source File
mat2x3.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "detail/type_mat2x3.hpp"
36 
37 namespace glm
38 {
44  typedef tmat2x3<float, lowp> lowp_mat2x3;
45 
51  typedef tmat2x3<float, mediump> mediump_mat2x3;
52 
58  typedef tmat2x3<float, highp> highp_mat2x3;
59 
60 }//namespace glm
61 
type_mat2x3.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::lowp_mat2x3
tmat2x3< float, lowp > lowp_mat2x3
2 columns of 3 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:112
glm::mediump_mat2x3
tmat2x3< float, mediump > mediump_mat2x3
2 columns of 3 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:119
glm::highp_mat2x3
tmat2x3< float, highp > highp_mat2x3
2 columns of 3 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:126
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00060.html000066400000000000000000000101661356361734700216440ustar00rootroot00000000000000 0.9.7: mat2x4.hpp File Reference
mat2x4.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-12-24 / 2013-12-24
Author
Christophe Riccio

Definition in file mat2x4.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00060_source.html000066400000000000000000000142161356361734700232240ustar00rootroot00000000000000 0.9.7: mat2x4.hpp Source File
mat2x4.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "detail/type_mat2x4.hpp"
36 
37 namespace glm
38 {
44  typedef tmat2x4<float, lowp> lowp_mat2x4;
45 
51  typedef tmat2x4<float, mediump> mediump_mat2x4;
52 
58  typedef tmat2x4<float, highp> highp_mat2x4;
59 
60 }//namespace glm
glm::mediump_mat2x4
tmat2x4< float, mediump > mediump_mat2x4
2 columns of 4 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:145
type_mat2x4.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::lowp_mat2x4
tmat2x4< float, lowp > lowp_mat2x4
2 columns of 4 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:138
glm::highp_mat2x4
tmat2x4< float, highp > highp_mat2x4
2 columns of 4 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:152
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00061.html000066400000000000000000000101661356361734700216450ustar00rootroot00000000000000 0.9.7: mat3x2.hpp File Reference
mat3x2.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-12-24 / 2013-12-24
Author
Christophe Riccio

Definition in file mat3x2.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00061_source.html000066400000000000000000000142121356361734700232210ustar00rootroot00000000000000 0.9.7: mat3x2.hpp Source File
mat3x2.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "detail/type_mat3x2.hpp"
36 
37 namespace glm
38 {
44  typedef tmat3x2<float, lowp> lowp_mat3x2;
45 
51  typedef tmat3x2<float, mediump> mediump_mat3x2;
52 
58  typedef tmat3x2<float, highp> highp_mat3x2;
59 
60 }//namespace
type_mat3x2.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::highp_mat3x2
tmat3x2< float, highp > highp_mat3x2
3 columns of 2 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:178
glm::lowp_mat3x2
tmat3x2< float, lowp > lowp_mat3x2
3 columns of 2 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:164
glm
Definition: _noise.hpp:40
glm::mediump_mat3x2
tmat3x2< float, mediump > mediump_mat3x2
3 columns of 2 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:171
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00062.html000066400000000000000000000101661356361734700216460ustar00rootroot00000000000000 0.9.7: mat3x3.hpp File Reference
mat3x3.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-12-24 / 2013-12-24
Author
Christophe Riccio

Definition in file mat3x3.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00062_source.html000066400000000000000000000207251356361734700232300ustar00rootroot00000000000000 0.9.7: mat3x3.hpp Source File
mat3x3.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "detail/type_mat3x3.hpp"
36 
37 namespace glm
38 {
44  typedef tmat3x3<float, lowp> lowp_mat3;
45 
51  typedef tmat3x3<float, mediump> mediump_mat3;
52 
58  typedef tmat3x3<float, highp> highp_mat3;
59 
65  typedef tmat3x3<float, lowp> lowp_mat3x3;
66 
72  typedef tmat3x3<float, mediump> mediump_mat3x3;
73 
79  typedef tmat3x3<float, highp> highp_mat3x3;
80 
81 }//namespace glm
glm::mediump_mat3
tmat3x3< float, mediump > mediump_mat3
3 columns of 3 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:197
glm::highp_mat3x3
tmat3x3< float, highp > highp_mat3x3
3 columns of 3 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:225
glm::lowp_mat3
tmat3x3< float, lowp > lowp_mat3
3 columns of 3 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:190
glm::mediump_mat3x3
tmat3x3< float, mediump > mediump_mat3x3
3 columns of 3 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:218
glm
Definition: _noise.hpp:40
glm::lowp_mat3x3
tmat3x3< float, lowp > lowp_mat3x3
3 columns of 3 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:211
type_mat3x3.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::highp_mat3
tmat3x3< float, highp > highp_mat3
3 columns of 3 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:204
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00063.html000066400000000000000000000101661356361734700216470ustar00rootroot00000000000000 0.9.7: mat3x4.hpp File Reference
mat3x4.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-12-24 / 2013-12-24
Author
Christophe Riccio

Definition in file mat3x4.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00063_source.html000066400000000000000000000142161356361734700232270ustar00rootroot00000000000000 0.9.7: mat3x4.hpp Source File
mat3x4.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "detail/type_mat3x4.hpp"
36 
37 namespace glm
38 {
44  typedef tmat3x4<float, lowp> lowp_mat3x4;
45 
51  typedef tmat3x4<float, mediump> mediump_mat3x4;
52 
58  typedef tmat3x4<float, highp> highp_mat3x4;
59 
60 }//namespace glm
glm::mediump_mat3x4
tmat3x4< float, mediump > mediump_mat3x4
3 columns of 4 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:244
type_mat3x4.hpp
OpenGL Mathematics (glm.g-truc.net)
glm
Definition: _noise.hpp:40
glm::lowp_mat3x4
tmat3x4< float, lowp > lowp_mat3x4
3 columns of 4 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:237
glm::highp_mat3x4
tmat3x4< float, highp > highp_mat3x4
3 columns of 4 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:251
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00064.html000066400000000000000000000101661356361734700216500ustar00rootroot00000000000000 0.9.7: mat4x2.hpp File Reference
mat4x2.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-12-24 / 2013-12-24
Author
Christophe Riccio

Definition in file mat4x2.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00064_source.html000066400000000000000000000142161356361734700232300ustar00rootroot00000000000000 0.9.7: mat4x2.hpp Source File
mat4x2.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "detail/type_mat4x2.hpp"
36 
37 namespace glm
38 {
44  typedef tmat4x2<float, lowp> lowp_mat4x2;
45 
51  typedef tmat4x2<float, mediump> mediump_mat4x2;
52 
58  typedef tmat4x2<float, highp> highp_mat4x2;
59 
60 }//namespace glm
type_mat4x2.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::lowp_mat4x2
tmat4x2< float, lowp > lowp_mat4x2
4 columns of 2 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:263
glm
Definition: _noise.hpp:40
glm::mediump_mat4x2
tmat4x2< float, mediump > mediump_mat4x2
4 columns of 2 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:270
glm::highp_mat4x2
tmat4x2< float, highp > highp_mat4x2
4 columns of 2 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:277
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00065_source.html000066400000000000000000000141171356361734700232310ustar00rootroot00000000000000 0.9.7: mat4x3.hpp Source File
mat4x3.hpp
1 
33 #pragma once
34 
35 #include "detail/type_mat4x3.hpp"
36 
37 namespace glm
38 {
44  typedef tmat4x3<float, lowp> lowp_mat4x3;
45 
51  typedef tmat4x3<float, mediump> mediump_mat4x3;
52 
58  typedef tmat4x3<float, highp> highp_mat4x3;
59 
60 }//namespace glm
glm::highp_mat4x3
tmat4x3< float, highp > highp_mat4x3
4 columns of 3 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:303
glm::lowp_mat4x3
tmat4x3< float, lowp > lowp_mat4x3
4 columns of 3 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:289
glm
Definition: _noise.hpp:40
glm::mediump_mat4x3
tmat4x3< float, mediump > mediump_mat4x3
4 columns of 3 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:296
type_mat4x3.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00066.html000066400000000000000000000101661356361734700216520ustar00rootroot00000000000000 0.9.7: mat4x4.hpp File Reference
mat4x4.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-12-24 / 2013-12-24
Author
Christophe Riccio

Definition in file mat4x4.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00066_source.html000066400000000000000000000207251356361734700232340ustar00rootroot00000000000000 0.9.7: mat4x4.hpp Source File
mat4x4.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "detail/type_mat4x4.hpp"
36 
37 namespace glm
38 {
44  typedef tmat4x4<float, lowp> lowp_mat4;
45 
51  typedef tmat4x4<float, mediump> mediump_mat4;
52 
58  typedef tmat4x4<float, highp> highp_mat4;
59 
65  typedef tmat4x4<float, lowp> lowp_mat4x4;
66 
72  typedef tmat4x4<float, mediump> mediump_mat4x4;
73 
79  typedef tmat4x4<float, highp> highp_mat4x4;
80 
81 }//namespace glm
glm::lowp_mat4x4
tmat4x4< float, lowp > lowp_mat4x4
4 columns of 4 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:337
glm::highp_mat4
tmat4x4< float, highp > highp_mat4
4 columns of 4 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:330
type_mat4x4.hpp
OpenGL Mathematics (glm.g-truc.net)
glm
Definition: _noise.hpp:40
glm::lowp_mat4
tmat4x4< float, lowp > lowp_mat4
4 columns of 4 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:316
glm::highp_mat4x4
tmat4x4< float, highp > highp_mat4x4
4 columns of 4 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:351
glm::mediump_mat4
tmat4x4< float, mediump > mediump_mat4
4 columns of 4 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:323
glm::mediump_mat4x4
tmat4x4< float, mediump > mediump_mat4x4
4 columns of 4 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:344
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00067.html000066400000000000000000000101661356361734700216530ustar00rootroot00000000000000 0.9.7: matrix.hpp File Reference
matrix.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-12-24 / 2013-12-24
Author
Christophe Riccio

Definition in file matrix.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00067_source.html000066400000000000000000000062511356361734700232330ustar00rootroot00000000000000 0.9.7: matrix.hpp Source File
matrix.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "detail/func_matrix.hpp"
func_matrix.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00068.html000066400000000000000000000157551356361734700216650ustar00rootroot00000000000000 0.9.7: matrix_access.hpp File Reference
Functions
matrix_access.hpp File Reference

Go to the source code of this file.

Functions

template<typename genType >
GLM_FUNC_DECL genType::col_type column (genType const &m, length_t index)
 
template<typename genType >
GLM_FUNC_DECL genType column (genType const &m, length_t index, typename genType::col_type const &x)
 
template<typename genType >
GLM_FUNC_DECL genType::row_type row (genType const &m, length_t index)
 
template<typename genType >
GLM_FUNC_DECL genType row (genType const &m, length_t index, typename genType::row_type const &x)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTC_matrix_access

Date
2005-12-27 / 2011-05-16
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file matrix_access.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00068_source.html000066400000000000000000000214461356361734700232370ustar00rootroot00000000000000 0.9.7: matrix_access.hpp Source File
matrix_access.hpp
Go to the documentation of this file.
1 
41 #pragma once
42 
43 // Dependency:
44 #include "../detail/setup.hpp"
45 
46 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
47 # pragma message("GLM: GLM_GTC_matrix_access extension included")
48 #endif
49 
50 namespace glm
51 {
54 
57  template <typename genType>
58  GLM_FUNC_DECL typename genType::row_type row(
59  genType const & m,
60  length_t index);
61 
64  template <typename genType>
65  GLM_FUNC_DECL genType row(
66  genType const & m,
67  length_t index,
68  typename genType::row_type const & x);
69 
72  template <typename genType>
73  GLM_FUNC_DECL typename genType::col_type column(
74  genType const & m,
75  length_t index);
76 
79  template <typename genType>
80  GLM_FUNC_DECL genType column(
81  genType const & m,
82  length_t index,
83  typename genType::col_type const & x);
84 
86 }//namespace glm
87 
88 #include "matrix_access.inl"
glm::column
GLM_FUNC_DECL genType column(genType const &m, length_t index, typename genType::col_type const &x)
Set a specific column to a matrix.
glm
Definition: _noise.hpp:40
glm::row
GLM_FUNC_DECL genType row(genType const &m, length_t index, typename genType::row_type const &x)
Set a specific row to a matrix.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00069.html000066400000000000000000000137651356361734700216650ustar00rootroot00000000000000 0.9.7: matrix_cross_product.hpp File Reference
Functions
matrix_cross_product.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > matrixCross3 (tvec3< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > matrixCross4 (tvec3< T, P > const &x)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_matrix_cross_product

Date
2005-12-21 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTX_extented_min_max (dependence)

Definition in file matrix_cross_product.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00069_source.html000066400000000000000000000153321356361734700232350ustar00rootroot00000000000000 0.9.7: matrix_cross_product.hpp Source File
matrix_cross_product.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependency:
46 #include "../glm.hpp"
47 
48 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
49 # pragma message("GLM: GLM_GTX_matrix_cross_product extension included")
50 #endif
51 
52 namespace glm
53 {
56 
59  template <typename T, precision P>
60  GLM_FUNC_DECL tmat3x3<T, P> matrixCross3(
61  tvec3<T, P> const & x);
62 
65  template <typename T, precision P>
66  GLM_FUNC_DECL tmat4x4<T, P> matrixCross4(
67  tvec3<T, P> const & x);
68 
70 }//namespace glm
71 
72 #include "matrix_cross_product.inl"
glm::matrixCross4
GLM_FUNC_DECL tmat4x4< T, P > matrixCross4(tvec3< T, P > const &x)
Build a cross product matrix.
glm::matrixCross3
GLM_FUNC_DECL tmat3x3< T, P > matrixCross3(tvec3< T, P > const &x)
Build a cross product matrix.
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00070.html000066400000000000000000000126641356361734700216520ustar00rootroot00000000000000 0.9.7: matrix_decompose.hpp File Reference
Functions
matrix_decompose.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P>
GLM_FUNC_DECL bool decompose (tmat4x4< T, P > const &modelMatrix, tvec3< T, P > &scale, tquat< T, P > &orientation, tvec3< T, P > &translation, tvec3< T, P > &skew, tvec4< T, P > &perspective)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_matrix_decompose

Date
2014-08-29 / 2014-08-29
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file matrix_decompose.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00070_source.html000066400000000000000000000203331356361734700232220ustar00rootroot00000000000000 0.9.7: matrix_decompose.hpp Source File
matrix_decompose.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependencies
45 #include "../mat4x4.hpp"
46 #include "../vec3.hpp"
47 #include "../vec4.hpp"
48 #include "../gtc/quaternion.hpp"
49 #include "../gtc/matrix_transform.hpp"
50 
51 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
52 # pragma message("GLM: GLM_GTX_matrix_decompose extension included")
53 #endif
54 
55 namespace glm
56 {
59 
62  template <typename T, precision P>
63  GLM_FUNC_DECL bool decompose(
64  tmat4x4<T, P> const & modelMatrix,
65  tvec3<T, P> & scale, tquat<T, P> & orientation, tvec3<T, P> & translation, tvec3<T, P> & skew, tvec4<T, P> & perspective);
66 
68 }//namespace glm
69 
70 #include "matrix_decompose.inl"
glm::perspective
GLM_FUNC_DECL tmat4x4< T, defaultp > perspective(T fovy, T aspect, T near, T far)
Creates a matrix for a symetric perspective-view frustum based on the default handedness.
glm::orientation
GLM_FUNC_DECL tmat4x4< T, P > orientation(tvec3< T, P > const &Normal, tvec3< T, P > const &Up)
Build a rotation matrix from a normal and a up vector.
glm
Definition: _noise.hpp:40
glm::decompose
GLM_FUNC_DECL bool decompose(tmat4x4< T, P > const &modelMatrix, tvec3< T, P > &scale, tquat< T, P > &orientation, tvec3< T, P > &translation, tvec3< T, P > &skew, tvec4< T, P > &perspective)
Decomposes a model matrix to translations, rotation and scale components.
glm::scale
GLM_FUNC_DECL tmat4x4< T, P > scale(tmat4x4< T, P > const &m, tvec3< T, P > const &v)
Builds a scale 4 * 4 matrix created from 3 scalars.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00071.html000066400000000000000000001234411356361734700216470ustar00rootroot00000000000000 0.9.7: matrix_integer.hpp File Reference
Typedefs
matrix_integer.hpp File Reference

Go to the source code of this file.

Typedefs

typedef tmat2x2< int, highp > highp_imat2
 
typedef tmat2x2< int, highp > highp_imat2x2
 
typedef tmat2x3< int, highp > highp_imat2x3
 
typedef tmat2x4< int, highp > highp_imat2x4
 
typedef tmat3x3< int, highp > highp_imat3
 
typedef tmat3x2< int, highp > highp_imat3x2
 
typedef tmat3x3< int, highp > highp_imat3x3
 
typedef tmat3x4< int, highp > highp_imat3x4
 
typedef tmat4x4< int, highp > highp_imat4
 
typedef tmat4x2< int, highp > highp_imat4x2
 
typedef tmat4x3< int, highp > highp_imat4x3
 
typedef tmat4x4< int, highp > highp_imat4x4
 
typedef tmat2x2< uint, highp > highp_umat2
 
typedef tmat2x2< uint, highp > highp_umat2x2
 
typedef tmat2x3< uint, highp > highp_umat2x3
 
typedef tmat2x4< uint, highp > highp_umat2x4
 
typedef tmat3x3< uint, highp > highp_umat3
 
typedef tmat3x2< uint, highp > highp_umat3x2
 
typedef tmat3x3< uint, highp > highp_umat3x3
 
typedef tmat3x4< uint, highp > highp_umat3x4
 
typedef tmat4x4< uint, highp > highp_umat4
 
typedef tmat4x2< uint, highp > highp_umat4x2
 
typedef tmat4x3< uint, highp > highp_umat4x3
 
typedef tmat4x4< uint, highp > highp_umat4x4
 
typedef mediump_imat2 imat2
 
typedef mediump_imat2x2 imat2x2
 
typedef mediump_imat2x3 imat2x3
 
typedef mediump_imat2x4 imat2x4
 
typedef mediump_imat3 imat3
 
typedef mediump_imat3x2 imat3x2
 
typedef mediump_imat3x3 imat3x3
 
typedef mediump_imat3x4 imat3x4
 
typedef mediump_imat4 imat4
 
typedef mediump_imat4x2 imat4x2
 
typedef mediump_imat4x3 imat4x3
 
typedef mediump_imat4x4 imat4x4
 
typedef tmat2x2< int, lowp > lowp_imat2
 
typedef tmat2x2< int, lowp > lowp_imat2x2
 
typedef tmat2x3< int, lowp > lowp_imat2x3
 
typedef tmat2x4< int, lowp > lowp_imat2x4
 
typedef tmat3x3< int, lowp > lowp_imat3
 
typedef tmat3x2< int, lowp > lowp_imat3x2
 
typedef tmat3x3< int, lowp > lowp_imat3x3
 
typedef tmat3x4< int, lowp > lowp_imat3x4
 
typedef tmat4x4< int, lowp > lowp_imat4
 
typedef tmat4x2< int, lowp > lowp_imat4x2
 
typedef tmat4x3< int, lowp > lowp_imat4x3
 
typedef tmat4x4< int, lowp > lowp_imat4x4
 
typedef tmat2x2< uint, lowp > lowp_umat2
 
typedef tmat2x2< uint, lowp > lowp_umat2x2
 
typedef tmat2x3< uint, lowp > lowp_umat2x3
 
typedef tmat2x4< uint, lowp > lowp_umat2x4
 
typedef tmat3x3< uint, lowp > lowp_umat3
 
typedef tmat3x2< uint, lowp > lowp_umat3x2
 
typedef tmat3x3< uint, lowp > lowp_umat3x3
 
typedef tmat3x4< uint, lowp > lowp_umat3x4
 
typedef tmat4x4< uint, lowp > lowp_umat4
 
typedef tmat4x2< uint, lowp > lowp_umat4x2
 
typedef tmat4x3< uint, lowp > lowp_umat4x3
 
typedef tmat4x4< uint, lowp > lowp_umat4x4
 
typedef tmat2x2< int, mediump > mediump_imat2
 
typedef tmat2x2< int, mediump > mediump_imat2x2
 
typedef tmat2x3< int, mediump > mediump_imat2x3
 
typedef tmat2x4< int, mediump > mediump_imat2x4
 
typedef tmat3x3< int, mediump > mediump_imat3
 
typedef tmat3x2< int, mediump > mediump_imat3x2
 
typedef tmat3x3< int, mediump > mediump_imat3x3
 
typedef tmat3x4< int, mediump > mediump_imat3x4
 
typedef tmat4x4< int, mediump > mediump_imat4
 
typedef tmat4x2< int, mediump > mediump_imat4x2
 
typedef tmat4x3< int, mediump > mediump_imat4x3
 
typedef tmat4x4< int, mediump > mediump_imat4x4
 
typedef tmat2x2< uint, mediump > mediump_umat2
 
typedef tmat2x2< uint, mediump > mediump_umat2x2
 
typedef tmat2x3< uint, mediump > mediump_umat2x3
 
typedef tmat2x4< uint, mediump > mediump_umat2x4
 
typedef tmat3x3< uint, mediump > mediump_umat3
 
typedef tmat3x2< uint, mediump > mediump_umat3x2
 
typedef tmat3x3< uint, mediump > mediump_umat3x3
 
typedef tmat3x4< uint, mediump > mediump_umat3x4
 
typedef tmat4x4< uint, mediump > mediump_umat4
 
typedef tmat4x2< uint, mediump > mediump_umat4x2
 
typedef tmat4x3< uint, mediump > mediump_umat4x3
 
typedef tmat4x4< uint, mediump > mediump_umat4x4
 
typedef mediump_umat2 umat2
 
typedef mediump_umat2x2 umat2x2
 
typedef mediump_umat2x3 umat2x3
 
typedef mediump_umat2x4 umat2x4
 
typedef mediump_umat3 umat3
 
typedef mediump_umat3x2 umat3x2
 
typedef mediump_umat3x3 umat3x3
 
typedef mediump_umat3x4 umat3x4
 
typedef mediump_umat4 umat4
 
typedef mediump_umat4x2 umat4x2
 
typedef mediump_umat4x3 umat4x3
 
typedef mediump_umat4x4 umat4x4
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTC_matrix_integer

Date
2011-01-20 / 2011-06-05
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file matrix_integer.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00071_source.html000066400000000000000000003074631356361734700232370ustar00rootroot00000000000000 0.9.7: matrix_integer.hpp Source File
matrix_integer.hpp
Go to the documentation of this file.
1 
41 #pragma once
42 
43 // Dependency:
44 #include "../mat2x2.hpp"
45 #include "../mat2x3.hpp"
46 #include "../mat2x4.hpp"
47 #include "../mat3x2.hpp"
48 #include "../mat3x3.hpp"
49 #include "../mat3x4.hpp"
50 #include "../mat4x2.hpp"
51 #include "../mat4x3.hpp"
52 #include "../mat4x4.hpp"
53 
54 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
55 # pragma message("GLM: GLM_GTC_matrix_integer extension included")
56 #endif
57 
58 namespace glm
59 {
62 
65  typedef tmat2x2<int, highp> highp_imat2;
66 
69  typedef tmat3x3<int, highp> highp_imat3;
70 
73  typedef tmat4x4<int, highp> highp_imat4;
74 
77  typedef tmat2x2<int, highp> highp_imat2x2;
78 
81  typedef tmat2x3<int, highp> highp_imat2x3;
82 
85  typedef tmat2x4<int, highp> highp_imat2x4;
86 
89  typedef tmat3x2<int, highp> highp_imat3x2;
90 
93  typedef tmat3x3<int, highp> highp_imat3x3;
94 
97  typedef tmat3x4<int, highp> highp_imat3x4;
98 
101  typedef tmat4x2<int, highp> highp_imat4x2;
102 
105  typedef tmat4x3<int, highp> highp_imat4x3;
106 
109  typedef tmat4x4<int, highp> highp_imat4x4;
110 
111 
114  typedef tmat2x2<int, mediump> mediump_imat2;
115 
118  typedef tmat3x3<int, mediump> mediump_imat3;
119 
122  typedef tmat4x4<int, mediump> mediump_imat4;
123 
124 
127  typedef tmat2x2<int, mediump> mediump_imat2x2;
128 
131  typedef tmat2x3<int, mediump> mediump_imat2x3;
132 
135  typedef tmat2x4<int, mediump> mediump_imat2x4;
136 
139  typedef tmat3x2<int, mediump> mediump_imat3x2;
140 
143  typedef tmat3x3<int, mediump> mediump_imat3x3;
144 
147  typedef tmat3x4<int, mediump> mediump_imat3x4;
148 
151  typedef tmat4x2<int, mediump> mediump_imat4x2;
152 
155  typedef tmat4x3<int, mediump> mediump_imat4x3;
156 
159  typedef tmat4x4<int, mediump> mediump_imat4x4;
160 
161 
164  typedef tmat2x2<int, lowp> lowp_imat2;
165 
168  typedef tmat3x3<int, lowp> lowp_imat3;
169 
172  typedef tmat4x4<int, lowp> lowp_imat4;
173 
174 
177  typedef tmat2x2<int, lowp> lowp_imat2x2;
178 
181  typedef tmat2x3<int, lowp> lowp_imat2x3;
182 
185  typedef tmat2x4<int, lowp> lowp_imat2x4;
186 
189  typedef tmat3x2<int, lowp> lowp_imat3x2;
190 
193  typedef tmat3x3<int, lowp> lowp_imat3x3;
194 
197  typedef tmat3x4<int, lowp> lowp_imat3x4;
198 
201  typedef tmat4x2<int, lowp> lowp_imat4x2;
202 
205  typedef tmat4x3<int, lowp> lowp_imat4x3;
206 
209  typedef tmat4x4<int, lowp> lowp_imat4x4;
210 
211 
214  typedef tmat2x2<uint, highp> highp_umat2;
215 
218  typedef tmat3x3<uint, highp> highp_umat3;
219 
222  typedef tmat4x4<uint, highp> highp_umat4;
223 
226  typedef tmat2x2<uint, highp> highp_umat2x2;
227 
230  typedef tmat2x3<uint, highp> highp_umat2x3;
231 
234  typedef tmat2x4<uint, highp> highp_umat2x4;
235 
238  typedef tmat3x2<uint, highp> highp_umat3x2;
239 
242  typedef tmat3x3<uint, highp> highp_umat3x3;
243 
246  typedef tmat3x4<uint, highp> highp_umat3x4;
247 
250  typedef tmat4x2<uint, highp> highp_umat4x2;
251 
254  typedef tmat4x3<uint, highp> highp_umat4x3;
255 
258  typedef tmat4x4<uint, highp> highp_umat4x4;
259 
260 
263  typedef tmat2x2<uint, mediump> mediump_umat2;
264 
267  typedef tmat3x3<uint, mediump> mediump_umat3;
268 
271  typedef tmat4x4<uint, mediump> mediump_umat4;
272 
273 
276  typedef tmat2x2<uint, mediump> mediump_umat2x2;
277 
280  typedef tmat2x3<uint, mediump> mediump_umat2x3;
281 
284  typedef tmat2x4<uint, mediump> mediump_umat2x4;
285 
288  typedef tmat3x2<uint, mediump> mediump_umat3x2;
289 
292  typedef tmat3x3<uint, mediump> mediump_umat3x3;
293 
296  typedef tmat3x4<uint, mediump> mediump_umat3x4;
297 
300  typedef tmat4x2<uint, mediump> mediump_umat4x2;
301 
304  typedef tmat4x3<uint, mediump> mediump_umat4x3;
305 
308  typedef tmat4x4<uint, mediump> mediump_umat4x4;
309 
310 
313  typedef tmat2x2<uint, lowp> lowp_umat2;
314 
317  typedef tmat3x3<uint, lowp> lowp_umat3;
318 
321  typedef tmat4x4<uint, lowp> lowp_umat4;
322 
323 
326  typedef tmat2x2<uint, lowp> lowp_umat2x2;
327 
330  typedef tmat2x3<uint, lowp> lowp_umat2x3;
331 
334  typedef tmat2x4<uint, lowp> lowp_umat2x4;
335 
338  typedef tmat3x2<uint, lowp> lowp_umat3x2;
339 
342  typedef tmat3x3<uint, lowp> lowp_umat3x3;
343 
346  typedef tmat3x4<uint, lowp> lowp_umat3x4;
347 
350  typedef tmat4x2<uint, lowp> lowp_umat4x2;
351 
354  typedef tmat4x3<uint, lowp> lowp_umat4x3;
355 
358  typedef tmat4x4<uint, lowp> lowp_umat4x4;
359 
360 #if(defined(GLM_PRECISION_HIGHP_INT))
361  typedef highp_imat2 imat2;
362  typedef highp_imat3 imat3;
363  typedef highp_imat4 imat4;
364  typedef highp_imat2x2 imat2x2;
365  typedef highp_imat2x3 imat2x3;
366  typedef highp_imat2x4 imat2x4;
367  typedef highp_imat3x2 imat3x2;
368  typedef highp_imat3x3 imat3x3;
369  typedef highp_imat3x4 imat3x4;
370  typedef highp_imat4x2 imat4x2;
371  typedef highp_imat4x3 imat4x3;
372  typedef highp_imat4x4 imat4x4;
373 #elif(defined(GLM_PRECISION_LOWP_INT))
374  typedef lowp_imat2 imat2;
375  typedef lowp_imat3 imat3;
376  typedef lowp_imat4 imat4;
377  typedef lowp_imat2x2 imat2x2;
378  typedef lowp_imat2x3 imat2x3;
379  typedef lowp_imat2x4 imat2x4;
380  typedef lowp_imat3x2 imat3x2;
381  typedef lowp_imat3x3 imat3x3;
382  typedef lowp_imat3x4 imat3x4;
383  typedef lowp_imat4x2 imat4x2;
384  typedef lowp_imat4x3 imat4x3;
385  typedef lowp_imat4x4 imat4x4;
386 #else //if(defined(GLM_PRECISION_MEDIUMP_INT))
387 
390  typedef mediump_imat2 imat2;
391 
394  typedef mediump_imat3 imat3;
395 
398  typedef mediump_imat4 imat4;
399 
402  typedef mediump_imat2x2 imat2x2;
403 
406  typedef mediump_imat2x3 imat2x3;
407 
410  typedef mediump_imat2x4 imat2x4;
411 
414  typedef mediump_imat3x2 imat3x2;
415 
418  typedef mediump_imat3x3 imat3x3;
419 
422  typedef mediump_imat3x4 imat3x4;
423 
426  typedef mediump_imat4x2 imat4x2;
427 
430  typedef mediump_imat4x3 imat4x3;
431 
434  typedef mediump_imat4x4 imat4x4;
435 #endif//GLM_PRECISION
436 
437 #if(defined(GLM_PRECISION_HIGHP_UINT))
438  typedef highp_umat2 umat2;
439  typedef highp_umat3 umat3;
440  typedef highp_umat4 umat4;
441  typedef highp_umat2x2 umat2x2;
442  typedef highp_umat2x3 umat2x3;
443  typedef highp_umat2x4 umat2x4;
444  typedef highp_umat3x2 umat3x2;
445  typedef highp_umat3x3 umat3x3;
446  typedef highp_umat3x4 umat3x4;
447  typedef highp_umat4x2 umat4x2;
448  typedef highp_umat4x3 umat4x3;
449  typedef highp_umat4x4 umat4x4;
450 #elif(defined(GLM_PRECISION_LOWP_UINT))
451  typedef lowp_umat2 umat2;
452  typedef lowp_umat3 umat3;
453  typedef lowp_umat4 umat4;
454  typedef lowp_umat2x2 umat2x2;
455  typedef lowp_umat2x3 umat2x3;
456  typedef lowp_umat2x4 umat2x4;
457  typedef lowp_umat3x2 umat3x2;
458  typedef lowp_umat3x3 umat3x3;
459  typedef lowp_umat3x4 umat3x4;
460  typedef lowp_umat4x2 umat4x2;
461  typedef lowp_umat4x3 umat4x3;
462  typedef lowp_umat4x4 umat4x4;
463 #else //if(defined(GLM_PRECISION_MEDIUMP_UINT))
464 
467  typedef mediump_umat2 umat2;
468 
471  typedef mediump_umat3 umat3;
472 
475  typedef mediump_umat4 umat4;
476 
479  typedef mediump_umat2x2 umat2x2;
480 
483  typedef mediump_umat2x3 umat2x3;
484 
487  typedef mediump_umat2x4 umat2x4;
488 
491  typedef mediump_umat3x2 umat3x2;
492 
495  typedef mediump_umat3x3 umat3x3;
496 
499  typedef mediump_umat3x4 umat3x4;
500 
503  typedef mediump_umat4x2 umat4x2;
504 
507  typedef mediump_umat4x3 umat4x3;
508 
511  typedef mediump_umat4x4 umat4x4;
512 #endif//GLM_PRECISION
513 
515 }//namespace glm
glm::imat4
mediump_imat4 imat4
Signed integer 4x4 matrix.
Definition: matrix_integer.hpp:398
glm::lowp_umat2
tmat2x2< uint, lowp > lowp_umat2
Low-precision unsigned integer 2x2 matrix.
Definition: matrix_integer.hpp:313
glm::mediump_imat4x2
tmat4x2< int, mediump > mediump_imat4x2
Medium-precision signed integer 4x2 matrix.
Definition: matrix_integer.hpp:151
glm::mediump_umat2x3
tmat2x3< uint, mediump > mediump_umat2x3
Medium-precision unsigned integer 2x3 matrix.
Definition: matrix_integer.hpp:280
glm::mediump_umat3x4
tmat3x4< uint, mediump > mediump_umat3x4
Medium-precision unsigned integer 3x4 matrix.
Definition: matrix_integer.hpp:296
glm::highp_umat2x2
tmat2x2< uint, highp > highp_umat2x2
High-precision unsigned integer 2x2 matrix.
Definition: matrix_integer.hpp:226
glm::umat2x3
mediump_umat2x3 umat2x3
Unsigned integer 2x3 matrix.
Definition: matrix_integer.hpp:483
glm::mediump_umat2x2
tmat2x2< uint, mediump > mediump_umat2x2
Medium-precision unsigned integer 2x2 matrix.
Definition: matrix_integer.hpp:276
glm::umat2
mediump_umat2 umat2
Unsigned integer 2x2 matrix.
Definition: matrix_integer.hpp:467
glm::lowp_umat4x3
tmat4x3< uint, lowp > lowp_umat4x3
Low-precision unsigned integer 4x3 matrix.
Definition: matrix_integer.hpp:354
glm::lowp_umat2x3
tmat2x3< uint, lowp > lowp_umat2x3
Low-precision unsigned integer 2x3 matrix.
Definition: matrix_integer.hpp:330
glm::highp_umat4x3
tmat4x3< uint, highp > highp_umat4x3
High-precision unsigned integer 4x3 matrix.
Definition: matrix_integer.hpp:254
glm::lowp_umat2x4
tmat2x4< uint, lowp > lowp_umat2x4
Low-precision unsigned integer 2x4 matrix.
Definition: matrix_integer.hpp:334
glm::highp_umat4x4
tmat4x4< uint, highp > highp_umat4x4
High-precision unsigned integer 4x4 matrix.
Definition: matrix_integer.hpp:258
glm::lowp_umat3x2
tmat3x2< uint, lowp > lowp_umat3x2
Low-precision unsigned integer 3x2 matrix.
Definition: matrix_integer.hpp:338
glm::lowp_imat3x3
tmat3x3< int, lowp > lowp_imat3x3
Low-precision signed integer 3x3 matrix.
Definition: matrix_integer.hpp:193
glm::mediump_umat4
tmat4x4< uint, mediump > mediump_umat4
Medium-precision unsigned integer 4x4 matrix.
Definition: matrix_integer.hpp:271
glm::mediump_imat3x4
tmat3x4< int, mediump > mediump_imat3x4
Medium-precision signed integer 3x4 matrix.
Definition: matrix_integer.hpp:147
glm::highp_umat2x3
tmat2x3< uint, highp > highp_umat2x3
High-precision unsigned integer 2x3 matrix.
Definition: matrix_integer.hpp:230
glm::umat2x4
mediump_umat2x4 umat2x4
Unsigned integer 2x4 matrix.
Definition: matrix_integer.hpp:487
glm::imat2x3
mediump_imat2x3 imat2x3
Signed integer 2x3 matrix.
Definition: matrix_integer.hpp:406
glm::lowp_umat3x3
tmat3x3< uint, lowp > lowp_umat3x3
Low-precision unsigned integer 3x3 matrix.
Definition: matrix_integer.hpp:342
glm::mediump_umat4x4
tmat4x4< uint, mediump > mediump_umat4x4
Medium-precision unsigned integer 4x4 matrix.
Definition: matrix_integer.hpp:308
glm::highp_imat4x3
tmat4x3< int, highp > highp_imat4x3
High-precision signed integer 4x3 matrix.
Definition: matrix_integer.hpp:105
glm::highp_umat3x3
tmat3x3< uint, highp > highp_umat3x3
High-precision unsigned integer 3x3 matrix.
Definition: matrix_integer.hpp:242
glm::highp_imat3x2
tmat3x2< int, highp > highp_imat3x2
High-precision signed integer 3x2 matrix.
Definition: matrix_integer.hpp:89
glm::lowp_umat4
tmat4x4< uint, lowp > lowp_umat4
Low-precision unsigned integer 4x4 matrix.
Definition: matrix_integer.hpp:321
glm::lowp_imat3
tmat3x3< int, lowp > lowp_imat3
Low-precision signed integer 3x3 matrix.
Definition: matrix_integer.hpp:168
glm::imat4x2
mediump_imat4x2 imat4x2
Signed integer 4x2 matrix.
Definition: matrix_integer.hpp:426
glm::highp_umat4
tmat4x4< uint, highp > highp_umat4
High-precision unsigned integer 4x4 matrix.
Definition: matrix_integer.hpp:222
glm::umat4x3
mediump_umat4x3 umat4x3
Unsigned integer 4x3 matrix.
Definition: matrix_integer.hpp:507
glm::lowp_imat2x3
tmat2x3< int, lowp > lowp_imat2x3
Low-precision signed integer 2x3 matrix.
Definition: matrix_integer.hpp:181
glm::lowp_umat4x2
tmat4x2< uint, lowp > lowp_umat4x2
Low-precision unsigned integer 4x2 matrix.
Definition: matrix_integer.hpp:350
glm::mediump_imat2x3
tmat2x3< int, mediump > mediump_imat2x3
Medium-precision signed integer 2x3 matrix.
Definition: matrix_integer.hpp:131
glm::highp_imat4
tmat4x4< int, highp > highp_imat4
High-precision signed integer 4x4 matrix.
Definition: matrix_integer.hpp:73
glm::umat4x2
mediump_umat4x2 umat4x2
Unsigned integer 4x2 matrix.
Definition: matrix_integer.hpp:503
glm::imat3
mediump_imat3 imat3
Signed integer 3x3 matrix.
Definition: matrix_integer.hpp:394
glm::umat3x3
mediump_umat3x3 umat3x3
Unsigned integer 3x3 matrix.
Definition: matrix_integer.hpp:495
glm::lowp_umat4x4
tmat4x4< uint, lowp > lowp_umat4x4
Low-precision unsigned integer 4x4 matrix.
Definition: matrix_integer.hpp:358
glm::mediump_imat4x3
tmat4x3< int, mediump > mediump_imat4x3
Medium-precision signed integer 4x3 matrix.
Definition: matrix_integer.hpp:155
glm::umat2x2
mediump_umat2x2 umat2x2
Unsigned integer 2x2 matrix.
Definition: matrix_integer.hpp:479
glm::lowp_imat4
tmat4x4< int, lowp > lowp_imat4
Low-precision signed integer 4x4 matrix.
Definition: matrix_integer.hpp:172
glm::lowp_imat2x2
tmat2x2< int, lowp > lowp_imat2x2
Low-precision signed integer 2x2 matrix.
Definition: matrix_integer.hpp:177
glm::mediump_umat4x2
tmat4x2< uint, mediump > mediump_umat4x2
Medium-precision unsigned integer 4x2 matrix.
Definition: matrix_integer.hpp:300
glm::lowp_imat4x3
tmat4x3< int, lowp > lowp_imat4x3
Low-precision signed integer 4x3 matrix.
Definition: matrix_integer.hpp:205
glm::highp_imat2x2
tmat2x2< int, highp > highp_imat2x2
High-precision signed integer 2x2 matrix.
Definition: matrix_integer.hpp:77
glm::highp_umat2
tmat2x2< uint, highp > highp_umat2
High-precision unsigned integer 2x2 matrix.
Definition: matrix_integer.hpp:214
glm::imat4x3
mediump_imat4x3 imat4x3
Signed integer 4x3 matrix.
Definition: matrix_integer.hpp:430
glm::mediump_imat3x2
tmat3x2< int, mediump > mediump_imat3x2
Medium-precision signed integer 3x2 matrix.
Definition: matrix_integer.hpp:139
glm::mediump_umat4x3
tmat4x3< uint, mediump > mediump_umat4x3
Medium-precision unsigned integer 4x3 matrix.
Definition: matrix_integer.hpp:304
glm::umat3x2
mediump_umat3x2 umat3x2
Unsigned integer 3x2 matrix.
Definition: matrix_integer.hpp:491
glm
Definition: _noise.hpp:40
glm::umat3
mediump_umat3 umat3
Unsigned integer 3x3 matrix.
Definition: matrix_integer.hpp:471
glm::highp_imat2x4
tmat2x4< int, highp > highp_imat2x4
High-precision signed integer 2x4 matrix.
Definition: matrix_integer.hpp:85
glm::lowp_imat2x4
tmat2x4< int, lowp > lowp_imat2x4
Low-precision signed integer 2x4 matrix.
Definition: matrix_integer.hpp:185
glm::highp_imat4x2
tmat4x2< int, highp > highp_imat4x2
High-precision signed integer 4x2 matrix.
Definition: matrix_integer.hpp:101
glm::imat3x4
mediump_imat3x4 imat3x4
Signed integer 3x4 matrix.
Definition: matrix_integer.hpp:422
glm::mediump_umat2
tmat2x2< uint, mediump > mediump_umat2
Medium-precision unsigned integer 2x2 matrix.
Definition: matrix_integer.hpp:263
glm::mediump_umat2x4
tmat2x4< uint, mediump > mediump_umat2x4
Medium-precision unsigned integer 2x4 matrix.
Definition: matrix_integer.hpp:284
glm::lowp_imat3x2
tmat3x2< int, lowp > lowp_imat3x2
Low-precision signed integer 3x2 matrix.
Definition: matrix_integer.hpp:189
glm::imat2x4
mediump_imat2x4 imat2x4
Signed integer 2x4 matrix.
Definition: matrix_integer.hpp:410
glm::lowp_imat4x2
tmat4x2< int, lowp > lowp_imat4x2
Low-precision signed integer 4x2 matrix.
Definition: matrix_integer.hpp:201
glm::highp_imat2x3
tmat2x3< int, highp > highp_imat2x3
High-precision signed integer 2x3 matrix.
Definition: matrix_integer.hpp:81
glm::umat4
mediump_umat4 umat4
Unsigned integer 4x4 matrix.
Definition: matrix_integer.hpp:475
glm::mediump_imat3
tmat3x3< int, mediump > mediump_imat3
Medium-precision signed integer 3x3 matrix.
Definition: matrix_integer.hpp:118
glm::mediump_imat2x4
tmat2x4< int, mediump > mediump_imat2x4
Medium-precision signed integer 2x4 matrix.
Definition: matrix_integer.hpp:135
glm::umat3x4
mediump_umat3x4 umat3x4
Unsigned integer 3x4 matrix.
Definition: matrix_integer.hpp:499
glm::lowp_imat2
tmat2x2< int, lowp > lowp_imat2
Low-precision signed integer 2x2 matrix.
Definition: matrix_integer.hpp:164
glm::highp_imat3x3
tmat3x3< int, highp > highp_imat3x3
High-precision signed integer 3x3 matrix.
Definition: matrix_integer.hpp:93
glm::highp_umat3x4
tmat3x4< uint, highp > highp_umat3x4
High-precision unsigned integer 3x4 matrix.
Definition: matrix_integer.hpp:246
glm::imat4x4
mediump_imat4x4 imat4x4
Signed integer 4x4 matrix.
Definition: matrix_integer.hpp:434
glm::imat2x2
mediump_imat2x2 imat2x2
Signed integer 2x2 matrix.
Definition: matrix_integer.hpp:402
glm::mediump_imat2x2
tmat2x2< int, mediump > mediump_imat2x2
Medium-precision signed integer 2x2 matrix.
Definition: matrix_integer.hpp:127
glm::mediump_imat2
tmat2x2< int, mediump > mediump_imat2
Medium-precision signed integer 2x2 matrix.
Definition: matrix_integer.hpp:114
glm::mediump_umat3
tmat3x3< uint, mediump > mediump_umat3
Medium-precision unsigned integer 3x3 matrix.
Definition: matrix_integer.hpp:267
glm::lowp_imat4x4
tmat4x4< int, lowp > lowp_imat4x4
Low-precision signed integer 4x4 matrix.
Definition: matrix_integer.hpp:209
glm::highp_imat4x4
tmat4x4< int, highp > highp_imat4x4
High-precision signed integer 4x4 matrix.
Definition: matrix_integer.hpp:109
glm::mediump_imat3x3
tmat3x3< int, mediump > mediump_imat3x3
Medium-precision signed integer 3x3 matrix.
Definition: matrix_integer.hpp:143
glm::highp_imat3x4
tmat3x4< int, highp > highp_imat3x4
High-precision signed integer 3x4 matrix.
Definition: matrix_integer.hpp:97
glm::lowp_umat3
tmat3x3< uint, lowp > lowp_umat3
Low-precision unsigned integer 3x3 matrix.
Definition: matrix_integer.hpp:317
glm::highp_umat3x2
tmat3x2< uint, highp > highp_umat3x2
High-precision unsigned integer 3x2 matrix.
Definition: matrix_integer.hpp:238
glm::mediump_imat4x4
tmat4x4< int, mediump > mediump_imat4x4
Medium-precision signed integer 4x4 matrix.
Definition: matrix_integer.hpp:159
glm::mediump_umat3x2
tmat3x2< uint, mediump > mediump_umat3x2
Medium-precision unsigned integer 3x2 matrix.
Definition: matrix_integer.hpp:288
glm::highp_umat4x2
tmat4x2< uint, highp > highp_umat4x2
High-precision unsigned integer 4x2 matrix.
Definition: matrix_integer.hpp:250
glm::highp_imat3
tmat3x3< int, highp > highp_imat3
High-precision signed integer 3x3 matrix.
Definition: matrix_integer.hpp:69
glm::lowp_umat3x4
tmat3x4< uint, lowp > lowp_umat3x4
Low-precision unsigned integer 3x4 matrix.
Definition: matrix_integer.hpp:346
glm::mediump_umat3x3
tmat3x3< uint, mediump > mediump_umat3x3
Medium-precision unsigned integer 3x3 matrix.
Definition: matrix_integer.hpp:292
glm::highp_umat2x4
tmat2x4< uint, highp > highp_umat2x4
High-precision unsigned integer 2x4 matrix.
Definition: matrix_integer.hpp:234
glm::imat3x3
mediump_imat3x3 imat3x3
Signed integer 3x3 matrix.
Definition: matrix_integer.hpp:418
glm::umat4x4
mediump_umat4x4 umat4x4
Unsigned integer 4x4 matrix.
Definition: matrix_integer.hpp:511
glm::mediump_imat4
tmat4x4< int, mediump > mediump_imat4
Medium-precision signed integer 4x4 matrix.
Definition: matrix_integer.hpp:122
glm::imat2
mediump_imat2 imat2
Signed integer 2x2 matrix.
Definition: matrix_integer.hpp:390
glm::imat3x2
mediump_imat3x2 imat3x2
Signed integer 3x2 matrix.
Definition: matrix_integer.hpp:414
glm::lowp_imat3x4
tmat3x4< int, lowp > lowp_imat3x4
Low-precision signed integer 3x4 matrix.
Definition: matrix_integer.hpp:197
glm::highp_imat2
tmat2x2< int, highp > highp_imat2
High-precision signed integer 2x2 matrix.
Definition: matrix_integer.hpp:65
glm::lowp_umat2x2
tmat2x2< uint, lowp > lowp_umat2x2
Low-precision unsigned integer 2x2 matrix.
Definition: matrix_integer.hpp:326
glm::highp_umat3
tmat3x3< uint, highp > highp_umat3
High-precision unsigned integer 3x3 matrix.
Definition: matrix_integer.hpp:218
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00072.html000066400000000000000000000166671356361734700216630ustar00rootroot00000000000000 0.9.7: matrix_interpolation.hpp File Reference
Functions
matrix_interpolation.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P>
GLM_FUNC_DECL void axisAngle (tmat4x4< T, P > const &mat, tvec3< T, P > &axis, T &angle)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > axisAngleMatrix (tvec3< T, P > const &axis, T const angle)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > extractMatrixRotation (tmat4x4< T, P > const &mat)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > interpolate (tmat4x4< T, P > const &m1, tmat4x4< T, P > const &m2, T const delta)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_matrix_interpolation

Date
2011-03-05 / 2011-06-07
Author
Ghenadii Ursachi (the.a.nosp@m.ster.nosp@m.oth@g.nosp@m.mail.nosp@m..com)
See also
GLM Core (dependence)

Definition in file matrix_interpolation.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00072_source.html000066400000000000000000000247161356361734700232350ustar00rootroot00000000000000 0.9.7: matrix_interpolation.hpp Source File
matrix_interpolation.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../glm.hpp"
46 
47 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
48 # pragma message("GLM: GLM_GTX_matrix_interpolation extension included")
49 #endif
50 
51 namespace glm
52 {
55 
58  template <typename T, precision P>
59  GLM_FUNC_DECL void axisAngle(
60  tmat4x4<T, P> const & mat,
61  tvec3<T, P> & axis,
62  T & angle);
63 
66  template <typename T, precision P>
67  GLM_FUNC_DECL tmat4x4<T, P> axisAngleMatrix(
68  tvec3<T, P> const & axis,
69  T const angle);
70 
73  template <typename T, precision P>
74  GLM_FUNC_DECL tmat4x4<T, P> extractMatrixRotation(
75  tmat4x4<T, P> const & mat);
76 
80  template <typename T, precision P>
81  GLM_FUNC_DECL tmat4x4<T, P> interpolate(
82  tmat4x4<T, P> const & m1,
83  tmat4x4<T, P> const & m2,
84  T const delta);
85 
87 }//namespace glm
88 
89 #include "matrix_interpolation.inl"
glm::extractMatrixRotation
GLM_FUNC_DECL tmat4x4< T, P > extractMatrixRotation(tmat4x4< T, P > const &mat)
Extracts the rotation part of a matrix.
glm::interpolate
GLM_FUNC_DECL tmat4x4< T, P > interpolate(tmat4x4< T, P > const &m1, tmat4x4< T, P > const &m2, T const delta)
Build a interpolation of 4 * 4 matrixes.
glm::axis
GLM_FUNC_DECL tvec3< T, P > axis(tquat< T, P > const &x)
Returns the q rotation axis.
glm
Definition: _noise.hpp:40
glm::axisAngle
GLM_FUNC_DECL void axisAngle(tmat4x4< T, P > const &mat, tvec3< T, P > &axis, T &angle)
Get the axis and angle of the rotation from a matrix.
glm::angle
GLM_FUNC_DECL T angle(tquat< T, P > const &x)
Returns the quaternion rotation angle.
glm::axisAngleMatrix
GLM_FUNC_DECL tmat4x4< T, P > axisAngleMatrix(tvec3< T, P > const &axis, T const angle)
Build a matrix from axis and angle.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00073.html000066400000000000000000000134241356361734700216500ustar00rootroot00000000000000 0.9.7: matrix_inverse.hpp File Reference
Functions
matrix_inverse.hpp File Reference

Go to the source code of this file.

Functions

template<typename genType >
GLM_FUNC_DECL genType affineInverse (genType const &m)
 
template<typename genType >
GLM_FUNC_DECL genType inverseTranspose (genType const &m)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTC_matrix_inverse

Date
2005-12-21 / 2011-06-05
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file matrix_inverse.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00073_source.html000066400000000000000000000160161356361734700232300ustar00rootroot00000000000000 0.9.7: matrix_inverse.hpp Source File
matrix_inverse.hpp
Go to the documentation of this file.
1 
41 #pragma once
42 
43 // Dependencies
44 #include "../detail/setup.hpp"
45 #include "../matrix.hpp"
46 #include "../mat2x2.hpp"
47 #include "../mat3x3.hpp"
48 #include "../mat4x4.hpp"
49 
50 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
51 # pragma message("GLM: GLM_GTC_matrix_inverse extension included")
52 #endif
53 
54 namespace glm
55 {
58 
64  template <typename genType>
65  GLM_FUNC_DECL genType affineInverse(genType const & m);
66 
72  template <typename genType>
73  GLM_FUNC_DECL genType inverseTranspose(genType const & m);
74 
76 }//namespace glm
77 
78 #include "matrix_inverse.inl"
glm::inverseTranspose
GLM_FUNC_DECL genType inverseTranspose(genType const &m)
Compute the inverse transpose of a matrix.
glm
Definition: _noise.hpp:40
glm::affineInverse
GLM_FUNC_DECL genType affineInverse(genType const &m)
Fast matrix inverse for affine matrix.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00074.html000066400000000000000000000302231356361734700216450ustar00rootroot00000000000000 0.9.7: matrix_major_storage.hpp File Reference
Functions
matrix_major_storage.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P>
GLM_FUNC_DECL tmat2x2< T, P > colMajor2 (tvec2< T, P > const &v1, tvec2< T, P > const &v2)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat2x2< T, P > colMajor2 (tmat2x2< T, P > const &m)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > colMajor3 (tvec3< T, P > const &v1, tvec3< T, P > const &v2, tvec3< T, P > const &v3)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > colMajor3 (tmat3x3< T, P > const &m)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > colMajor4 (tvec4< T, P > const &v1, tvec4< T, P > const &v2, tvec4< T, P > const &v3, tvec4< T, P > const &v4)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > colMajor4 (tmat4x4< T, P > const &m)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat2x2< T, P > rowMajor2 (tvec2< T, P > const &v1, tvec2< T, P > const &v2)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat2x2< T, P > rowMajor2 (tmat2x2< T, P > const &m)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > rowMajor3 (tvec3< T, P > const &v1, tvec3< T, P > const &v2, tvec3< T, P > const &v3)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > rowMajor3 (tmat3x3< T, P > const &m)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > rowMajor4 (tvec4< T, P > const &v1, tvec4< T, P > const &v2, tvec4< T, P > const &v3, tvec4< T, P > const &v4)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > rowMajor4 (tmat4x4< T, P > const &m)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_matrix_major_storage

Date
2006-04-19 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTX_extented_min_max (dependence)

Definition in file matrix_major_storage.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00074_source.html000066400000000000000000000407531356361734700232360ustar00rootroot00000000000000 0.9.7: matrix_major_storage.hpp Source File
matrix_major_storage.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependency:
46 #include "../glm.hpp"
47 
48 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
49 # pragma message("GLM: GLM_GTX_matrix_major_storage extension included")
50 #endif
51 
52 namespace glm
53 {
56 
59  template <typename T, precision P>
60  GLM_FUNC_DECL tmat2x2<T, P> rowMajor2(
61  tvec2<T, P> const & v1,
62  tvec2<T, P> const & v2);
63 
66  template <typename T, precision P>
67  GLM_FUNC_DECL tmat2x2<T, P> rowMajor2(
68  tmat2x2<T, P> const & m);
69 
72  template <typename T, precision P>
73  GLM_FUNC_DECL tmat3x3<T, P> rowMajor3(
74  tvec3<T, P> const & v1,
75  tvec3<T, P> const & v2,
76  tvec3<T, P> const & v3);
77 
80  template <typename T, precision P>
81  GLM_FUNC_DECL tmat3x3<T, P> rowMajor3(
82  tmat3x3<T, P> const & m);
83 
86  template <typename T, precision P>
87  GLM_FUNC_DECL tmat4x4<T, P> rowMajor4(
88  tvec4<T, P> const & v1,
89  tvec4<T, P> const & v2,
90  tvec4<T, P> const & v3,
91  tvec4<T, P> const & v4);
92 
95  template <typename T, precision P>
96  GLM_FUNC_DECL tmat4x4<T, P> rowMajor4(
97  tmat4x4<T, P> const & m);
98 
101  template <typename T, precision P>
102  GLM_FUNC_DECL tmat2x2<T, P> colMajor2(
103  tvec2<T, P> const & v1,
104  tvec2<T, P> const & v2);
105 
108  template <typename T, precision P>
109  GLM_FUNC_DECL tmat2x2<T, P> colMajor2(
110  tmat2x2<T, P> const & m);
111 
114  template <typename T, precision P>
115  GLM_FUNC_DECL tmat3x3<T, P> colMajor3(
116  tvec3<T, P> const & v1,
117  tvec3<T, P> const & v2,
118  tvec3<T, P> const & v3);
119 
122  template <typename T, precision P>
123  GLM_FUNC_DECL tmat3x3<T, P> colMajor3(
124  tmat3x3<T, P> const & m);
125 
128  template <typename T, precision P>
129  GLM_FUNC_DECL tmat4x4<T, P> colMajor4(
130  tvec4<T, P> const & v1,
131  tvec4<T, P> const & v2,
132  tvec4<T, P> const & v3,
133  tvec4<T, P> const & v4);
134 
137  template <typename T, precision P>
138  GLM_FUNC_DECL tmat4x4<T, P> colMajor4(
139  tmat4x4<T, P> const & m);
140 
142 }//namespace glm
143 
144 #include "matrix_major_storage.inl"
glm::colMajor2
GLM_FUNC_DECL tmat2x2< T, P > colMajor2(tmat2x2< T, P > const &m)
Build a column major matrix from other matrix.
glm::colMajor4
GLM_FUNC_DECL tmat4x4< T, P > colMajor4(tmat4x4< T, P > const &m)
Build a column major matrix from other matrix.
glm::rowMajor4
GLM_FUNC_DECL tmat4x4< T, P > rowMajor4(tmat4x4< T, P > const &m)
Build a row major matrix from other matrix.
glm::rowMajor2
GLM_FUNC_DECL tmat2x2< T, P > rowMajor2(tmat2x2< T, P > const &m)
Build a row major matrix from other matrix.
glm
Definition: _noise.hpp:40
glm::rowMajor3
GLM_FUNC_DECL tmat3x3< T, P > rowMajor3(tmat3x3< T, P > const &m)
Build a row major matrix from other matrix.
glm::colMajor3
GLM_FUNC_DECL tmat3x3< T, P > colMajor3(tmat3x3< T, P > const &m)
Build a column major matrix from other matrix.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00075.html000066400000000000000000000235621356361734700216560ustar00rootroot00000000000000 0.9.7: matrix_operation.hpp File Reference
Functions
matrix_operation.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P>
GLM_FUNC_DECL tmat2x2< T, P > diagonal2x2 (tvec2< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat2x3< T, P > diagonal2x3 (tvec2< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat2x4< T, P > diagonal2x4 (tvec2< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x2< T, P > diagonal3x2 (tvec2< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > diagonal3x3 (tvec3< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x4< T, P > diagonal3x4 (tvec3< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x2< T, P > diagonal4x2 (tvec2< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x3< T, P > diagonal4x3 (tvec3< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > diagonal4x4 (tvec4< T, P > const &v)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_matrix_operation

Date
2009-08-29 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file matrix_operation.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00075_source.html000066400000000000000000000326561356361734700232420ustar00rootroot00000000000000 0.9.7: matrix_operation.hpp Source File
matrix_operation.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../glm.hpp"
46 
47 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
48 # pragma message("GLM: GLM_GTX_matrix_operation extension included")
49 #endif
50 
51 namespace glm
52 {
55 
58  template <typename T, precision P>
59  GLM_FUNC_DECL tmat2x2<T, P> diagonal2x2(
60  tvec2<T, P> const & v);
61 
64  template <typename T, precision P>
65  GLM_FUNC_DECL tmat2x3<T, P> diagonal2x3(
66  tvec2<T, P> const & v);
67 
70  template <typename T, precision P>
71  GLM_FUNC_DECL tmat2x4<T, P> diagonal2x4(
72  tvec2<T, P> const & v);
73 
76  template <typename T, precision P>
77  GLM_FUNC_DECL tmat3x2<T, P> diagonal3x2(
78  tvec2<T, P> const & v);
79 
82  template <typename T, precision P>
83  GLM_FUNC_DECL tmat3x3<T, P> diagonal3x3(
84  tvec3<T, P> const & v);
85 
88  template <typename T, precision P>
89  GLM_FUNC_DECL tmat3x4<T, P> diagonal3x4(
90  tvec3<T, P> const & v);
91 
94  template <typename T, precision P>
95  GLM_FUNC_DECL tmat4x2<T, P> diagonal4x2(
96  tvec2<T, P> const & v);
97 
100  template <typename T, precision P>
101  GLM_FUNC_DECL tmat4x3<T, P> diagonal4x3(
102  tvec3<T, P> const & v);
103 
106  template <typename T, precision P>
107  GLM_FUNC_DECL tmat4x4<T, P> diagonal4x4(
108  tvec4<T, P> const & v);
109 
111 }//namespace glm
112 
113 #include "matrix_operation.inl"
glm::diagonal3x4
GLM_FUNC_DECL tmat3x4< T, P > diagonal3x4(tvec3< T, P > const &v)
Build a diagonal matrix.
glm::diagonal3x2
GLM_FUNC_DECL tmat3x2< T, P > diagonal3x2(tvec2< T, P > const &v)
Build a diagonal matrix.
glm::diagonal4x2
GLM_FUNC_DECL tmat4x2< T, P > diagonal4x2(tvec2< T, P > const &v)
Build a diagonal matrix.
glm::diagonal2x4
GLM_FUNC_DECL tmat2x4< T, P > diagonal2x4(tvec2< T, P > const &v)
Build a diagonal matrix.
glm
Definition: _noise.hpp:40
glm::diagonal4x3
GLM_FUNC_DECL tmat4x3< T, P > diagonal4x3(tvec3< T, P > const &v)
Build a diagonal matrix.
glm::diagonal4x4
GLM_FUNC_DECL tmat4x4< T, P > diagonal4x4(tvec4< T, P > const &v)
Build a diagonal matrix.
glm::diagonal2x2
GLM_FUNC_DECL tmat2x2< T, P > diagonal2x2(tvec2< T, P > const &v)
Build a diagonal matrix.
glm::diagonal3x3
GLM_FUNC_DECL tmat3x3< T, P > diagonal3x3(tvec3< T, P > const &v)
Build a diagonal matrix.
glm::diagonal2x3
GLM_FUNC_DECL tmat2x3< T, P > diagonal2x3(tvec2< T, P > const &v)
Build a diagonal matrix.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00076.html000066400000000000000000000230521356361734700216510ustar00rootroot00000000000000 0.9.7: matrix_query.hpp File Reference
Functions
matrix_query.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P, template< typename, precision > class matType>
GLM_FUNC_DECL bool isIdentity (matType< T, P > const &m, T const &epsilon)
 
template<typename T , precision P>
GLM_FUNC_DECL bool isNormalized (tmat2x2< T, P > const &m, T const &epsilon)
 
template<typename T , precision P>
GLM_FUNC_DECL bool isNormalized (tmat3x3< T, P > const &m, T const &epsilon)
 
template<typename T , precision P>
GLM_FUNC_DECL bool isNormalized (tmat4x4< T, P > const &m, T const &epsilon)
 
template<typename T , precision P>
GLM_FUNC_DECL bool isNull (tmat2x2< T, P > const &m, T const &epsilon)
 
template<typename T , precision P>
GLM_FUNC_DECL bool isNull (tmat3x3< T, P > const &m, T const &epsilon)
 
template<typename T , precision P>
GLM_FUNC_DECL bool isNull (tmat4x4< T, P > const &m, T const &epsilon)
 
template<typename T , precision P, template< typename, precision > class matType>
GLM_FUNC_DECL bool isOrthogonal (matType< T, P > const &m, T const &epsilon)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_matrix_query

Date
2007-03-05 / 2011-08-28
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTX_vector_query (dependence)

Definition in file matrix_query.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00076_source.html000066400000000000000000000307731356361734700232410ustar00rootroot00000000000000 0.9.7: matrix_query.hpp Source File
matrix_query.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependency:
46 #include "../glm.hpp"
47 #include "../gtx/vector_query.hpp"
48 #include <limits>
49 
50 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
51 # pragma message("GLM: GLM_GTX_matrix_query extension included")
52 #endif
53 
54 namespace glm
55 {
58 
61  template<typename T, precision P>
62  GLM_FUNC_DECL bool isNull(tmat2x2<T, P> const & m, T const & epsilon);
63 
66  template<typename T, precision P>
67  GLM_FUNC_DECL bool isNull(tmat3x3<T, P> const & m, T const & epsilon);
68 
71  template<typename T, precision P>
72  GLM_FUNC_DECL bool isNull(tmat4x4<T, P> const & m, T const & epsilon);
73 
76  template<typename T, precision P, template <typename, precision> class matType>
77  GLM_FUNC_DECL bool isIdentity(matType<T, P> const & m, T const & epsilon);
78 
81  template<typename T, precision P>
82  GLM_FUNC_DECL bool isNormalized(tmat2x2<T, P> const & m, T const & epsilon);
83 
86  template<typename T, precision P>
87  GLM_FUNC_DECL bool isNormalized(tmat3x3<T, P> const & m, T const & epsilon);
88 
91  template<typename T, precision P>
92  GLM_FUNC_DECL bool isNormalized(tmat4x4<T, P> const & m, T const & epsilon);
93 
96  template<typename T, precision P, template <typename, precision> class matType>
97  GLM_FUNC_DECL bool isOrthogonal(matType<T, P> const & m, T const & epsilon);
98 
100 }//namespace glm
101 
102 #include "matrix_query.inl"
glm::isNull
GLM_FUNC_DECL bool isNull(tmat4x4< T, P > const &m, T const &epsilon)
Return whether a matrix is a null matrix.
glm::epsilon
GLM_FUNC_DECL genType epsilon()
Return the epsilon constant for floating point types.
glm
Definition: _noise.hpp:40
glm::isIdentity
GLM_FUNC_DECL bool isIdentity(matType< T, P > const &m, T const &epsilon)
Return whether a matrix is an identity matrix.
glm::isNormalized
GLM_FUNC_DECL bool isNormalized(tmat4x4< T, P > const &m, T const &epsilon)
Return whether a matrix is a normalized matrix.
glm::isOrthogonal
GLM_FUNC_DECL bool isOrthogonal(matType< T, P > const &m, T const &epsilon)
Return whether a matrix is an orthonormalized matrix.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00077.html000066400000000000000000000432141356361734700216540ustar00rootroot00000000000000 0.9.7: matrix_transform.hpp File Reference
Functions
matrix_transform.hpp File Reference

Go to the source code of this file.

Functions

template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > frustum (T left, T right, T bottom, T top, T near, T far)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > infinitePerspective (T fovy, T aspect, T near)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > lookAt (tvec3< T, P > const &eye, tvec3< T, P > const &center, tvec3< T, P > const &up)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > lookAtLH (tvec3< T, P > const &eye, tvec3< T, P > const &center, tvec3< T, P > const &up)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > lookAtRH (tvec3< T, P > const &eye, tvec3< T, P > const &center, tvec3< T, P > const &up)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > ortho (T left, T right, T bottom, T top, T zNear, T zFar)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > ortho (T left, T right, T bottom, T top)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > perspective (T fovy, T aspect, T near, T far)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > perspectiveFov (T fov, T width, T height, T near, T far)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > perspectiveFovLH (T fov, T width, T height, T near, T far)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > perspectiveFovRH (T fov, T width, T height, T near, T far)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > perspectiveLH (T fovy, T aspect, T near, T far)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > perspectiveRH (T fovy, T aspect, T near, T far)
 
template<typename T , precision P, typename U >
GLM_FUNC_DECL tmat4x4< T, P > pickMatrix (tvec2< T, P > const &center, tvec2< T, P > const &delta, tvec4< U, P > const &viewport)
 
template<typename T , typename U , precision P>
GLM_FUNC_DECL tvec3< T, P > project (tvec3< T, P > const &obj, tmat4x4< T, P > const &model, tmat4x4< T, P > const &proj, tvec4< U, P > const &viewport)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > rotate (tmat4x4< T, P > const &m, T angle, tvec3< T, P > const &axis)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > scale (tmat4x4< T, P > const &m, tvec3< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > translate (tmat4x4< T, P > const &m, tvec3< T, P > const &v)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > tweakedInfinitePerspective (T fovy, T aspect, T near)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > tweakedInfinitePerspective (T fovy, T aspect, T near, T ep)
 
template<typename T , typename U , precision P>
GLM_FUNC_DECL tvec3< T, P > unProject (tvec3< T, P > const &win, tmat4x4< T, P > const &model, tmat4x4< T, P > const &proj, tvec4< U, P > const &viewport)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTC_matrix_transform

Date
2009-04-29 / 2011-05-16
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTX_transform
GLM_GTX_transform2

Definition in file matrix_transform.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00077_source.html000066400000000000000000001034511356361734700232340ustar00rootroot00000000000000 0.9.7: matrix_transform.hpp Source File
matrix_transform.hpp
Go to the documentation of this file.
1 
50 #pragma once
51 
52 // Dependencies
53 #include "../mat4x4.hpp"
54 #include "../vec2.hpp"
55 #include "../vec3.hpp"
56 #include "../vec4.hpp"
57 #include "../gtc/constants.hpp"
58 
59 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
60 # pragma message("GLM: GLM_GTC_matrix_transform extension included")
61 #endif
62 
63 namespace glm
64 {
67 
86  template <typename T, precision P>
87  GLM_FUNC_DECL tmat4x4<T, P> translate(
88  tmat4x4<T, P> const & m,
89  tvec3<T, P> const & v);
90 
100  template <typename T, precision P>
101  GLM_FUNC_DECL tmat4x4<T, P> rotate(
102  tmat4x4<T, P> const & m,
103  T angle,
104  tvec3<T, P> const & axis);
105 
114  template <typename T, precision P>
115  GLM_FUNC_DECL tmat4x4<T, P> scale(
116  tmat4x4<T, P> const & m,
117  tvec3<T, P> const & v);
118 
130  template <typename T>
131  GLM_FUNC_DECL tmat4x4<T, defaultp> ortho(
132  T left,
133  T right,
134  T bottom,
135  T top,
136  T zNear,
137  T zFar);
138 
148  template <typename T>
149  GLM_FUNC_DECL tmat4x4<T, defaultp> ortho(
150  T left,
151  T right,
152  T bottom,
153  T top);
154 
165  template <typename T>
166  GLM_FUNC_DECL tmat4x4<T, defaultp> frustum(
167  T left,
168  T right,
169  T bottom,
170  T top,
171  T near,
172  T far);
173 
182  template <typename T>
183  GLM_FUNC_DECL tmat4x4<T, defaultp> perspective(
184  T fovy,
185  T aspect,
186  T near,
187  T far);
188 
189 
198  template <typename T>
199  GLM_FUNC_DECL tmat4x4<T, defaultp> perspectiveRH(
200  T fovy,
201  T aspect,
202  T near,
203  T far);
204 
213  template <typename T>
214  GLM_FUNC_DECL tmat4x4<T, defaultp> perspectiveLH(
215  T fovy,
216  T aspect,
217  T near,
218  T far);
219 
229  template <typename T>
230  GLM_FUNC_DECL tmat4x4<T, defaultp> perspectiveFov(
231  T fov,
232  T width,
233  T height,
234  T near,
235  T far);
236 
246  template <typename T>
247  GLM_FUNC_DECL tmat4x4<T, defaultp> perspectiveFovRH(
248  T fov,
249  T width,
250  T height,
251  T near,
252  T far);
253 
263  template <typename T>
264  GLM_FUNC_DECL tmat4x4<T, defaultp> perspectiveFovLH(
265  T fov,
266  T width,
267  T height,
268  T near,
269  T far);
270 
278  template <typename T>
279  GLM_FUNC_DECL tmat4x4<T, defaultp> infinitePerspective(
280  T fovy, T aspect, T near);
281 
289  template <typename T>
290  GLM_FUNC_DECL tmat4x4<T, defaultp> tweakedInfinitePerspective(
291  T fovy, T aspect, T near);
292 
301  template <typename T>
302  GLM_FUNC_DECL tmat4x4<T, defaultp> tweakedInfinitePerspective(
303  T fovy, T aspect, T near, T ep);
304 
315  template <typename T, typename U, precision P>
316  GLM_FUNC_DECL tvec3<T, P> project(
317  tvec3<T, P> const & obj,
318  tmat4x4<T, P> const & model,
319  tmat4x4<T, P> const & proj,
320  tvec4<U, P> const & viewport);
321 
332  template <typename T, typename U, precision P>
333  GLM_FUNC_DECL tvec3<T, P> unProject(
334  tvec3<T, P> const & win,
335  tmat4x4<T, P> const & model,
336  tmat4x4<T, P> const & proj,
337  tvec4<U, P> const & viewport);
338 
347  template <typename T, precision P, typename U>
348  GLM_FUNC_DECL tmat4x4<T, P> pickMatrix(
349  tvec2<T, P> const & center,
350  tvec2<T, P> const & delta,
351  tvec4<U, P> const & viewport);
352 
360  template <typename T, precision P>
361  GLM_FUNC_DECL tmat4x4<T, P> lookAt(
362  tvec3<T, P> const & eye,
363  tvec3<T, P> const & center,
364  tvec3<T, P> const & up);
365 
373  template <typename T, precision P>
374  GLM_FUNC_DECL tmat4x4<T, P> lookAtRH(
375  tvec3<T, P> const & eye,
376  tvec3<T, P> const & center,
377  tvec3<T, P> const & up);
378 
386  template <typename T, precision P>
387  GLM_FUNC_DECL tmat4x4<T, P> lookAtLH(
388  tvec3<T, P> const & eye,
389  tvec3<T, P> const & center,
390  tvec3<T, P> const & up);
391 
393 }//namespace glm
394 
395 #include "matrix_transform.inl"
glm::proj
GLM_FUNC_DECL vecType proj(vecType const &x, vecType const &Normal)
Projects x on Normal.
glm::translate
GLM_FUNC_DECL tmat4x4< T, P > translate(tmat4x4< T, P > const &m, tvec3< T, P > const &v)
Builds a translation 4 * 4 matrix created from a vector of 3 components.
glm::perspectiveFov
GLM_FUNC_DECL tmat4x4< T, defaultp > perspectiveFov(T fov, T width, T height, T near, T far)
Builds a perspective projection matrix based on a field of view and the default handedness.
glm::tweakedInfinitePerspective
GLM_FUNC_DECL tmat4x4< T, defaultp > tweakedInfinitePerspective(T fovy, T aspect, T near, T ep)
Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics har...
glm::perspective
GLM_FUNC_DECL tmat4x4< T, defaultp > perspective(T fovy, T aspect, T near, T far)
Creates a matrix for a symetric perspective-view frustum based on the default handedness.
glm::perspectiveRH
GLM_FUNC_DECL tmat4x4< T, defaultp > perspectiveRH(T fovy, T aspect, T near, T far)
Creates a matrix for a right handed, symetric perspective-view frustum.
glm::unProject
GLM_FUNC_DECL tvec3< T, P > unProject(tvec3< T, P > const &win, tmat4x4< T, P > const &model, tmat4x4< T, P > const &proj, tvec4< U, P > const &viewport)
Map the specified window coordinates (win.x, win.y, win.z) into object coordinates.
glm::ortho
GLM_FUNC_DECL tmat4x4< T, defaultp > ortho(T left, T right, T bottom, T top)
Creates a matrix for projecting two-dimensional coordinates onto the screen.
glm::lookAt
GLM_FUNC_DECL tmat4x4< T, P > lookAt(tvec3< T, P > const &eye, tvec3< T, P > const &center, tvec3< T, P > const &up)
Build a look at view matrix based on the default handedness.
glm::pickMatrix
GLM_FUNC_DECL tmat4x4< T, P > pickMatrix(tvec2< T, P > const &center, tvec2< T, P > const &delta, tvec4< U, P > const &viewport)
Define a picking region.
glm::perspectiveLH
GLM_FUNC_DECL tmat4x4< T, defaultp > perspectiveLH(T fovy, T aspect, T near, T far)
Creates a matrix for a left handed, symetric perspective-view frustum.
glm::infinitePerspective
GLM_FUNC_DECL tmat4x4< T, defaultp > infinitePerspective(T fovy, T aspect, T near)
Creates a matrix for a symmetric perspective-view frustum with far plane at infinite.
glm::project
GLM_FUNC_DECL tvec3< T, P > project(tvec3< T, P > const &obj, tmat4x4< T, P > const &model, tmat4x4< T, P > const &proj, tvec4< U, P > const &viewport)
Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates.
glm::axis
GLM_FUNC_DECL tvec3< T, P > axis(tquat< T, P > const &x)
Returns the q rotation axis.
glm
Definition: _noise.hpp:40
glm::perspectiveFovRH
GLM_FUNC_DECL tmat4x4< T, defaultp > perspectiveFovRH(T fov, T width, T height, T near, T far)
Builds a right handed perspective projection matrix based on a field of view.
glm::angle
GLM_FUNC_DECL T angle(tquat< T, P > const &x)
Returns the quaternion rotation angle.
glm::frustum
GLM_FUNC_DECL tmat4x4< T, defaultp > frustum(T left, T right, T bottom, T top, T near, T far)
Creates a frustum matrix.
glm::lookAtLH
GLM_FUNC_DECL tmat4x4< T, P > lookAtLH(tvec3< T, P > const &eye, tvec3< T, P > const &center, tvec3< T, P > const &up)
Build a left handed look at view matrix.
glm::rotate
GLM_FUNC_DECL tmat4x4< T, P > rotate(tmat4x4< T, P > const &m, T angle, tvec3< T, P > const &axis)
Builds a rotation 4 * 4 matrix created from an axis vector and an angle.
glm::perspectiveFovLH
GLM_FUNC_DECL tmat4x4< T, defaultp > perspectiveFovLH(T fov, T width, T height, T near, T far)
Builds a left handed perspective projection matrix based on a field of view.
glm::lookAtRH
GLM_FUNC_DECL tmat4x4< T, P > lookAtRH(tvec3< T, P > const &eye, tvec3< T, P > const &center, tvec3< T, P > const &up)
Build a right handed look at view matrix.
glm::scale
GLM_FUNC_DECL tmat4x4< T, P > scale(tmat4x4< T, P > const &m, tvec3< T, P > const &v)
Builds a scale 4 * 4 matrix created from 3 scalars.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00078.html000066400000000000000000000172551356361734700216630ustar00rootroot00000000000000 0.9.7: matrix_transform_2d.hpp File Reference
Functions
matrix_transform_2d.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P>
GLM_FUNC_QUALIFIER tmat3x3< T, P > rotate (tmat3x3< T, P > const &m, T angle)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tmat3x3< T, P > scale (tmat3x3< T, P > const &m, tvec2< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tmat3x3< T, P > shearX (tmat3x3< T, P > const &m, T y)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tmat3x3< T, P > shearY (tmat3x3< T, P > const &m, T x)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tmat3x3< T, P > translate (tmat3x3< T, P > const &m, tvec2< T, P > const &v)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_matrix_transform_2d

Date
2014-02-20
Author
Miguel Ángel Pérez Martínez
See also
GLM Core (dependence)

Definition in file matrix_transform_2d.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00078_source.html000066400000000000000000000261561356361734700232430ustar00rootroot00000000000000 0.9.7: matrix_transform_2d.hpp Source File
matrix_transform_2d.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../mat3x3.hpp"
46 #include "../vec2.hpp"
47 
48 
49 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
50 # pragma message("GLM: GLM_GTX_matrix_transform_2d extension included")
51 #endif
52 
53 namespace glm
54 {
57 
62  template <typename T, precision P>
63  GLM_FUNC_QUALIFIER tmat3x3<T, P> translate(
64  tmat3x3<T, P> const & m,
65  tvec2<T, P> const & v);
66 
71  template <typename T, precision P>
72  GLM_FUNC_QUALIFIER tmat3x3<T, P> rotate(
73  tmat3x3<T, P> const & m,
74  T angle);
75 
80  template <typename T, precision P>
81  GLM_FUNC_QUALIFIER tmat3x3<T, P> scale(
82  tmat3x3<T, P> const & m,
83  tvec2<T, P> const & v);
84 
89  template <typename T, precision P>
90  GLM_FUNC_QUALIFIER tmat3x3<T, P> shearX(
91  tmat3x3<T, P> const & m,
92  T y);
93 
98  template <typename T, precision P>
99  GLM_FUNC_QUALIFIER tmat3x3<T, P> shearY(
100  tmat3x3<T, P> const & m,
101  T x);
102 
104 }//namespace glm
105 
106 #include "matrix_transform_2d.inl"
glm::scale
GLM_FUNC_QUALIFIER tmat3x3< T, P > scale(tmat3x3< T, P > const &m, tvec2< T, P > const &v)
Builds a scale 3 * 3 matrix created from a vector of 2 components.
glm
Definition: _noise.hpp:40
glm::angle
GLM_FUNC_DECL T angle(tquat< T, P > const &x)
Returns the quaternion rotation angle.
glm::translate
GLM_FUNC_QUALIFIER tmat3x3< T, P > translate(tmat3x3< T, P > const &m, tvec2< T, P > const &v)
Builds a translation 3 * 3 matrix created from a vector of 2 components.
glm::rotate
GLM_FUNC_QUALIFIER tmat3x3< T, P > rotate(tmat3x3< T, P > const &m, T angle)
Builds a rotation 3 * 3 matrix created from an angle.
glm::shearY
GLM_FUNC_QUALIFIER tmat3x3< T, P > shearY(tmat3x3< T, P > const &m, T x)
Builds a vertical (parallel to the y axis) shear 3 * 3 matrix.
glm::shearX
GLM_FUNC_QUALIFIER tmat3x3< T, P > shearX(tmat3x3< T, P > const &m, T y)
Builds an horizontal (parallel to the x axis) shear 3 * 3 matrix.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00079.html000066400000000000000000000125621356361734700216600ustar00rootroot00000000000000 0.9.7: mixed_product.hpp File Reference
Functions
mixed_product.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P>
GLM_FUNC_DECL T mixedProduct (tvec3< T, P > const &v1, tvec3< T, P > const &v2, tvec3< T, P > const &v3)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_mixed_producte

Date
2007-04-03 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file mixed_product.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00079_source.html000066400000000000000000000141321356361734700232330ustar00rootroot00000000000000 0.9.7: mixed_product.hpp Source File
mixed_product.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../glm.hpp"
46 
47 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
48 # pragma message("GLM: GLM_GTX_mixed_product extension included")
49 #endif
50 
51 namespace glm
52 {
55 
57  template <typename T, precision P>
58  GLM_FUNC_DECL T mixedProduct(
59  tvec3<T, P> const & v1,
60  tvec3<T, P> const & v2,
61  tvec3<T, P> const & v3);
62 
64 }// namespace glm
65 
66 #include "mixed_product.inl"
glm::mixedProduct
GLM_FUNC_DECL T mixedProduct(tvec3< T, P > const &v1, tvec3< T, P > const &v2, tvec3< T, P > const &v3)
Mixed product of 3 vectors (from GLM_GTX_mixed_product extension)
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00080.html000066400000000000000000000147711356361734700216540ustar00rootroot00000000000000 0.9.7: noise.hpp File Reference
Functions
noise.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL T perlin (vecType< T, P > const &p)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL T perlin (vecType< T, P > const &p, vecType< T, P > const &rep)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL T simplex (vecType< T, P > const &p)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTC_noise

Date
2011-04-21 / 2011-09-27
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file noise.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00080_source.html000066400000000000000000000217571356361734700232360ustar00rootroot00000000000000 0.9.7: noise.hpp Source File
noise.hpp
Go to the documentation of this file.
1 
45 #pragma once
46 
47 // Dependencies
48 #include "../detail/setup.hpp"
49 #include "../detail/precision.hpp"
50 #include "../detail/_noise.hpp"
51 #include "../geometric.hpp"
52 #include "../common.hpp"
53 #include "../vector_relational.hpp"
54 #include "../vec2.hpp"
55 #include "../vec3.hpp"
56 #include "../vec4.hpp"
57 
58 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
59 # pragma message("GLM: GLM_GTC_noise extension included")
60 #endif
61 
62 namespace glm
63 {
66 
69  template <typename T, precision P, template<typename, precision> class vecType>
70  GLM_FUNC_DECL T perlin(
71  vecType<T, P> const & p);
72 
75  template <typename T, precision P, template<typename, precision> class vecType>
76  GLM_FUNC_DECL T perlin(
77  vecType<T, P> const & p,
78  vecType<T, P> const & rep);
79 
82  template <typename T, precision P, template<typename, precision> class vecType>
83  GLM_FUNC_DECL T simplex(
84  vecType<T, P> const & p);
85 
87 }//namespace glm
88 
89 #include "noise.inl"
glm::simplex
GLM_FUNC_DECL T simplex(vecType< T, P > const &p)
Simplex noise.
glm
Definition: _noise.hpp:40
glm::perlin
GLM_FUNC_DECL T perlin(vecType< T, P > const &p, vecType< T, P > const &rep)
Periodic perlin noise.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00081.html000066400000000000000000000246271356361734700216560ustar00rootroot00000000000000 0.9.7: norm.hpp File Reference
Functions
norm.hpp File Reference

Go to the source code of this file.

Functions

template<typename T >
GLM_FUNC_DECL T distance2 (T const &p0, T const &p1)
 
template<typename genType >
GLM_FUNC_DECL genType::value_type distance2 (genType const &p0, genType const &p1)
 
template<typename T , precision P>
GLM_FUNC_DECL T l1Norm (tvec3< T, P > const &x, tvec3< T, P > const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL T l1Norm (tvec3< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL T l2Norm (tvec3< T, P > const &x, tvec3< T, P > const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL T l2Norm (tvec3< T, P > const &x)
 
template<typename T >
GLM_FUNC_DECL T length2 (T const &x)
 
template<typename genType >
GLM_FUNC_DECL genType::value_type length2 (genType const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL T lxNorm (tvec3< T, P > const &x, tvec3< T, P > const &y, unsigned int Depth)
 
template<typename T , precision P>
GLM_FUNC_DECL T lxNorm (tvec3< T, P > const &x, unsigned int Depth)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_norm

Date
2005-12-21 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTX_quaternion (dependence)

Definition in file norm.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00081_source.html000066400000000000000000000335541356361734700232350ustar00rootroot00000000000000 0.9.7: norm.hpp Source File
norm.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependency:
46 #include "../glm.hpp"
47 #include "../gtx/quaternion.hpp"
48 
49 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
50 # pragma message("GLM: GLM_GTX_norm extension included")
51 #endif
52 
53 namespace glm
54 {
57 
60  template <typename T>
61  GLM_FUNC_DECL T length2(
62  T const & x);
63 
66  template <typename genType>
67  GLM_FUNC_DECL typename genType::value_type length2(
68  genType const & x);
69 
72  template <typename T>
73  GLM_FUNC_DECL T distance2(
74  T const & p0,
75  T const & p1);
76 
79  template <typename genType>
80  GLM_FUNC_DECL typename genType::value_type distance2(
81  genType const & p0,
82  genType const & p1);
83 
86  template <typename T, precision P>
87  GLM_FUNC_DECL T l1Norm(
88  tvec3<T, P> const & x,
89  tvec3<T, P> const & y);
90 
93  template <typename T, precision P>
94  GLM_FUNC_DECL T l1Norm(
95  tvec3<T, P> const & v);
96 
99  template <typename T, precision P>
100  GLM_FUNC_DECL T l2Norm(
101  tvec3<T, P> const & x,
102  tvec3<T, P> const & y);
103 
106  template <typename T, precision P>
107  GLM_FUNC_DECL T l2Norm(
108  tvec3<T, P> const & x);
109 
112  template <typename T, precision P>
113  GLM_FUNC_DECL T lxNorm(
114  tvec3<T, P> const & x,
115  tvec3<T, P> const & y,
116  unsigned int Depth);
117 
120  template <typename T, precision P>
121  GLM_FUNC_DECL T lxNorm(
122  tvec3<T, P> const & x,
123  unsigned int Depth);
124 
126 }//namespace glm
127 
128 #include "norm.inl"
glm::lxNorm
GLM_FUNC_DECL T lxNorm(tvec3< T, P > const &x, unsigned int Depth)
Returns the L norm of v.
glm::distance2
GLM_FUNC_DECL genType::value_type distance2(genType const &p0, genType const &p1)
Returns the squared distance between p0 and p1, i.e., length2(p0 - p1).
glm::l2Norm
GLM_FUNC_DECL T l2Norm(tvec3< T, P > const &x)
Returns the L2 norm of v.
glm
Definition: _noise.hpp:40
glm::l1Norm
GLM_FUNC_DECL T l1Norm(tvec3< T, P > const &v)
Returns the L1 norm of v.
glm::length2
GLM_FUNC_DECL genType::value_type length2(genType const &x)
Returns the squared length of x.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00082.html000066400000000000000000000126661356361734700216570ustar00rootroot00000000000000 0.9.7: normal.hpp File Reference
Functions
normal.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > triangleNormal (tvec3< T, P > const &p1, tvec3< T, P > const &p2, tvec3< T, P > const &p3)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_normal

Date
2005-12-21 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTX_extented_min_max (dependence)

Definition in file normal.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00082_source.html000066400000000000000000000141221356361734700232240ustar00rootroot00000000000000 0.9.7: normal.hpp Source File
normal.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependency:
46 #include "../glm.hpp"
47 
48 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
49 # pragma message("GLM: GLM_GTX_normal extension included")
50 #endif
51 
52 namespace glm
53 {
56 
59  template <typename T, precision P>
60  GLM_FUNC_DECL tvec3<T, P> triangleNormal(
61  tvec3<T, P> const & p1,
62  tvec3<T, P> const & p2,
63  tvec3<T, P> const & p3);
64 
66 }//namespace glm
67 
68 #include "normal.inl"
glm::triangleNormal
GLM_FUNC_DECL tvec3< T, P > triangleNormal(tvec3< T, P > const &p1, tvec3< T, P > const &p2, tvec3< T, P > const &p3)
Computes triangle normal from triangle points.
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00083.html000066400000000000000000000142051356361734700216470ustar00rootroot00000000000000 0.9.7: normalize_dot.hpp File Reference
Functions
normalize_dot.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL T fastNormalizeDot (vecType< T, P > const &x, vecType< T, P > const &y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL T normalizeDot (vecType< T, P > const &x, vecType< T, P > const &y)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_normalize_dot

Date
2007-09-28 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTX_fast_square_root (dependence)

Definition in file normalize_dot.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00083_source.html000066400000000000000000000157311356361734700232340ustar00rootroot00000000000000 0.9.7: normalize_dot.hpp Source File
normalize_dot.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependency:
46 #include "../gtx/fast_square_root.hpp"
47 
48 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
49 # pragma message("GLM: GLM_GTX_normalize_dot extension included")
50 #endif
51 
52 namespace glm
53 {
56 
61  template <typename T, precision P, template <typename, precision> class vecType>
62  GLM_FUNC_DECL T normalizeDot(vecType<T, P> const & x, vecType<T, P> const & y);
63 
68  template <typename T, precision P, template <typename, precision> class vecType>
69  GLM_FUNC_DECL T fastNormalizeDot(vecType<T, P> const & x, vecType<T, P> const & y);
70 
72 }//namespace glm
73 
74 #include "normalize_dot.inl"
glm::fastNormalizeDot
GLM_FUNC_DECL T fastNormalizeDot(vecType< T, P > const &x, vecType< T, P > const &y)
Normalize parameters and returns the dot product of x and y.
glm
Definition: _noise.hpp:40
glm::normalizeDot
GLM_FUNC_DECL T normalizeDot(vecType< T, P > const &x, vecType< T, P > const &y)
Normalize parameters and returns the dot product of x and y.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00084.html000066400000000000000000000223261356361734700216530ustar00rootroot00000000000000 0.9.7: number_precision.hpp File Reference
Typedefs
number_precision.hpp File Reference

Go to the source code of this file.

Typedefs

typedef f32 f32mat1
 
typedef f32 f32mat1x1
 
typedef f32 f32vec1
 
typedef f64 f64mat1
 
typedef f64 f64mat1x1
 
typedef f64 f64vec1
 
typedef u16 u16vec1
 
typedef u32 u32vec1
 
typedef u64 u64vec1
 
typedef u8 u8vec1
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_number_precision

Date
2007-05-10 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTC_type_precision (dependence)
GLM_GTC_quaternion (dependence)

Definition in file number_precision.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00084_source.html000066400000000000000000000404221356361734700232300ustar00rootroot00000000000000 0.9.7: number_precision.hpp Source File
number_precision.hpp
Go to the documentation of this file.
1 
44 #pragma once
45 
46 // Dependency:
47 #include "../glm.hpp"
48 #include "../gtc/type_precision.hpp"
49 
50 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
51 # pragma message("GLM: GLM_GTX_number_precision extension included")
52 #endif
53 
54 namespace glm{
55 namespace gtx
56 {
58  // Unsigned int vector types
59 
62 
63  typedef u8 u8vec1;
64  typedef u16 u16vec1;
65  typedef u32 u32vec1;
66  typedef u64 u64vec1;
67 
69  // Float vector types
70 
71  typedef f32 f32vec1;
72  typedef f64 f64vec1;
73 
75  // Float matrix types
76 
77  typedef f32 f32mat1;
78  typedef f32 f32mat1x1;
79  typedef f64 f64mat1;
80  typedef f64 f64mat1x1;
81 
83 }//namespace gtx
84 }//namespace glm
85 
86 #include "number_precision.inl"
glm::u32
detail::uint32 u32
32 bit unsigned integer type.
Definition: fwd.hpp:931
glm::gtx::f32mat1x1
f32 f32mat1x1
Single-precision floating-point scalar. (from GLM_GTX_number_precision extension) ...
Definition: number_precision.hpp:78
glm::u64
detail::uint64 u64
64 bit unsigned integer type.
Definition: fwd.hpp:935
glm::gtx::u8vec1
u8 u8vec1
8bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
Definition: number_precision.hpp:63
glm::gtx::f32mat1
f32 f32mat1
Single-precision floating-point scalar. (from GLM_GTX_number_precision extension) ...
Definition: number_precision.hpp:77
glm::gtx::f32vec1
f32 f32vec1
Single-precision floating-point scalar. (from GLM_GTX_number_precision extension) ...
Definition: number_precision.hpp:71
glm::u16
detail::uint16 u16
16 bit unsigned integer type.
Definition: fwd.hpp:927
glm::f64
highp_float64_t f64
Default 64 bit double-precision floating-point scalar.
Definition: fwd.hpp:1538
glm::gtx::f64vec1
f64 f64vec1
Single-precision floating-point scalar. (from GLM_GTX_number_precision extension) ...
Definition: number_precision.hpp:72
glm::gtx::f64mat1x1
f64 f64mat1x1
Double-precision floating-point scalar. (from GLM_GTX_number_precision extension) ...
Definition: number_precision.hpp:80
glm::f32
highp_float32_t f32
Default 32 bit single-precision floating-point scalar.
Definition: fwd.hpp:1534
glm::u8
detail::uint8 u8
8 bit unsigned integer type.
Definition: fwd.hpp:923
glm::gtx::u16vec1
u16 u16vec1
16bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
Definition: number_precision.hpp:64
glm
Definition: _noise.hpp:40
glm::gtx::f64mat1
f64 f64mat1
Double-precision floating-point scalar. (from GLM_GTX_number_precision extension) ...
Definition: number_precision.hpp:79
glm::gtx::u64vec1
u64 u64vec1
64bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
Definition: number_precision.hpp:66
glm::gtx::u32vec1
u32 u32vec1
32bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
Definition: number_precision.hpp:65
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00085.html000066400000000000000000000144301356361734700216510ustar00rootroot00000000000000 0.9.7: optimum_pow.hpp File Reference
Functions
optimum_pow.hpp File Reference

Go to the source code of this file.

Functions

template<typename genType >
GLM_FUNC_DECL genType pow2 (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL genType pow3 (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL genType pow4 (genType const &x)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_optimum_pow

Date
2005-12-21 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file optimum_pow.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00085_source.html000066400000000000000000000166211356361734700232350ustar00rootroot00000000000000 0.9.7: optimum_pow.hpp Source File
optimum_pow.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../glm.hpp"
46 
47 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
48 # pragma message("GLM: GLM_GTX_optimum_pow extension included")
49 #endif
50 
51 namespace glm{
52 namespace gtx
53 {
56 
60  template <typename genType>
61  GLM_FUNC_DECL genType pow2(genType const & x);
62 
66  template <typename genType>
67  GLM_FUNC_DECL genType pow3(genType const & x);
68 
72  template <typename genType>
73  GLM_FUNC_DECL genType pow4(genType const & x);
74 
76 }//namespace gtx
77 }//namespace glm
78 
79 #include "optimum_pow.inl"
glm::gtx::pow3
GLM_FUNC_DECL genType pow3(genType const &x)
Returns x raised to the power of 3.
glm
Definition: _noise.hpp:40
glm::gtx::pow4
GLM_FUNC_DECL genType pow4(genType const &x)
Returns x raised to the power of 4.
glm::gtx::pow2
GLM_FUNC_DECL genType pow2(genType const &x)
Returns x raised to the power of 2.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00086.html000066400000000000000000000140031356361734700216460ustar00rootroot00000000000000 0.9.7: orthonormalize.hpp File Reference
Functions
orthonormalize.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > orthonormalize (tmat3x3< T, P > const &m)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > orthonormalize (tvec3< T, P > const &x, tvec3< T, P > const &y)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_orthonormalize

Date
2005-12-21 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTX_extented_min_max (dependence)

Definition in file orthonormalize.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00086_source.html000066400000000000000000000151001356361734700232250ustar00rootroot00000000000000 0.9.7: orthonormalize.hpp Source File
orthonormalize.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependency:
46 #include "../vec3.hpp"
47 #include "../mat3x3.hpp"
48 #include "../geometric.hpp"
49 
50 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
51 # pragma message("GLM: GLM_GTX_orthonormalize extension included")
52 #endif
53 
54 namespace glm
55 {
58 
62  template <typename T, precision P>
63  GLM_FUNC_DECL tmat3x3<T, P> orthonormalize(tmat3x3<T, P> const & m);
64 
68  template <typename T, precision P>
69  GLM_FUNC_DECL tvec3<T, P> orthonormalize(tvec3<T, P> const & x, tvec3<T, P> const & y);
70 
72 }//namespace glm
73 
74 #include "orthonormalize.inl"
glm::orthonormalize
GLM_FUNC_DECL tvec3< T, P > orthonormalize(tvec3< T, P > const &x, tvec3< T, P > const &y)
Orthonormalizes x according y.
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00087.html000066400000000000000000000405511356361734700216560ustar00rootroot00000000000000 0.9.7: packing.hpp File Reference
Functions
gtc/packing.hpp File Reference

Go to the source code of this file.

Functions

GLM_FUNC_DECL uint32 packF2x11_1x10 (vec3 const &v)
 
GLM_FUNC_DECL uint16 packHalf1x16 (float v)
 
GLM_FUNC_DECL uint64 packHalf4x16 (vec4 const &v)
 
GLM_FUNC_DECL uint32 packI3x10_1x2 (ivec4 const &v)
 
GLM_FUNC_DECL uint16 packSnorm1x16 (float v)
 
GLM_FUNC_DECL uint8 packSnorm1x8 (float s)
 
GLM_FUNC_DECL uint16 packSnorm2x8 (vec2 const &v)
 
GLM_FUNC_DECL uint32 packSnorm3x10_1x2 (vec4 const &v)
 
GLM_FUNC_DECL uint64 packSnorm4x16 (vec4 const &v)
 
GLM_FUNC_DECL uint32 packU3x10_1x2 (uvec4 const &v)
 
GLM_FUNC_DECL uint16 packUnorm1x16 (float v)
 
GLM_FUNC_DECL uint8 packUnorm1x8 (float v)
 
GLM_FUNC_DECL uint16 packUnorm2x8 (vec2 const &v)
 
GLM_FUNC_DECL uint32 packUnorm3x10_1x2 (vec4 const &v)
 
GLM_FUNC_DECL uint64 packUnorm4x16 (vec4 const &v)
 
GLM_FUNC_DECL vec3 unpackF2x11_1x10 (uint32 p)
 
GLM_FUNC_DECL float unpackHalf1x16 (uint16 v)
 
GLM_FUNC_DECL vec4 unpackHalf4x16 (uint64 p)
 
GLM_FUNC_DECL ivec4 unpackI3x10_1x2 (uint32 p)
 
GLM_FUNC_DECL float unpackSnorm1x16 (uint16 p)
 
GLM_FUNC_DECL float unpackSnorm1x8 (uint8 p)
 
GLM_FUNC_DECL vec2 unpackSnorm2x8 (uint16 p)
 
GLM_FUNC_DECL vec4 unpackSnorm3x10_1x2 (uint32 p)
 
GLM_FUNC_DECL vec4 unpackSnorm4x16 (uint64 p)
 
GLM_FUNC_DECL uvec4 unpackU3x10_1x2 (uint32 p)
 
GLM_FUNC_DECL float unpackUnorm1x16 (uint16 p)
 
GLM_FUNC_DECL float unpackUnorm1x8 (uint8 p)
 
GLM_FUNC_DECL vec2 unpackUnorm2x8 (uint16 p)
 
GLM_FUNC_DECL vec4 unpackUnorm3x10_1x2 (uint32 p)
 
GLM_FUNC_DECL vec4 unpackUnorm4x16 (uint64 p)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTC_packing

Date
2013-08-08 / 2013-08-08
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file gtc/packing.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00087_source.html000066400000000000000000000712471356361734700232440ustar00rootroot00000000000000 0.9.7: packing.hpp Source File
gtc/packing.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependency:
46 #include "type_precision.hpp"
47 
48 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
49 # pragma message("GLM: GLM_GTC_packing extension included")
50 #endif
51 
52 namespace glm
53 {
56 
68  GLM_FUNC_DECL uint8 packUnorm1x8(float v);
69 
80  GLM_FUNC_DECL float unpackUnorm1x8(uint8 p);
81 
96  GLM_FUNC_DECL uint16 packUnorm2x8(vec2 const & v);
97 
112  GLM_FUNC_DECL vec2 unpackUnorm2x8(uint16 p);
113 
125  GLM_FUNC_DECL uint8 packSnorm1x8(float s);
126 
138  GLM_FUNC_DECL float unpackSnorm1x8(uint8 p);
139 
154  GLM_FUNC_DECL uint16 packSnorm2x8(vec2 const & v);
155 
170  GLM_FUNC_DECL vec2 unpackSnorm2x8(uint16 p);
171 
183  GLM_FUNC_DECL uint16 packUnorm1x16(float v);
184 
196  GLM_FUNC_DECL float unpackUnorm1x16(uint16 p);
197 
212  GLM_FUNC_DECL uint64 packUnorm4x16(vec4 const & v);
213 
228  GLM_FUNC_DECL vec4 unpackUnorm4x16(uint64 p);
229 
241  GLM_FUNC_DECL uint16 packSnorm1x16(float v);
242 
254  GLM_FUNC_DECL float unpackSnorm1x16(uint16 p);
255 
270  GLM_FUNC_DECL uint64 packSnorm4x16(vec4 const & v);
271 
286  GLM_FUNC_DECL vec4 unpackSnorm4x16(uint64 p);
287 
297  GLM_FUNC_DECL uint16 packHalf1x16(float v);
298 
308  GLM_FUNC_DECL float unpackHalf1x16(uint16 v);
309 
321  GLM_FUNC_DECL uint64 packHalf4x16(vec4 const & v);
322 
334  GLM_FUNC_DECL vec4 unpackHalf4x16(uint64 p);
335 
347  GLM_FUNC_DECL uint32 packI3x10_1x2(ivec4 const & v);
348 
358  GLM_FUNC_DECL ivec4 unpackI3x10_1x2(uint32 p);
359 
371  GLM_FUNC_DECL uint32 packU3x10_1x2(uvec4 const & v);
372 
382  GLM_FUNC_DECL uvec4 unpackU3x10_1x2(uint32 p);
383 
400  GLM_FUNC_DECL uint32 packSnorm3x10_1x2(vec4 const & v);
401 
417  GLM_FUNC_DECL vec4 unpackSnorm3x10_1x2(uint32 p);
418 
435  GLM_FUNC_DECL uint32 packUnorm3x10_1x2(vec4 const & v);
436 
452  GLM_FUNC_DECL vec4 unpackUnorm3x10_1x2(uint32 p);
453 
463  GLM_FUNC_DECL uint32 packF2x11_1x10(vec3 const & v);
464 
473  GLM_FUNC_DECL vec3 unpackF2x11_1x10(uint32 p);
474 
476 }// namespace glm
477 
478 #include "packing.inl"
glm::packUnorm1x16
GLM_FUNC_DECL uint16 packUnorm1x16(float v)
First, converts the normalized floating-point value v into a 16-bit integer value.
glm::unpackUnorm1x16
GLM_FUNC_DECL float unpackUnorm1x16(uint16 p)
First, unpacks a single 16-bit unsigned integer p into a of 16-bit unsigned integers.
glm::packUnorm4x16
GLM_FUNC_DECL uint64 packUnorm4x16(vec4 const &v)
First, converts each component of the normalized floating-point value v into 16-bit integer values...
glm::packSnorm1x16
GLM_FUNC_DECL uint16 packSnorm1x16(float v)
First, converts the normalized floating-point value v into 16-bit integer value.
glm::unpackHalf1x16
GLM_FUNC_DECL float unpackHalf1x16(uint16 v)
Returns a floating-point scalar with components obtained by unpacking a 16-bit unsigned integer into ...
glm::packUnorm3x10_1x2
GLM_FUNC_DECL uint32 packUnorm3x10_1x2(vec4 const &v)
First, converts the first three components of the normalized floating-point value v into 10-bit unsig...
glm::unpackF2x11_1x10
GLM_FUNC_DECL vec3 unpackF2x11_1x10(uint32 p)
First, unpacks a single 32-bit unsigned integer p into two 11-bit signless floating-point values and ...
glm::unpackI3x10_1x2
GLM_FUNC_DECL ivec4 unpackI3x10_1x2(uint32 p)
Unpacks a single 32-bit unsigned integer p into three 10-bit and one 2-bit signed integers...
type_precision.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::packSnorm4x16
GLM_FUNC_DECL uint64 packSnorm4x16(vec4 const &v)
First, converts each component of the normalized floating-point value v into 16-bit integer values...
glm::unpackUnorm2x8
GLM_FUNC_DECL vec2 unpackUnorm2x8(uint16 p)
First, unpacks a single 16-bit unsigned integer p into a pair of 8-bit unsigned integers.
glm::uvec4
highp_uvec4 uvec4
4 components vector of unsigned integer numbers.
Definition: type_vec.hpp:481
glm::packUnorm2x8
GLM_FUNC_DECL uint16 packUnorm2x8(vec2 const &v)
First, converts each component of the normalized floating-point value v into 8-bit integer values...
glm::unpackHalf4x16
GLM_FUNC_DECL vec4 unpackHalf4x16(uint64 p)
Returns a four-component floating-point vector with components obtained by unpacking a 64-bit unsigne...
glm::vec2
highp_vec2 vec2
2 components vector of floating-point numbers.
Definition: type_vec.hpp:390
glm::packSnorm3x10_1x2
GLM_FUNC_DECL uint32 packSnorm3x10_1x2(vec4 const &v)
First, converts the first three components of the normalized floating-point value v into 10-bit signe...
glm::unpackUnorm4x16
GLM_FUNC_DECL vec4 unpackUnorm4x16(uint64 p)
First, unpacks a single 64-bit unsigned integer p into four 16-bit unsigned integers.
glm::packI3x10_1x2
GLM_FUNC_DECL uint32 packI3x10_1x2(ivec4 const &v)
Returns an unsigned integer obtained by converting the components of a four-component signed integer ...
glm::unpackUnorm1x8
GLM_FUNC_DECL float unpackUnorm1x8(uint8 p)
Convert a single 8-bit integer to a normalized floating-point value.
glm::unpackSnorm3x10_1x2
GLM_FUNC_DECL vec4 unpackSnorm3x10_1x2(uint32 p)
First, unpacks a single 32-bit unsigned integer p into four 16-bit signed integers.
glm
Definition: _noise.hpp:40
glm::packSnorm2x8
GLM_FUNC_DECL uint16 packSnorm2x8(vec2 const &v)
First, converts each component of the normalized floating-point value v into 8-bit integer values...
glm::ivec4
highp_ivec4 ivec4
4 components vector of signed integer numbers.
Definition: type_vec.hpp:454
glm::packSnorm1x8
GLM_FUNC_DECL uint8 packSnorm1x8(float s)
First, converts the normalized floating-point value v into 8-bit integer value.
glm::vec4
highp_vec4 vec4
4 components vector of floating-point numbers.
Definition: type_vec.hpp:400
glm::packU3x10_1x2
GLM_FUNC_DECL uint32 packU3x10_1x2(uvec4 const &v)
Returns an unsigned integer obtained by converting the components of a four-component unsigned intege...
glm::packHalf4x16
GLM_FUNC_DECL uint64 packHalf4x16(vec4 const &v)
Returns an unsigned integer obtained by converting the components of a four-component floating-point ...
glm::vec3
highp_vec3 vec3
3 components vector of floating-point numbers.
Definition: type_vec.hpp:395
glm::unpackU3x10_1x2
GLM_FUNC_DECL uvec4 unpackU3x10_1x2(uint32 p)
Unpacks a single 32-bit unsigned integer p into three 10-bit and one 2-bit unsigned integers...
glm::packUnorm1x8
GLM_FUNC_DECL uint8 packUnorm1x8(float v)
First, converts the normalized floating-point value v into a 8-bit integer value. ...
glm::unpackSnorm4x16
GLM_FUNC_DECL vec4 unpackSnorm4x16(uint64 p)
First, unpacks a single 64-bit unsigned integer p into four 16-bit signed integers.
glm::unpackSnorm1x16
GLM_FUNC_DECL float unpackSnorm1x16(uint16 p)
First, unpacks a single 16-bit unsigned integer p into a single 16-bit signed integers.
glm::unpackUnorm3x10_1x2
GLM_FUNC_DECL vec4 unpackUnorm3x10_1x2(uint32 p)
First, unpacks a single 32-bit unsigned integer p into four 16-bit signed integers.
glm::unpackSnorm2x8
GLM_FUNC_DECL vec2 unpackSnorm2x8(uint16 p)
First, unpacks a single 16-bit unsigned integer p into a pair of 8-bit signed integers.
glm::unpackSnorm1x8
GLM_FUNC_DECL float unpackSnorm1x8(uint8 p)
First, unpacks a single 8-bit unsigned integer p into a single 8-bit signed integers.
glm::packHalf1x16
GLM_FUNC_DECL uint16 packHalf1x16(float v)
Returns an unsigned integer obtained by converting the components of a floating-point scalar to the 1...
glm::packF2x11_1x10
GLM_FUNC_DECL uint32 packF2x11_1x10(vec3 const &v)
First, converts the first two components of the normalized floating-point value v into 11-bit signles...
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00088.html000066400000000000000000000101711356361734700216520ustar00rootroot00000000000000 0.9.7: packing.hpp File Reference
packing.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-12-24 / 2013-12-24
Author
Christophe Riccio

Definition in file packing.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00088_source.html000066400000000000000000000062551356361734700232420ustar00rootroot00000000000000 0.9.7: packing.hpp Source File
packing.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "detail/func_packing.hpp"
func_packing.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00089_source.html000066400000000000000000000050401356361734700232320ustar00rootroot00000000000000 0.9.7: pages.doxy Source File
pages.doxy
1 
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00090.html000066400000000000000000000125571356361734700216550ustar00rootroot00000000000000 0.9.7: perpendicular.hpp File Reference
Functions
perpendicular.hpp File Reference

Go to the source code of this file.

Functions

template<typename vecType >
GLM_FUNC_DECL vecType perp (vecType const &x, vecType const &Normal)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_perpendicular

Date
2005-12-21 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTX_projection (dependence)

Definition in file perpendicular.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00090_source.html000066400000000000000000000137431356361734700232330ustar00rootroot00000000000000 0.9.7: perpendicular.hpp Source File
perpendicular.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependency:
46 #include "../glm.hpp"
47 #include "../gtx/projection.hpp"
48 
49 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
50 # pragma message("GLM: GLM_GTX_perpendicular extension included")
51 #endif
52 
53 namespace glm
54 {
57 
60  template <typename vecType>
61  GLM_FUNC_DECL vecType perp(
62  vecType const & x,
63  vecType const & Normal);
64 
66 }//namespace glm
67 
68 #include "perpendicular.inl"
glm::perp
GLM_FUNC_DECL vecType perp(vecType const &x, vecType const &Normal)
Projects x a perpendicular axis of Normal.
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00091.html000066400000000000000000000135331356361734700216510ustar00rootroot00000000000000 0.9.7: polar_coordinates.hpp File Reference
Functions
polar_coordinates.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > euclidean (tvec2< T, P > const &polar)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > polar (tvec3< T, P > const &euclidean)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_polar_coordinates

Date
2007-03-06 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file polar_coordinates.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00091_source.html000066400000000000000000000156241356361734700232340ustar00rootroot00000000000000 0.9.7: polar_coordinates.hpp Source File
polar_coordinates.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../glm.hpp"
46 
47 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
48 # pragma message("GLM: GLM_GTX_polar_coordinates extension included")
49 #endif
50 
51 namespace glm
52 {
55 
59  template <typename T, precision P>
60  GLM_FUNC_DECL tvec3<T, P> polar(
61  tvec3<T, P> const & euclidean);
62 
66  template <typename T, precision P>
67  GLM_FUNC_DECL tvec3<T, P> euclidean(
68  tvec2<T, P> const & polar);
69 
71 }//namespace glm
72 
73 #include "polar_coordinates.inl"
glm::euclidean
GLM_FUNC_DECL tvec3< T, P > euclidean(tvec2< T, P > const &polar)
Convert Polar to Euclidean coordinates.
glm
Definition: _noise.hpp:40
glm::polar
GLM_FUNC_DECL tvec3< T, P > polar(tvec3< T, P > const &euclidean)
Convert Euclidean to Polar coordinates, x is the xz distance, y, the latitude and z the longitude...
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00092.html000066400000000000000000000103411356361734700216440ustar00rootroot00000000000000 0.9.7: precision.hpp File Reference
precision.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-04-01 / 2013-04-01
Author
Christophe Riccio

Definition in file precision.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00092_source.html000066400000000000000000000103321356361734700232240ustar00rootroot00000000000000 0.9.7: precision.hpp Source File
precision.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 namespace glm
36 {
37  enum precision
38  {
39  highp,
40  mediump,
41  lowp,
42  defaultp = highp
43  };
44 }//namespace glm
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00093.html000066400000000000000000000123451356361734700216530ustar00rootroot00000000000000 0.9.7: projection.hpp File Reference
Functions
projection.hpp File Reference

Go to the source code of this file.

Functions

template<typename vecType >
GLM_FUNC_DECL vecType proj (vecType const &x, vecType const &Normal)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_projection

Date
2005-12-21 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file projection.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00093_source.html000066400000000000000000000131341356361734700232300ustar00rootroot00000000000000 0.9.7: projection.hpp Source File
projection.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../geometric.hpp"
46 
47 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
48 # pragma message("GLM: GLM_GTX_projection extension included")
49 #endif
50 
51 namespace glm
52 {
55 
59  template <typename vecType>
60  GLM_FUNC_DECL vecType proj(vecType const & x, vecType const & Normal);
61 
63 }//namespace glm
64 
65 #include "projection.inl"
glm::proj
GLM_FUNC_DECL vecType proj(vecType const &x, vecType const &Normal)
Projects x on Normal.
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00094.html000066400000000000000000000501021356361734700216450ustar00rootroot00000000000000 0.9.7: quaternion.hpp File Reference
Functions
gtc/quaternion.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P>
GLM_FUNC_DECL T angle (tquat< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > angleAxis (T const &angle, tvec3< T, P > const &axis)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > axis (tquat< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > conjugate (tquat< T, P > const &q)
 
template<typename T , precision P, template< typename, precision > class quatType>
GLM_FUNC_DECL T dot (quatType< T, P > const &x, quatType< T, P > const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< bool, P > equal (tquat< T, P > const &x, tquat< T, P > const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > eulerAngles (tquat< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< bool, P > greaterThan (tquat< T, P > const &x, tquat< T, P > const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< bool, P > greaterThanEqual (tquat< T, P > const &x, tquat< T, P > const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > inverse (tquat< T, P > const &q)
 
template<typename T , precision P>
GLM_FUNC_DECL T length (tquat< T, P > const &q)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > lerp (tquat< T, P > const &x, tquat< T, P > const &y, T a)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< bool, P > lessThan (tquat< T, P > const &x, tquat< T, P > const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< bool, P > lessThanEqual (tquat< T, P > const &x, tquat< T, P > const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > mat3_cast (tquat< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > mat4_cast (tquat< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > mix (tquat< T, P > const &x, tquat< T, P > const &y, T a)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > normalize (tquat< T, P > const &q)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< bool, P > notEqual (tquat< T, P > const &x, tquat< T, P > const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL T pitch (tquat< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > quat_cast (tmat3x3< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > quat_cast (tmat4x4< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL T roll (tquat< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > rotate (tquat< T, P > const &q, T const &angle, tvec3< T, P > const &axis)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > slerp (tquat< T, P > const &x, tquat< T, P > const &y, T a)
 
template<typename T , precision P>
GLM_FUNC_DECL T yaw (tquat< T, P > const &x)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTC_quaternion

Date
2009-05-21 / 2012-12-20
Author
Christophe Riccio
See also
GLM Core (dependence)
gtc_half_float (dependence)
GLM_GTC_constants (dependence)

Definition in file gtc/quaternion.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00094_source.html000066400000000000000000001345261356361734700232420ustar00rootroot00000000000000 0.9.7: quaternion.hpp Source File
gtc/quaternion.hpp
Go to the documentation of this file.
1 
44 #pragma once
45 
46 // Dependency:
47 #include "../mat3x3.hpp"
48 #include "../mat4x4.hpp"
49 #include "../vec3.hpp"
50 #include "../vec4.hpp"
51 #include "../gtc/constants.hpp"
52 
53 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
54 # pragma message("GLM: GLM_GTC_quaternion extension included")
55 #endif
56 
57 namespace glm
58 {
61 
62  template <typename T, precision P = defaultp>
63  struct tquat
64  {
65  // -- Implementation detail --
66 
67  typedef tquat<T, P> type;
68  typedef T value_type;
69 
70 # ifdef GLM_META_PROG_HELPERS
71  static GLM_RELAXED_CONSTEXPR length_t components = 4;
72  static GLM_RELAXED_CONSTEXPR precision prec = P;
73 # endif//GLM_META_PROG_HELPERS
74 
75  // -- Data --
76 
77  T x, y, z, w;
78 
79  // -- Component accesses --
80 
81 # ifdef GLM_FORCE_SIZE_FUNC
82  typedef size_t size_type;
84  GLM_FUNC_DECL GLM_CONSTEXPR size_type size() const;
85 
86  GLM_FUNC_DECL T & operator[](size_type i);
87  GLM_FUNC_DECL T const & operator[](size_type i) const;
88 # else
89  typedef length_t length_type;
91  GLM_FUNC_DECL GLM_CONSTEXPR length_type length() const;
92 
93  GLM_FUNC_DECL T & operator[](length_type i);
94  GLM_FUNC_DECL T const & operator[](length_type i) const;
95 # endif//GLM_FORCE_SIZE_FUNC
96 
97  // -- Implicit basic constructors --
98 
99  GLM_FUNC_DECL tquat() GLM_DEFAULT_CTOR;
100  GLM_FUNC_DECL tquat(tquat<T, P> const & q) GLM_DEFAULT;
101  template <precision Q>
102  GLM_FUNC_DECL tquat(tquat<T, Q> const & q);
103 
104  // -- Explicit basic constructors --
105 
106  GLM_FUNC_DECL explicit tquat(ctor);
107  GLM_FUNC_DECL explicit tquat(T const & s, tvec3<T, P> const & v);
108  GLM_FUNC_DECL tquat(T const & w, T const & x, T const & y, T const & z);
109 
110  // -- Conversion constructors --
111 
112  template <typename U, precision Q>
113  GLM_FUNC_DECL GLM_EXPLICIT tquat(tquat<U, Q> const & q);
114 
116 # if GLM_HAS_EXPLICIT_CONVERSION_OPERATORS
117  GLM_FUNC_DECL explicit operator tmat3x3<T, P>();
118  GLM_FUNC_DECL explicit operator tmat4x4<T, P>();
119 # endif
120 
127  GLM_FUNC_DECL explicit tquat(tvec3<T, P> const & u, tvec3<T, P> const & v);
128 
130  GLM_FUNC_DECL explicit tquat(tvec3<T, P> const & eulerAngles);
131  GLM_FUNC_DECL explicit tquat(tmat3x3<T, P> const & m);
132  GLM_FUNC_DECL explicit tquat(tmat4x4<T, P> const & m);
133 
134  // -- Unary arithmetic operators --
135 
136  GLM_FUNC_DECL tquat<T, P> & operator=(tquat<T, P> const & m) GLM_DEFAULT;
137 
138  template <typename U>
139  GLM_FUNC_DECL tquat<T, P> & operator=(tquat<U, P> const & m);
140  template <typename U>
141  GLM_FUNC_DECL tquat<T, P> & operator+=(tquat<U, P> const & q);
142  template <typename U>
143  GLM_FUNC_DECL tquat<T, P> & operator*=(tquat<U, P> const & q);
144  template <typename U>
145  GLM_FUNC_DECL tquat<T, P> & operator*=(U s);
146  template <typename U>
147  GLM_FUNC_DECL tquat<T, P> & operator/=(U s);
148  };
149 
150  // -- Unary bit operators --
151 
152  template <typename T, precision P>
153  GLM_FUNC_DECL tquat<T, P> operator-(tquat<T, P> const & q);
154 
155  // -- Binary operators --
156 
157  template <typename T, precision P>
158  GLM_FUNC_DECL tquat<T, P> operator+(tquat<T, P> const & q, tquat<T, P> const & p);
159 
160  template <typename T, precision P>
161  GLM_FUNC_DECL tquat<T, P> operator*(tquat<T, P> const & q, tquat<T, P> const & p);
162 
163  template <typename T, precision P>
164  GLM_FUNC_DECL tvec3<T, P> operator*(tquat<T, P> const & q, tvec3<T, P> const & v);
165 
166  template <typename T, precision P>
167  GLM_FUNC_DECL tvec3<T, P> operator*(tvec3<T, P> const & v, tquat<T, P> const & q);
168 
169  template <typename T, precision P>
170  GLM_FUNC_DECL tvec4<T, P> operator*(tquat<T, P> const & q, tvec4<T, P> const & v);
171 
172  template <typename T, precision P>
173  GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> const & v, tquat<T, P> const & q);
174 
175  template <typename T, precision P>
176  GLM_FUNC_DECL tquat<T, P> operator*(tquat<T, P> const & q, T const & s);
177 
178  template <typename T, precision P>
179  GLM_FUNC_DECL tquat<T, P> operator*(T const & s, tquat<T, P> const & q);
180 
181  template <typename T, precision P>
182  GLM_FUNC_DECL tquat<T, P> operator/(tquat<T, P> const & q, T const & s);
183 
187  template <typename T, precision P>
188  GLM_FUNC_DECL T length(tquat<T, P> const & q);
189 
193  template <typename T, precision P>
194  GLM_FUNC_DECL tquat<T, P> normalize(tquat<T, P> const & q);
195 
199  template <typename T, precision P, template <typename, precision> class quatType>
200  GLM_FUNC_DECL T dot(quatType<T, P> const & x, quatType<T, P> const & y);
201 
212  template <typename T, precision P>
213  GLM_FUNC_DECL tquat<T, P> mix(tquat<T, P> const & x, tquat<T, P> const & y, T a);
214 
223  template <typename T, precision P>
224  GLM_FUNC_DECL tquat<T, P> lerp(tquat<T, P> const & x, tquat<T, P> const & y, T a);
225 
234  template <typename T, precision P>
235  GLM_FUNC_DECL tquat<T, P> slerp(tquat<T, P> const & x, tquat<T, P> const & y, T a);
236 
240  template <typename T, precision P>
241  GLM_FUNC_DECL tquat<T, P> conjugate(tquat<T, P> const & q);
242 
246  template <typename T, precision P>
247  GLM_FUNC_DECL tquat<T, P> inverse(tquat<T, P> const & q);
248 
256  template <typename T, precision P>
257  GLM_FUNC_DECL tquat<T, P> rotate(tquat<T, P> const & q, T const & angle, tvec3<T, P> const & axis);
258 
263  template <typename T, precision P>
264  GLM_FUNC_DECL tvec3<T, P> eulerAngles(tquat<T, P> const & x);
265 
269  template <typename T, precision P>
270  GLM_FUNC_DECL T roll(tquat<T, P> const & x);
271 
275  template <typename T, precision P>
276  GLM_FUNC_DECL T pitch(tquat<T, P> const & x);
277 
281  template <typename T, precision P>
282  GLM_FUNC_DECL T yaw(tquat<T, P> const & x);
283 
287  template <typename T, precision P>
288  GLM_FUNC_DECL tmat3x3<T, P> mat3_cast(tquat<T, P> const & x);
289 
293  template <typename T, precision P>
294  GLM_FUNC_DECL tmat4x4<T, P> mat4_cast(tquat<T, P> const & x);
295 
299  template <typename T, precision P>
300  GLM_FUNC_DECL tquat<T, P> quat_cast(tmat3x3<T, P> const & x);
301 
305  template <typename T, precision P>
306  GLM_FUNC_DECL tquat<T, P> quat_cast(tmat4x4<T, P> const & x);
307 
311  template <typename T, precision P>
312  GLM_FUNC_DECL T angle(tquat<T, P> const & x);
313 
317  template <typename T, precision P>
318  GLM_FUNC_DECL tvec3<T, P> axis(tquat<T, P> const & x);
319 
326  template <typename T, precision P>
327  GLM_FUNC_DECL tquat<T, P> angleAxis(T const & angle, tvec3<T, P> const & axis);
328 
334  template <typename T, precision P>
335  GLM_FUNC_DECL tvec4<bool, P> lessThan(tquat<T, P> const & x, tquat<T, P> const & y);
336 
342  template <typename T, precision P>
343  GLM_FUNC_DECL tvec4<bool, P> lessThanEqual(tquat<T, P> const & x, tquat<T, P> const & y);
344 
350  template <typename T, precision P>
351  GLM_FUNC_DECL tvec4<bool, P> greaterThan(tquat<T, P> const & x, tquat<T, P> const & y);
352 
358  template <typename T, precision P>
359  GLM_FUNC_DECL tvec4<bool, P> greaterThanEqual(tquat<T, P> const & x, tquat<T, P> const & y);
360 
366  template <typename T, precision P>
367  GLM_FUNC_DECL tvec4<bool, P> equal(tquat<T, P> const & x, tquat<T, P> const & y);
368 
374  template <typename T, precision P>
375  GLM_FUNC_DECL tvec4<bool, P> notEqual(tquat<T, P> const & x, tquat<T, P> const & y);
377 } //namespace glm
378 
379 #include "quaternion.inl"
glm::rotate
GLM_FUNC_DECL tquat< T, P > rotate(tquat< T, P > const &q, T const &angle, tvec3< T, P > const &axis)
Rotates a quaternion from a vector of 3 components axis and an angle.
glm::pitch
GLM_FUNC_DECL T pitch(tquat< T, P > const &x)
Returns pitch value of euler angles expressed in radians.
glm::greaterThanEqual
GLM_FUNC_DECL tvec4< bool, P > greaterThanEqual(tquat< T, P > const &x, tquat< T, P > const &y)
Returns the component-wise comparison of result x >= y.
glm::conjugate
GLM_FUNC_DECL tquat< T, P > conjugate(tquat< T, P > const &q)
Returns the q conjugate.
glm::equal
GLM_FUNC_DECL tvec4< bool, P > equal(tquat< T, P > const &x, tquat< T, P > const &y)
Returns the component-wise comparison of result x == y.
glm::mat4_cast
GLM_FUNC_DECL tmat4x4< T, P > mat4_cast(tquat< T, P > const &x)
Converts a quaternion to a 4 * 4 matrix.
glm::quat_cast
GLM_FUNC_DECL tquat< T, P > quat_cast(tmat4x4< T, P > const &x)
Converts a 4 * 4 matrix to a quaternion.
glm::lerp
GLM_FUNC_DECL tquat< T, P > lerp(tquat< T, P > const &x, tquat< T, P > const &y, T a)
Linear interpolation of two quaternions.
glm::axis
GLM_FUNC_DECL tvec3< T, P > axis(tquat< T, P > const &x)
Returns the q rotation axis.
glm
Definition: _noise.hpp:40
glm::lessThanEqual
GLM_FUNC_DECL tvec4< bool, P > lessThanEqual(tquat< T, P > const &x, tquat< T, P > const &y)
Returns the component-wise comparison of result x <= y.
glm::length
GLM_FUNC_DECL T length(tquat< T, P > const &q)
Returns the length of the quaternion.
glm::notEqual
GLM_FUNC_DECL tvec4< bool, P > notEqual(tquat< T, P > const &x, tquat< T, P > const &y)
Returns the component-wise comparison of result x != y.
glm::greaterThan
GLM_FUNC_DECL tvec4< bool, P > greaterThan(tquat< T, P > const &x, tquat< T, P > const &y)
Returns the component-wise comparison of result x > y.
glm::eulerAngles
GLM_FUNC_DECL tvec3< T, P > eulerAngles(tquat< T, P > const &x)
Returns euler angles, yitch as x, yaw as y, roll as z.
glm::angle
GLM_FUNC_DECL T angle(tquat< T, P > const &x)
Returns the quaternion rotation angle.
glm::normalize
GLM_FUNC_DECL tquat< T, P > normalize(tquat< T, P > const &q)
Returns the normalized quaternion.
glm::dot
GLM_FUNC_DECL T dot(quatType< T, P > const &x, quatType< T, P > const &y)
Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ...
glm::yaw
GLM_FUNC_DECL T yaw(tquat< T, P > const &x)
Returns yaw value of euler angles expressed in radians.
glm::slerp
GLM_FUNC_DECL tquat< T, P > slerp(tquat< T, P > const &x, tquat< T, P > const &y, T a)
Spherical linear interpolation of two quaternions.
glm::mat3_cast
GLM_FUNC_DECL tmat3x3< T, P > mat3_cast(tquat< T, P > const &x)
Converts a quaternion to a 3 * 3 matrix.
glm::mix
GLM_FUNC_DECL tquat< T, P > mix(tquat< T, P > const &x, tquat< T, P > const &y, T a)
Spherical linear interpolation of two quaternions.
glm::inverse
GLM_FUNC_DECL tquat< T, P > inverse(tquat< T, P > const &q)
Returns the q inverse.
glm::roll
GLM_FUNC_DECL T roll(tquat< T, P > const &x)
Returns roll value of euler angles expressed in radians.
glm::angleAxis
GLM_FUNC_DECL tquat< T, P > angleAxis(T const &angle, tvec3< T, P > const &axis)
Build a quaternion from an angle and a normalized axis.
glm::lessThan
GLM_FUNC_DECL tvec4< bool, P > lessThan(tquat< T, P > const &x, tquat< T, P > const &y)
Returns the component-wise comparison result of x < y.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00095.html000066400000000000000000000370021356361734700216520ustar00rootroot00000000000000 0.9.7: quaternion.hpp File Reference
Functions
gtx/quaternion.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > cross (tquat< T, P > const &q, tvec3< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > cross (tvec3< T, P > const &v, tquat< T, P > const &q)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > exp (tquat< T, P > const &q)
 
template<typename T , precision P>
GLM_FUNC_DECL T extractRealComponent (tquat< T, P > const &q)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > fastMix (tquat< T, P > const &x, tquat< T, P > const &y, T const &a)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > intermediate (tquat< T, P > const &prev, tquat< T, P > const &curr, tquat< T, P > const &next)
 
template<typename T , precision P>
GLM_FUNC_DECL T length2 (tquat< T, P > const &q)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > log (tquat< T, P > const &q)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > pow (tquat< T, P > const &x, T const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > rotate (tquat< T, P > const &q, tvec3< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< T, P > rotate (tquat< T, P > const &q, tvec4< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > rotation (tvec3< T, P > const &orig, tvec3< T, P > const &dest)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > shortMix (tquat< T, P > const &x, tquat< T, P > const &y, T const &a)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > squad (tquat< T, P > const &q1, tquat< T, P > const &q2, tquat< T, P > const &s1, tquat< T, P > const &s2, T const &h)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > toMat3 (tquat< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > toMat4 (tquat< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > toQuat (tmat3x3< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > toQuat (tmat4x4< T, P > const &x)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_quaternion

Date
2005-12-21 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTX_extented_min_max (dependence)

Definition in file gtx/quaternion.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00095_source.html000066400000000000000000000657551356361734700232520ustar00rootroot00000000000000 0.9.7: quaternion.hpp Source File
gtx/quaternion.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependency:
46 #include "../glm.hpp"
47 #include "../gtc/constants.hpp"
48 #include "../gtc/quaternion.hpp"
49 #include "../gtx/norm.hpp"
50 
51 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
52 # pragma message("GLM: GLM_GTX_quaternion extension included")
53 #endif
54 
55 namespace glm
56 {
59 
63  template<typename T, precision P>
64  GLM_FUNC_DECL tvec3<T, P> cross(
65  tquat<T, P> const & q,
66  tvec3<T, P> const & v);
67 
71  template<typename T, precision P>
72  GLM_FUNC_DECL tvec3<T, P> cross(
73  tvec3<T, P> const & v,
74  tquat<T, P> const & q);
75 
80  template<typename T, precision P>
81  GLM_FUNC_DECL tquat<T, P> squad(
82  tquat<T, P> const & q1,
83  tquat<T, P> const & q2,
84  tquat<T, P> const & s1,
85  tquat<T, P> const & s2,
86  T const & h);
87 
91  template<typename T, precision P>
92  GLM_FUNC_DECL tquat<T, P> intermediate(
93  tquat<T, P> const & prev,
94  tquat<T, P> const & curr,
95  tquat<T, P> const & next);
96 
100  template<typename T, precision P>
101  GLM_FUNC_DECL tquat<T, P> exp(
102  tquat<T, P> const & q);
103 
107  template<typename T, precision P>
108  GLM_FUNC_DECL tquat<T, P> log(
109  tquat<T, P> const & q);
110 
114  template<typename T, precision P>
115  GLM_FUNC_DECL tquat<T, P> pow(
116  tquat<T, P> const & x,
117  T const & y);
118 
122  //template<typename T, precision P>
123  //tquat<T, P> sqrt(
124  // tquat<T, P> const & q);
125 
129  template<typename T, precision P>
130  GLM_FUNC_DECL tvec3<T, P> rotate(
131  tquat<T, P> const & q,
132  tvec3<T, P> const & v);
133 
137  template<typename T, precision P>
138  GLM_FUNC_DECL tvec4<T, P> rotate(
139  tquat<T, P> const & q,
140  tvec4<T, P> const & v);
141 
145  template<typename T, precision P>
146  GLM_FUNC_DECL T extractRealComponent(
147  tquat<T, P> const & q);
148 
152  template<typename T, precision P>
153  GLM_FUNC_DECL tmat3x3<T, P> toMat3(
154  tquat<T, P> const & x){return mat3_cast(x);}
155 
159  template<typename T, precision P>
160  GLM_FUNC_DECL tmat4x4<T, P> toMat4(
161  tquat<T, P> const & x){return mat4_cast(x);}
162 
166  template<typename T, precision P>
167  GLM_FUNC_DECL tquat<T, P> toQuat(
168  tmat3x3<T, P> const & x){return quat_cast(x);}
169 
173  template<typename T, precision P>
174  GLM_FUNC_DECL tquat<T, P> toQuat(
175  tmat4x4<T, P> const & x){return quat_cast(x);}
176 
180  template<typename T, precision P>
181  GLM_FUNC_DECL tquat<T, P> shortMix(
182  tquat<T, P> const & x,
183  tquat<T, P> const & y,
184  T const & a);
185 
189  template<typename T, precision P>
190  GLM_FUNC_DECL tquat<T, P> fastMix(
191  tquat<T, P> const & x,
192  tquat<T, P> const & y,
193  T const & a);
194 
200  template<typename T, precision P>
201  GLM_FUNC_DECL tquat<T, P> rotation(
202  tvec3<T, P> const & orig,
203  tvec3<T, P> const & dest);
204 
208  template<typename T, precision P>
209  GLM_FUNC_DECL T length2(tquat<T, P> const & q);
210 
212 }//namespace glm
213 
214 #include "quaternion.inl"
glm::intermediate
GLM_FUNC_DECL tquat< T, P > intermediate(tquat< T, P > const &prev, tquat< T, P > const &curr, tquat< T, P > const &next)
Returns an intermediate control point for squad interpolation.
glm::extractRealComponent
GLM_FUNC_DECL T extractRealComponent(tquat< T, P > const &q)
Extract the real component of a quaternion.
glm::toMat3
GLM_FUNC_DECL tmat3x3< T, P > toMat3(tquat< T, P > const &x)
Converts a quaternion to a 3 * 3 matrix.
Definition: gtx/quaternion.hpp:153
glm::exp
GLM_FUNC_DECL tquat< T, P > exp(tquat< T, P > const &q)
Returns a exp of a quaternion.
glm::fastMix
GLM_FUNC_DECL tquat< T, P > fastMix(tquat< T, P > const &x, tquat< T, P > const &y, T const &a)
Quaternion normalized linear interpolation.
glm::squad
GLM_FUNC_DECL tquat< T, P > squad(tquat< T, P > const &q1, tquat< T, P > const &q2, tquat< T, P > const &s1, tquat< T, P > const &s2, T const &h)
Compute a point on a path according squad equation.
glm::toMat4
GLM_FUNC_DECL tmat4x4< T, P > toMat4(tquat< T, P > const &x)
Converts a quaternion to a 4 * 4 matrix.
Definition: gtx/quaternion.hpp:160
glm::mat4_cast
GLM_FUNC_DECL tmat4x4< T, P > mat4_cast(tquat< T, P > const &x)
Converts a quaternion to a 4 * 4 matrix.
glm::shortMix
GLM_FUNC_DECL tquat< T, P > shortMix(tquat< T, P > const &x, tquat< T, P > const &y, T const &a)
Quaternion interpolation using the rotation short path.
glm::toQuat
GLM_FUNC_DECL tquat< T, P > toQuat(tmat4x4< T, P > const &x)
Converts a 4 * 4 matrix to a quaternion.
Definition: gtx/quaternion.hpp:174
glm::cross
GLM_FUNC_DECL tvec3< T, P > cross(tvec3< T, P > const &v, tquat< T, P > const &q)
Compute a cross product between a vector and a quaternion.
glm
Definition: _noise.hpp:40
glm::rotate
GLM_FUNC_DECL tvec4< T, P > rotate(tquat< T, P > const &q, tvec4< T, P > const &v)
Rotates a 4 components vector by a quaternion.
glm::quat_cast
GLM_FUNC_DECL tquat< T, P > quat_cast(tmat3x3< T, P > const &x)
Converts a 3 * 3 matrix to a quaternion.
glm::rotation
GLM_FUNC_DECL tquat< T, P > rotation(tvec3< T, P > const &orig, tvec3< T, P > const &dest)
Compute the rotation between two vectors.
glm::mat3_cast
GLM_FUNC_DECL tmat3x3< T, P > mat3_cast(tquat< T, P > const &x)
Converts a quaternion to a 3 * 3 matrix.
glm::log
GLM_FUNC_DECL tquat< T, P > log(tquat< T, P > const &q)
Returns a log of a quaternion.
glm::length2
GLM_FUNC_DECL T length2(tquat< T, P > const &q)
Returns the squared length of x.
glm::pow
GLM_FUNC_DECL tquat< T, P > pow(tquat< T, P > const &x, T const &y)
Returns x raised to the y power.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00096.html000066400000000000000000000177621356361734700216660ustar00rootroot00000000000000 0.9.7: random.hpp File Reference
Functions
random.hpp File Reference

Go to the source code of this file.

Functions

template<typename T >
GLM_FUNC_DECL tvec3< T, defaultp > ballRand (T Radius)
 
template<typename T >
GLM_FUNC_DECL tvec2< T, defaultp > circularRand (T Radius)
 
template<typename T >
GLM_FUNC_DECL tvec2< T, defaultp > diskRand (T Radius)
 
template<typename genType >
GLM_FUNC_DECL genType gaussRand (genType Mean, genType Deviation)
 
template<typename genTYpe >
GLM_FUNC_DECL genTYpe linearRand (genTYpe Min, genTYpe Max)
 
template<typename T >
GLM_FUNC_DECL tvec3< T, defaultp > sphericalRand (T Radius)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTC_random

Date
2011-09-18 / 2011-09-18
Author
Christophe Riccio
See also
GLM Core (dependence)
gtc_half_float (dependence)
gtx_random (extended)

Definition in file random.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00096_source.html000066400000000000000000000274341356361734700232430ustar00rootroot00000000000000 0.9.7: random.hpp Source File
random.hpp
Go to the documentation of this file.
1 
44 #pragma once
45 
46 // Dependency:
47 #include "../vec2.hpp"
48 #include "../vec3.hpp"
49 
50 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
51 # pragma message("GLM: GLM_GTC_random extension included")
52 #endif
53 
54 namespace glm
55 {
58 
65  template <typename genTYpe>
66  GLM_FUNC_DECL genTYpe linearRand(
67  genTYpe Min,
68  genTYpe Max);
69 
70  template <typename T, precision P, template <typename, precision> class vecType>
71  GLM_FUNC_DECL vecType<T, P> linearRand(
72  vecType<T, P> const & Min,
73  vecType<T, P> const & Max);
74 
80  template <typename genType>
81  GLM_FUNC_DECL genType gaussRand(
82  genType Mean,
83  genType Deviation);
84 
89  template <typename T>
90  GLM_FUNC_DECL tvec2<T, defaultp> circularRand(
91  T Radius);
92 
97  template <typename T>
98  GLM_FUNC_DECL tvec3<T, defaultp> sphericalRand(
99  T Radius);
100 
105  template <typename T>
106  GLM_FUNC_DECL tvec2<T, defaultp> diskRand(
107  T Radius);
108 
113  template <typename T>
114  GLM_FUNC_DECL tvec3<T, defaultp> ballRand(
115  T Radius);
116 
118 }//namespace glm
119 
120 #include "random.inl"
glm::ballRand
GLM_FUNC_DECL tvec3< T, defaultp > ballRand(T Radius)
Generate a random 3D vector which coordinates are regulary distributed within the volume of a ball of...
glm::circularRand
GLM_FUNC_DECL tvec2< T, defaultp > circularRand(T Radius)
Generate a random 2D vector which coordinates are regulary distributed on a circle of a given radius...
glm
Definition: _noise.hpp:40
glm::gaussRand
GLM_FUNC_DECL genType gaussRand(genType Mean, genType Deviation)
Generate random numbers in the interval [Min, Max], according a gaussian distribution.
glm::linearRand
GLM_FUNC_DECL genTYpe linearRand(genTYpe Min, genTYpe Max)
Generate random numbers in the interval [Min, Max], according a linear distribution.
glm::sphericalRand
GLM_FUNC_DECL tvec3< T, defaultp > sphericalRand(T Radius)
Generate a random 3D vector which coordinates are regulary distributed on a sphere of a given radius...
glm::diskRand
GLM_FUNC_DECL tvec2< T, defaultp > diskRand(T Radius)
Generate a random 2D vector which coordinates are regulary distributed within the area of a disk of a...
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00097.html000066400000000000000000000103241356361734700216520ustar00rootroot00000000000000 0.9.7: range.hpp File Reference
range.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_range

Date
2014-09-19 / 2014-09-19
Author
Joshua Moerman

Definition in file range.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00097_source.html000066400000000000000000000271541356361734700232430ustar00rootroot00000000000000 0.9.7: range.hpp Source File
range.hpp
Go to the documentation of this file.
1 
41 #pragma once
42 
43 // Dependencies
44 #include "../detail/setup.hpp"
45 
46 #if !GLM_HAS_RANGE_FOR
47 # error "GLM_GTX_range requires C++11 suppport or 'range for'"
48 #endif
49 
50 #include "../gtc/type_ptr.hpp"
51 
52 namespace glm{
53 namespace detail
54 {
55  /* The glm types provide a .length() member, but for matrices
56  this only defines the number of columns, so we need to work around this */
57  template <typename T, precision P>
58  detail::component_count_t number_of_elements_(tvec2<T, P> const & v){
59  return detail::component_count(v);
60  }
61 
62  template <typename T, precision P>
63  detail::component_count_t number_of_elements_(tvec3<T, P> const & v){
64  return detail::component_count(v);
65  }
66 
67  template <typename T, precision P>
68  detail::component_count_t number_of_elements_(tvec4<T, P> const & v){
69  return detail::component_count(v);
70  }
71 
72  template <typename genType>
73  detail::component_count_t number_of_elements_(genType const & m){
74  return detail::component_count(m) * detail::component_count(m[0]);
75  }
76 }//namespace
77 
80 
81  template <typename genType>
82  const typename genType::value_type * begin(genType const & v){
83  return value_ptr(v);
84  }
85 
86  template <typename genType>
87  const typename genType::value_type * end(genType const & v){
88  return begin(v) + detail::number_of_elements_(v);
89  }
90 
91  template <typename genType>
92  typename genType::value_type * begin(genType& v){
93  return value_ptr(v);
94  }
95 
96  template <typename genType>
97  typename genType::value_type * end(genType& v){
98  return begin(v) + detail::number_of_elements_(v);
99  }
100 
102 }//namespace glm
glm
Definition: _noise.hpp:40
glm::value_ptr
GLM_FUNC_DECL genType::value_type const * value_ptr(genType const &vec)
Return the constant address to the data of the input parameter.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00098.html000066400000000000000000000142121356361734700216530ustar00rootroot00000000000000 0.9.7: raw_data.hpp File Reference
Typedefs
raw_data.hpp File Reference

Go to the source code of this file.

Typedefs

typedef detail::uint8 byte
 
typedef detail::uint32 dword
 
typedef detail::uint64 qword
 
typedef detail::uint16 word
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_raw_data

Date
2008-11-19 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file raw_data.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00098_source.html000066400000000000000000000175261356361734700232460ustar00rootroot00000000000000 0.9.7: raw_data.hpp Source File
raw_data.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependencies
45 #include "../detail/setup.hpp"
46 #include "../detail/type_int.hpp"
47 
48 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
49 # pragma message("GLM: GLM_GTX_raw_data extension included")
50 #endif
51 
52 namespace glm
53 {
56 
59  typedef detail::uint8 byte;
60 
63  typedef detail::uint16 word;
64 
67  typedef detail::uint32 dword;
68 
71  typedef detail::uint64 qword;
72 
74 }// namespace glm
75 
76 #include "raw_data.inl"
glm::word
detail::uint16 word
Type for word numbers.
Definition: raw_data.hpp:63
glm::byte
detail::uint8 byte
Type for byte numbers.
Definition: raw_data.hpp:59
glm
Definition: _noise.hpp:40
glm::dword
detail::uint32 dword
Type for dword numbers.
Definition: raw_data.hpp:67
glm::qword
detail::uint64 qword
Type for qword numbers.
Definition: raw_data.hpp:71
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00099.html000066400000000000000000000261711356361734700216630ustar00rootroot00000000000000 0.9.7: reciprocal.hpp File Reference
Functions
reciprocal.hpp File Reference

Go to the source code of this file.

Functions

template<typename genType >
GLM_FUNC_DECL genType acot (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL genType acoth (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL genType acsc (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL genType acsch (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL genType asec (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL genType asech (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL genType cot (genType const &angle)
 
template<typename genType >
GLM_FUNC_DECL genType coth (genType const &angle)
 
template<typename genType >
GLM_FUNC_DECL genType csc (genType const &angle)
 
template<typename genType >
GLM_FUNC_DECL genType csch (genType const &angle)
 
template<typename genType >
GLM_FUNC_DECL genType sec (genType const &angle)
 
template<typename genType >
GLM_FUNC_DECL genType sech (genType const &angle)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTC_reciprocal

Date
2008-10-09 / 2012-01-25
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file reciprocal.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00099_source.html000066400000000000000000000362041356361734700232410ustar00rootroot00000000000000 0.9.7: reciprocal.hpp Source File
reciprocal.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependencies
45 #include "../detail/setup.hpp"
46 
47 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
48 # pragma message("GLM: GLM_GTC_reciprocal extension included")
49 #endif
50 
51 namespace glm
52 {
55 
60  template <typename genType>
61  GLM_FUNC_DECL genType sec(genType const & angle);
62 
67  template <typename genType>
68  GLM_FUNC_DECL genType csc(genType const & angle);
69 
74  template <typename genType>
75  GLM_FUNC_DECL genType cot(genType const & angle);
76 
80  template <typename genType>
81  GLM_FUNC_DECL genType asec(genType const & x);
82 
86  template <typename genType>
87  GLM_FUNC_DECL genType acsc(genType const & x);
88 
92  template <typename genType>
93  GLM_FUNC_DECL genType acot(genType const & x);
94 
98  template <typename genType>
99  GLM_FUNC_DECL genType sech(genType const & angle);
100 
104  template <typename genType>
105  GLM_FUNC_DECL genType csch(genType const & angle);
106 
110  template <typename genType>
111  GLM_FUNC_DECL genType coth(genType const & angle);
112 
116  template <typename genType>
117  GLM_FUNC_DECL genType asech(genType const & x);
118 
122  template <typename genType>
123  GLM_FUNC_DECL genType acsch(genType const & x);
124 
128  template <typename genType>
129  GLM_FUNC_DECL genType acoth(genType const & x);
130 
132 }//namespace glm
133 
134 #include "reciprocal.inl"
glm::asech
GLM_FUNC_DECL genType asech(genType const &x)
Inverse secant hyperbolic function.
glm::cot
GLM_FUNC_DECL genType cot(genType const &angle)
Cotangent function.
glm::csch
GLM_FUNC_DECL genType csch(genType const &angle)
Cosecant hyperbolic function.
glm::asec
GLM_FUNC_DECL genType asec(genType const &x)
Inverse secant function.
glm::acot
GLM_FUNC_DECL genType acot(genType const &x)
Inverse cotangent function.
glm::csc
GLM_FUNC_DECL genType csc(genType const &angle)
Cosecant function.
glm
Definition: _noise.hpp:40
glm::sec
GLM_FUNC_DECL genType sec(genType const &angle)
Secant function.
glm::angle
GLM_FUNC_DECL T angle(tquat< T, P > const &x)
Returns the quaternion rotation angle.
glm::acoth
GLM_FUNC_DECL genType acoth(genType const &x)
Inverse cotangent hyperbolic function.
glm::acsch
GLM_FUNC_DECL genType acsch(genType const &x)
Inverse cosecant hyperbolic function.
glm::coth
GLM_FUNC_DECL genType coth(genType const &angle)
Cotangent hyperbolic function.
glm::acsc
GLM_FUNC_DECL genType acsc(genType const &x)
Inverse cosecant function.
glm::sech
GLM_FUNC_DECL genType sech(genType const &angle)
Secant hyperbolic function.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00100.html000066400000000000000000000144301356361734700216350ustar00rootroot00000000000000 0.9.7: rotate_normalized_axis.hpp File Reference
Functions
rotate_normalized_axis.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > rotateNormalizedAxis (tmat4x4< T, P > const &m, T const &angle, tvec3< T, P > const &axis)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > rotateNormalizedAxis (tquat< T, P > const &q, T const &angle, tvec3< T, P > const &axis)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_rotate_normalized_axis

Date
2012-12-13 / 2012-12-13
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTC_matrix_transform
GLM_GTC_quaternion

Definition in file rotate_normalized_axis.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00100_source.html000066400000000000000000000205441356361734700232200ustar00rootroot00000000000000 0.9.7: rotate_normalized_axis.hpp Source File
rotate_normalized_axis.hpp
Go to the documentation of this file.
1 
44 #pragma once
45 
46 // Dependency:
47 #include "../glm.hpp"
48 #include "../gtc/epsilon.hpp"
49 #include "../gtc/quaternion.hpp"
50 
51 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
52 # pragma message("GLM: GLM_GTX_rotate_normalized_axis extension included")
53 #endif
54 
55 namespace glm
56 {
59 
71  template <typename T, precision P>
72  GLM_FUNC_DECL tmat4x4<T, P> rotateNormalizedAxis(
73  tmat4x4<T, P> const & m,
74  T const & angle,
75  tvec3<T, P> const & axis);
76 
84  template <typename T, precision P>
85  GLM_FUNC_DECL tquat<T, P> rotateNormalizedAxis(
86  tquat<T, P> const & q,
87  T const & angle,
88  tvec3<T, P> const & axis);
89 
91 }//namespace glm
92 
93 #include "rotate_normalized_axis.inl"
glm::rotateNormalizedAxis
GLM_FUNC_DECL tquat< T, P > rotateNormalizedAxis(tquat< T, P > const &q, T const &angle, tvec3< T, P > const &axis)
Rotates a quaternion from a vector of 3 components normalized axis and an angle.
glm::axis
GLM_FUNC_DECL tvec3< T, P > axis(tquat< T, P > const &x)
Returns the q rotation axis.
glm
Definition: _noise.hpp:40
glm::angle
GLM_FUNC_DECL T angle(tquat< T, P > const &x)
Returns the quaternion rotation angle.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00101.html000066400000000000000000000266201356361734700216420ustar00rootroot00000000000000 0.9.7: rotate_vector.hpp File Reference
Functions
rotate_vector.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > orientation (tvec3< T, P > const &Normal, tvec3< T, P > const &Up)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec2< T, P > rotate (tvec2< T, P > const &v, T const &angle)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > rotate (tvec3< T, P > const &v, T const &angle, tvec3< T, P > const &normal)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< T, P > rotate (tvec4< T, P > const &v, T const &angle, tvec3< T, P > const &normal)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > rotateX (tvec3< T, P > const &v, T const &angle)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< T, P > rotateX (tvec4< T, P > const &v, T const &angle)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > rotateY (tvec3< T, P > const &v, T const &angle)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< T, P > rotateY (tvec4< T, P > const &v, T const &angle)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > rotateZ (tvec3< T, P > const &v, T const &angle)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< T, P > rotateZ (tvec4< T, P > const &v, T const &angle)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > slerp (tvec3< T, P > const &x, tvec3< T, P > const &y, T const &a)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_rotate_vector

Date
2006-11-02 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTX_transform (dependence)

Definition in file rotate_vector.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00101_source.html000066400000000000000000000424571356361734700232300ustar00rootroot00000000000000 0.9.7: rotate_vector.hpp Source File
rotate_vector.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependency:
46 #include "../glm.hpp"
47 #include "../gtx/transform.hpp"
48 
49 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
50 # pragma message("GLM: GLM_GTX_rotate_vector extension included")
51 #endif
52 
53 namespace glm
54 {
57 
65  template <typename T, precision P>
66  GLM_FUNC_DECL tvec3<T, P> slerp(
67  tvec3<T, P> const & x,
68  tvec3<T, P> const & y,
69  T const & a);
70 
73  template <typename T, precision P>
74  GLM_FUNC_DECL tvec2<T, P> rotate(
75  tvec2<T, P> const & v,
76  T const & angle);
77 
80  template <typename T, precision P>
81  GLM_FUNC_DECL tvec3<T, P> rotate(
82  tvec3<T, P> const & v,
83  T const & angle,
84  tvec3<T, P> const & normal);
85 
88  template <typename T, precision P>
89  GLM_FUNC_DECL tvec4<T, P> rotate(
90  tvec4<T, P> const & v,
91  T const & angle,
92  tvec3<T, P> const & normal);
93 
96  template <typename T, precision P>
97  GLM_FUNC_DECL tvec3<T, P> rotateX(
98  tvec3<T, P> const & v,
99  T const & angle);
100 
103  template <typename T, precision P>
104  GLM_FUNC_DECL tvec3<T, P> rotateY(
105  tvec3<T, P> const & v,
106  T const & angle);
107 
110  template <typename T, precision P>
111  GLM_FUNC_DECL tvec3<T, P> rotateZ(
112  tvec3<T, P> const & v,
113  T const & angle);
114 
117  template <typename T, precision P>
118  GLM_FUNC_DECL tvec4<T, P> rotateX(
119  tvec4<T, P> const & v,
120  T const & angle);
121 
124  template <typename T, precision P>
125  GLM_FUNC_DECL tvec4<T, P> rotateY(
126  tvec4<T, P> const & v,
127  T const & angle);
128 
131  template <typename T, precision P>
132  GLM_FUNC_DECL tvec4<T, P> rotateZ(
133  tvec4<T, P> const & v,
134  T const & angle);
135 
138  template <typename T, precision P>
139  GLM_FUNC_DECL tmat4x4<T, P> orientation(
140  tvec3<T, P> const & Normal,
141  tvec3<T, P> const & Up);
142 
144 }//namespace glm
145 
146 #include "rotate_vector.inl"
glm::rotateZ
GLM_FUNC_DECL tvec4< T, P > rotateZ(tvec4< T, P > const &v, T const &angle)
Rotate a four dimensional vector around the X axis.
glm::orientation
GLM_FUNC_DECL tmat4x4< T, P > orientation(tvec3< T, P > const &Normal, tvec3< T, P > const &Up)
Build a rotation matrix from a normal and a up vector.
glm::rotate
GLM_FUNC_DECL tvec4< T, P > rotate(tvec4< T, P > const &v, T const &angle, tvec3< T, P > const &normal)
Rotate a four dimensional vector around an axis.
glm::rotateX
GLM_FUNC_DECL tvec4< T, P > rotateX(tvec4< T, P > const &v, T const &angle)
Rotate a four dimentionnals vector around the X axis.
glm
Definition: _noise.hpp:40
glm::angle
GLM_FUNC_DECL T angle(tquat< T, P > const &x)
Returns the quaternion rotation angle.
glm::slerp
GLM_FUNC_DECL tvec3< T, P > slerp(tvec3< T, P > const &x, tvec3< T, P > const &y, T const &a)
Returns Spherical interpolation between two vectors.
glm::rotateY
GLM_FUNC_DECL tvec4< T, P > rotateY(tvec4< T, P > const &v, T const &angle)
Rotate a four dimensional vector around the X axis.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00102.html000066400000000000000000000360761356361734700216510ustar00rootroot00000000000000 0.9.7: round.hpp File Reference
Functions
round.hpp File Reference

Go to the source code of this file.

Functions

template<typename genType >
GLM_FUNC_DECL genType ceilMultiple (genType Source, genType Multiple)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > ceilMultiple (vecType< T, P > const &Source, vecType< T, P > const &Multiple)
 
template<typename genIUType >
GLM_FUNC_DECL genIUType ceilPowerOfTwo (genIUType Value)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > ceilPowerOfTwo (vecType< T, P > const &value)
 
template<typename genType >
GLM_FUNC_DECL genType floorMultiple (genType Source, genType Multiple)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > floorMultiple (vecType< T, P > const &Source, vecType< T, P > const &Multiple)
 
template<typename genIUType >
GLM_FUNC_DECL genIUType floorPowerOfTwo (genIUType Value)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > floorPowerOfTwo (vecType< T, P > const &value)
 
template<typename genIUType >
GLM_FUNC_DECL bool isMultiple (genIUType Value, genIUType Multiple)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > isMultiple (vecType< T, P > const &Value, T Multiple)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > isMultiple (vecType< T, P > const &Value, vecType< T, P > const &Multiple)
 
template<typename genIUType >
GLM_FUNC_DECL bool isPowerOfTwo (genIUType Value)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > isPowerOfTwo (vecType< T, P > const &value)
 
template<typename genType >
GLM_FUNC_DECL genType roundMultiple (genType Source, genType Multiple)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > roundMultiple (vecType< T, P > const &Source, vecType< T, P > const &Multiple)
 
template<typename genIUType >
GLM_FUNC_DECL genIUType roundPowerOfTwo (genIUType Value)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > roundPowerOfTwo (vecType< T, P > const &value)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTC_round

Date
2014-11-03 / 2014-11-03
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTC_round (dependence)

Definition in file round.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00102_source.html000066400000000000000000000475301356361734700232260ustar00rootroot00000000000000 0.9.7: round.hpp Source File
round.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependencies
46 #include "../detail/setup.hpp"
47 #include "../detail/precision.hpp"
48 #include "../detail/_vectorize.hpp"
49 #include "../vector_relational.hpp"
50 #include "../common.hpp"
51 #include <limits>
52 
53 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
54 # pragma message("GLM: GLM_GTC_integer extension included")
55 #endif
56 
57 namespace glm
58 {
61 
65  template <typename genIUType>
66  GLM_FUNC_DECL bool isPowerOfTwo(genIUType Value);
67 
71  template <typename T, precision P, template <typename, precision> class vecType>
72  GLM_FUNC_DECL vecType<bool, P> isPowerOfTwo(vecType<T, P> const & value);
73 
78  template <typename genIUType>
79  GLM_FUNC_DECL genIUType ceilPowerOfTwo(genIUType Value);
80 
85  template <typename T, precision P, template <typename, precision> class vecType>
86  GLM_FUNC_DECL vecType<T, P> ceilPowerOfTwo(vecType<T, P> const & value);
87 
92  template <typename genIUType>
93  GLM_FUNC_DECL genIUType floorPowerOfTwo(genIUType Value);
94 
99  template <typename T, precision P, template <typename, precision> class vecType>
100  GLM_FUNC_DECL vecType<T, P> floorPowerOfTwo(vecType<T, P> const & value);
101 
105  template <typename genIUType>
106  GLM_FUNC_DECL genIUType roundPowerOfTwo(genIUType Value);
107 
111  template <typename T, precision P, template <typename, precision> class vecType>
112  GLM_FUNC_DECL vecType<T, P> roundPowerOfTwo(vecType<T, P> const & value);
113 
117  template <typename genIUType>
118  GLM_FUNC_DECL bool isMultiple(genIUType Value, genIUType Multiple);
119 
123  template <typename T, precision P, template <typename, precision> class vecType>
124  GLM_FUNC_DECL vecType<bool, P> isMultiple(vecType<T, P> const & Value, T Multiple);
125 
129  template <typename T, precision P, template <typename, precision> class vecType>
130  GLM_FUNC_DECL vecType<bool, P> isMultiple(vecType<T, P> const & Value, vecType<T, P> const & Multiple);
131 
139  template <typename genType>
140  GLM_FUNC_DECL genType ceilMultiple(genType Source, genType Multiple);
141 
149  template <typename T, precision P, template <typename, precision> class vecType>
150  GLM_FUNC_DECL vecType<T, P> ceilMultiple(vecType<T, P> const & Source, vecType<T, P> const & Multiple);
151 
159  template <typename genType>
160  GLM_FUNC_DECL genType floorMultiple(
161  genType Source,
162  genType Multiple);
163 
171  template <typename T, precision P, template <typename, precision> class vecType>
172  GLM_FUNC_DECL vecType<T, P> floorMultiple(
173  vecType<T, P> const & Source,
174  vecType<T, P> const & Multiple);
175 
183  template <typename genType>
184  GLM_FUNC_DECL genType roundMultiple(
185  genType Source,
186  genType Multiple);
187 
195  template <typename T, precision P, template <typename, precision> class vecType>
196  GLM_FUNC_DECL vecType<T, P> roundMultiple(
197  vecType<T, P> const & Source,
198  vecType<T, P> const & Multiple);
199 
201 } //namespace glm
202 
203 #include "round.inl"
glm::isPowerOfTwo
GLM_FUNC_DECL vecType< bool, P > isPowerOfTwo(vecType< T, P > const &value)
Return true if the value is a power of two number.
glm::roundPowerOfTwo
GLM_FUNC_DECL vecType< T, P > roundPowerOfTwo(vecType< T, P > const &value)
Return the power of two number which value is the closet to the input value.
glm::floorPowerOfTwo
GLM_FUNC_DECL vecType< T, P > floorPowerOfTwo(vecType< T, P > const &value)
Return the power of two number which value is just lower the input value, round down to a power of tw...
glm::ceilPowerOfTwo
GLM_FUNC_DECL vecType< T, P > ceilPowerOfTwo(vecType< T, P > const &value)
Return the power of two number which value is just higher the input value, round up to a power of two...
glm::ceilMultiple
GLM_FUNC_DECL vecType< T, P > ceilMultiple(vecType< T, P > const &Source, vecType< T, P > const &Multiple)
Higher multiple number of Source.
glm
Definition: _noise.hpp:40
glm::floorMultiple
GLM_FUNC_DECL vecType< T, P > floorMultiple(vecType< T, P > const &Source, vecType< T, P > const &Multiple)
Lower multiple number of Source.
glm::roundMultiple
GLM_FUNC_DECL vecType< T, P > roundMultiple(vecType< T, P > const &Source, vecType< T, P > const &Multiple)
Lower multiple number of Source.
glm::isMultiple
GLM_FUNC_DECL vecType< bool, P > isMultiple(vecType< T, P > const &Value, vecType< T, P > const &Multiple)
Return true if the 'Value' is a multiple of 'Multiple'.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00103.html000066400000000000000000000110551356361734700216400ustar00rootroot00000000000000 0.9.7: scalar_multiplication.hpp File Reference
scalar_multiplication.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GTX Extensions (Experimental)

Date
2014-09-22 / 2014-09-22
Author
Joshua Moerman

Enables scalar multiplication for all types

Since GLSL is very strict about types, the following (often used) combinations do not work: double * vec4 int * vec4 vec4 / int So we'll fix that! Of course "float * vec4" should remain the same (hence the enable_if magic)

Definition in file scalar_multiplication.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00103_source.html000066400000000000000000000403401356361734700232170ustar00rootroot00000000000000 0.9.7: scalar_multiplication.hpp Source File
scalar_multiplication.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 #include "../detail/setup.hpp"
45 
46 #if !GLM_HAS_TEMPLATE_ALIASES && !(GLM_COMPILER & GLM_COMPILER_GCC)
47 # error "GLM_GTX_scalar_multiplication requires C++11 support or alias templates and if not support for GCC"
48 #endif
49 
50 #include "../vec2.hpp"
51 #include "../vec3.hpp"
52 #include "../vec4.hpp"
53 #include "../mat2x2.hpp"
54 #include <type_traits>
55 
56 namespace glm
57 {
58  template <typename T, typename Vec>
59  using return_type_scalar_multiplication = typename std::enable_if<
60  !std::is_same<T, float>::value // T may not be a float
61  && std::is_arithmetic<T>::value, Vec // But it may be an int or double (no vec3 or mat3, ...)
62  >::type;
63 
64 #define GLM_IMPLEMENT_SCAL_MULT(Vec) \
65  template <typename T> \
66  return_type_scalar_multiplication<T, Vec> \
67  operator*(T const & s, Vec rh){ \
68  return rh *= static_cast<float>(s); \
69  } \
70  \
71  template <typename T> \
72  return_type_scalar_multiplication<T, Vec> \
73  operator*(Vec lh, T const & s){ \
74  return lh *= static_cast<float>(s); \
75  } \
76  \
77  template <typename T> \
78  return_type_scalar_multiplication<T, Vec> \
79  operator/(Vec lh, T const & s){ \
80  return lh *= 1.0f / s; \
81  }
82 
83 GLM_IMPLEMENT_SCAL_MULT(vec2)
84 GLM_IMPLEMENT_SCAL_MULT(vec3)
85 GLM_IMPLEMENT_SCAL_MULT(vec4)
86 
87 GLM_IMPLEMENT_SCAL_MULT(mat2)
88 GLM_IMPLEMENT_SCAL_MULT(mat2x3)
89 GLM_IMPLEMENT_SCAL_MULT(mat2x4)
90 GLM_IMPLEMENT_SCAL_MULT(mat3x2)
91 GLM_IMPLEMENT_SCAL_MULT(mat3)
92 GLM_IMPLEMENT_SCAL_MULT(mat3x4)
93 GLM_IMPLEMENT_SCAL_MULT(mat4x2)
94 GLM_IMPLEMENT_SCAL_MULT(mat4x3)
95 GLM_IMPLEMENT_SCAL_MULT(mat4)
96 
97 #undef GLM_IMPLEMENT_SCAL_MULT
98 } // namespace glm
glm::mat3x4
highp_mat3x4 mat3x4
3 columns of 4 components matrix of floating-point numbers.
Definition: type_mat.hpp:410
glm::mat2
mat2x2 mat2
2 columns of 2 components matrix of floating-point numbers.
Definition: type_mat.hpp:432
glm::mat2x4
highp_mat2x4 mat2x4
2 columns of 4 components matrix of floating-point numbers.
Definition: type_mat.hpp:395
glm::mat2x3
highp_mat2x3 mat2x3
2 columns of 3 components matrix of floating-point numbers.
Definition: type_mat.hpp:390
glm::mat3x2
highp_mat3x2 mat3x2
3 columns of 2 components matrix of floating-point numbers.
Definition: type_mat.hpp:400
glm::mat3
mat3x3 mat3
3 columns of 3 components matrix of floating-point numbers.
Definition: type_mat.hpp:437
glm::vec2
highp_vec2 vec2
2 components vector of floating-point numbers.
Definition: type_vec.hpp:390
glm::mat4x3
highp_mat4x3 mat4x3
4 columns of 3 components matrix of floating-point numbers.
Definition: type_mat.hpp:420
glm::mat4x2
highp_mat4x2 mat4x2
4 columns of 2 components matrix of floating-point numbers.
Definition: type_mat.hpp:415
glm
Definition: _noise.hpp:40
glm::vec4
highp_vec4 vec4
4 components vector of floating-point numbers.
Definition: type_vec.hpp:400
glm::vec3
highp_vec3 vec3
3 components vector of floating-point numbers.
Definition: type_vec.hpp:395
glm::mat4
mat4x4 mat4
4 columns of 4 components matrix of floating-point numbers.
Definition: type_mat.hpp:442
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00104.html000066400000000000000000000107451356361734700216460ustar00rootroot00000000000000 0.9.7: scalar_relational.hpp File Reference
scalar_relational.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_scalar_relational

Date
2013-02-04 / 2013-02-04
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file scalar_relational.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00104_source.html000066400000000000000000000116251356361734700232240ustar00rootroot00000000000000 0.9.7: scalar_relational.hpp Source File
scalar_relational.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../glm.hpp"
46 
47 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
48 # pragma message("GLM: GLM_GTX_extend extension included")
49 #endif
50 
51 namespace glm
52 {
55 
56 
57 
59 }//namespace glm
60 
61 #include "scalar_relational.inl"
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00105.html000066400000000000000000000103251356361734700216410ustar00rootroot00000000000000 0.9.7: setup.hpp File Reference
setup.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2006-11-13 / 2014-10-05
Author
Christophe Riccio

Definition in file setup.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00105_source.html000066400000000000000000004703371356361734700232360ustar00rootroot00000000000000 0.9.7: setup.hpp Source File
setup.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include <cassert>
36 #include <cstddef>
37 
39 // Version
40 
41 #define GLM_VERSION 97
42 #define GLM_VERSION_MAJOR 0
43 #define GLM_VERSION_MINOR 9
44 #define GLM_VERSION_PATCH 7
45 #define GLM_VERSION_REVISION 0
46 
47 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_VERSION_DISPLAYED))
48 # define GLM_MESSAGE_VERSION_DISPLAYED
49 # pragma message ("GLM: version 0.9.7")
50 #endif//GLM_MESSAGE
51 
53 // Platform
54 
55 #define GLM_PLATFORM_UNKNOWN 0x00000000
56 #define GLM_PLATFORM_WINDOWS 0x00010000
57 #define GLM_PLATFORM_LINUX 0x00020000
58 #define GLM_PLATFORM_APPLE 0x00040000
59 //#define GLM_PLATFORM_IOS 0x00080000
60 #define GLM_PLATFORM_ANDROID 0x00100000
61 #define GLM_PLATFORM_CHROME_NACL 0x00200000
62 #define GLM_PLATFORM_UNIX 0x00400000
63 #define GLM_PLATFORM_QNXNTO 0x00800000
64 #define GLM_PLATFORM_WINCE 0x01000000
65 
66 #ifdef GLM_FORCE_PLATFORM_UNKNOWN
67 # define GLM_PLATFORM GLM_PLATFORM_UNKNOWN
68 #elif defined(__QNXNTO__)
69 # define GLM_PLATFORM GLM_PLATFORM_QNXNTO
70 #elif defined(__APPLE__)
71 # define GLM_PLATFORM GLM_PLATFORM_APPLE
72 #elif defined(WINCE)
73 # define GLM_PLATFORM GLM_PLATFORM_WINCE
74 #elif defined(_WIN32)
75 # define GLM_PLATFORM GLM_PLATFORM_WINDOWS
76 #elif defined(__native_client__)
77 # define GLM_PLATFORM GLM_PLATFORM_CHROME_NACL
78 #elif defined(__ANDROID__)
79 # define GLM_PLATFORM GLM_PLATFORM_ANDROID
80 #elif defined(__linux)
81 # define GLM_PLATFORM GLM_PLATFORM_LINUX
82 #elif defined(__unix)
83 # define GLM_PLATFORM GLM_PLATFORM_UNIX
84 #else
85 # define GLM_PLATFORM GLM_PLATFORM_UNKNOWN
86 #endif//
87 
88 // Report platform detection
89 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_PLATFORM_DISPLAYED))
90 # define GLM_MESSAGE_PLATFORM_DISPLAYED
91 # if(GLM_PLATFORM & GLM_PLATFORM_QNXNTO)
92 # pragma message("GLM: QNX platform detected")
93 //# elif(GLM_PLATFORM & GLM_PLATFORM_IOS)
94 //# pragma message("GLM: iOS platform detected")
95 # elif(GLM_PLATFORM & GLM_PLATFORM_APPLE)
96 # pragma message("GLM: Apple platform detected")
97 # elif(GLM_PLATFORM & GLM_PLATFORM_WINCE)
98 # pragma message("GLM: WinCE platform detected")
99 # elif(GLM_PLATFORM & GLM_PLATFORM_WINDOWS)
100 # pragma message("GLM: Windows platform detected")
101 # elif(GLM_PLATFORM & GLM_PLATFORM_CHROME_NACL)
102 # pragma message("GLM: Native Client detected")
103 # elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
104 # pragma message("GLM: Android platform detected")
105 # elif(GLM_PLATFORM & GLM_PLATFORM_LINUX)
106 # pragma message("GLM: Linux platform detected")
107 # elif(GLM_PLATFORM & GLM_PLATFORM_UNIX)
108 # pragma message("GLM: UNIX platform detected")
109 # elif(GLM_PLATFORM & GLM_PLATFORM_UNKNOWN)
110 # pragma message("GLM: platform unknown")
111 # else
112 # pragma message("GLM: platform not detected")
113 # endif
114 #endif//GLM_MESSAGE
115 
117 // Compiler
118 
119 // User defines: GLM_FORCE_COMPILER_UNKNOWN
120 // TODO ? __llvm__
121 
122 #define GLM_COMPILER_UNKNOWN 0x00000000
123 
124 // Intel
125 #define GLM_COMPILER_INTEL 0x00100000
126 #define GLM_COMPILER_INTEL12 0x00100010
127 #define GLM_COMPILER_INTEL12_1 0x00100020
128 #define GLM_COMPILER_INTEL13 0x00100030
129 #define GLM_COMPILER_INTEL14 0x00100040
130 #define GLM_COMPILER_INTEL15 0x00100050
131 #define GLM_COMPILER_INTEL16 0x00100060
132 
133 // Visual C++ defines
134 #define GLM_COMPILER_VC 0x01000000
135 #define GLM_COMPILER_VC2010 0x01000090
136 #define GLM_COMPILER_VC2012 0x010000A0
137 #define GLM_COMPILER_VC2013 0x010000B0
138 #define GLM_COMPILER_VC2015 0x010000C0
139 
140 // GCC defines
141 #define GLM_COMPILER_GCC 0x02000000
142 #define GLM_COMPILER_GCC44 0x020000B0
143 #define GLM_COMPILER_GCC45 0x020000C0
144 #define GLM_COMPILER_GCC46 0x020000D0
145 #define GLM_COMPILER_GCC47 0x020000E0
146 #define GLM_COMPILER_GCC48 0x020000F0
147 #define GLM_COMPILER_GCC49 0x02000100
148 #define GLM_COMPILER_GCC50 0x02000200
149 #define GLM_COMPILER_GCC51 0x02000300
150 #define GLM_COMPILER_GCC52 0x02000400
151 #define GLM_COMPILER_GCC53 0x02000500
152 
153 // CUDA
154 #define GLM_COMPILER_CUDA 0x10000000
155 #define GLM_COMPILER_CUDA40 0x10000040
156 #define GLM_COMPILER_CUDA41 0x10000050
157 #define GLM_COMPILER_CUDA42 0x10000060
158 #define GLM_COMPILER_CUDA50 0x10000070
159 #define GLM_COMPILER_CUDA60 0x10000080
160 #define GLM_COMPILER_CUDA65 0x10000090
161 #define GLM_COMPILER_CUDA70 0x100000A0
162 #define GLM_COMPILER_CUDA75 0x100000B0
163 
164 // LLVM
165 #define GLM_COMPILER_LLVM 0x20000000
166 #define GLM_COMPILER_LLVM32 0x20000030
167 #define GLM_COMPILER_LLVM33 0x20000040
168 #define GLM_COMPILER_LLVM34 0x20000050
169 #define GLM_COMPILER_LLVM35 0x20000060
170 #define GLM_COMPILER_LLVM36 0x20000070
171 #define GLM_COMPILER_LLVM37 0x20000080
172 #define GLM_COMPILER_LLVM38 0x20000090
173 #define GLM_COMPILER_LLVM39 0x200000A0
174 
175 // Apple Clang
176 #define GLM_COMPILER_APPLE_CLANG 0x40000000
177 #define GLM_COMPILER_APPLE_CLANG40 0x40000010
178 #define GLM_COMPILER_APPLE_CLANG41 0x40000020
179 #define GLM_COMPILER_APPLE_CLANG42 0x40000030
180 #define GLM_COMPILER_APPLE_CLANG50 0x40000040
181 #define GLM_COMPILER_APPLE_CLANG51 0x40000050
182 #define GLM_COMPILER_APPLE_CLANG60 0x40000060
183 #define GLM_COMPILER_APPLE_CLANG61 0x40000070
184 
185 // Build model
186 #define GLM_MODEL_32 0x00000010
187 #define GLM_MODEL_64 0x00000020
188 
189 // Force generic C++ compiler
190 #ifdef GLM_FORCE_COMPILER_UNKNOWN
191 # define GLM_COMPILER GLM_COMPILER_UNKNOWN
192 
193 #elif defined(__INTEL_COMPILER)
194 # if __INTEL_COMPILER == 1200
195 # define GLM_COMPILER GLM_COMPILER_INTEL12
196 # elif __INTEL_COMPILER == 1210
197 # define GLM_COMPILER GLM_COMPILER_INTEL12_1
198 # elif __INTEL_COMPILER == 1300
199 # define GLM_COMPILER GLM_COMPILER_INTEL13
200 # elif __INTEL_COMPILER == 1400
201 # define GLM_COMPILER GLM_COMPILER_INTEL14
202 # elif __INTEL_COMPILER >= 1500
203 # define GLM_COMPILER GLM_COMPILER_INTEL15
204 # elif __INTEL_COMPILER >= 1600
205 # define GLM_COMPILER GLM_COMPILER_INTEL16
206 # else
207 # define GLM_COMPILER GLM_COMPILER_INTEL
208 # endif
209 
210 // CUDA
211 #elif defined(__CUDACC__)
212 # if !defined(CUDA_VERSION) && !defined(GLM_FORCE_CUDA)
213 # include <cuda.h> // make sure version is defined since nvcc does not define it itself!
214 # endif
215 # if CUDA_VERSION < 3000
216 # error "GLM requires CUDA 3.0 or higher"
217 # else
218 # define GLM_COMPILER GLM_COMPILER_CUDA
219 # endif
220 
221 // Visual C++
222 #elif defined(_MSC_VER)
223 # if _MSC_VER < 1600
224 # error "GLM requires Visual C++ 2010 or higher"
225 # elif _MSC_VER == 1600
226 # define GLM_COMPILER GLM_COMPILER_VC2010
227 # elif _MSC_VER == 1700
228 # define GLM_COMPILER GLM_COMPILER_VC2012
229 # elif _MSC_VER == 1800
230 # define GLM_COMPILER GLM_COMPILER_VC2013
231 # elif _MSC_VER >= 1900
232 # define GLM_COMPILER GLM_COMPILER_VC2015
233 # else//_MSC_VER
234 # define GLM_COMPILER GLM_COMPILER_VC
235 # endif//_MSC_VER
236 
237 // Clang
238 #elif defined(__clang__)
239 # if GLM_PLATFORM & GLM_PLATFORM_APPLE
240 # if __clang_major__ == 4 && __clang_minor__ == 0
241 # define GLM_COMPILER GLM_COMPILER_APPLE_CLANG40
242 # elif __clang_major__ == 4 && __clang_minor__ == 1
243 # define GLM_COMPILER GLM_COMPILER_APPLE_CLANG41
244 # elif __clang_major__ == 4 && __clang_minor__ == 2
245 # define GLM_COMPILER GLM_COMPILER_APPLE_CLANG42
246 # elif __clang_major__ == 5 && __clang_minor__ == 0
247 # define GLM_COMPILER GLM_COMPILER_APPLE_CLANG50
248 # elif __clang_major__ == 5 && __clang_minor__ == 1
249 # define GLM_COMPILER GLM_COMPILER_APPLE_CLANG51
250 # elif __clang_major__ == 6 && __clang_minor__ == 0
251 # define GLM_COMPILER GLM_COMPILER_APPLE_CLANG60
252 # elif __clang_major__ == 6 && __clang_minor__ >= 1
253 # define GLM_COMPILER GLM_COMPILER_APPLE_CLANG61
254 # elif __clang_major__ >= 7
255 # define GLM_COMPILER GLM_COMPILER_APPLE_CLANG61
256 # else
257 # define GLM_COMPILER GLM_COMPILER_APPLE_CLANG
258 # endif
259 # else
260 # if __clang_major__ == 3 && __clang_minor__ == 0
261 # define GLM_COMPILER GLM_COMPILER_LLVM30
262 # elif __clang_major__ == 3 && __clang_minor__ == 1
263 # define GLM_COMPILER GLM_COMPILER_LLVM31
264 # elif __clang_major__ == 3 && __clang_minor__ == 2
265 # define GLM_COMPILER GLM_COMPILER_LLVM32
266 # elif __clang_major__ == 3 && __clang_minor__ == 3
267 # define GLM_COMPILER GLM_COMPILER_LLVM33
268 # elif __clang_major__ == 3 && __clang_minor__ == 4
269 # define GLM_COMPILER GLM_COMPILER_LLVM34
270 # elif __clang_major__ == 3 && __clang_minor__ == 5
271 # define GLM_COMPILER GLM_COMPILER_LLVM35
272 # elif __clang_major__ == 3 && __clang_minor__ == 6
273 # define GLM_COMPILER GLM_COMPILER_LLVM36
274 # elif __clang_major__ == 3 && __clang_minor__ == 7
275 # define GLM_COMPILER GLM_COMPILER_LLVM37
276 # elif __clang_major__ == 3 && __clang_minor__ == 8
277 # define GLM_COMPILER GLM_COMPILER_LLVM38
278 # elif __clang_major__ == 3 && __clang_minor__ >= 9
279 # define GLM_COMPILER GLM_COMPILER_LLVM39
280 # elif __clang_major__ >= 4
281 # define GLM_COMPILER GLM_COMPILER_LLVM39
282 # else
283 # define GLM_COMPILER GLM_COMPILER_LLVM
284 # endif
285 # endif
286 
287 // G++
288 #elif defined(__GNUC__) || defined(__MINGW32__)
289 # if (__GNUC__ == 4) && (__GNUC_MINOR__ == 2)
290 # define GLM_COMPILER (GLM_COMPILER_GCC42)
291 # elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 3)
292 # define GLM_COMPILER (GLM_COMPILER_GCC43)
293 # elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 4)
294 # define GLM_COMPILER (GLM_COMPILER_GCC44)
295 # elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 5)
296 # define GLM_COMPILER (GLM_COMPILER_GCC45)
297 # elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 6)
298 # define GLM_COMPILER (GLM_COMPILER_GCC46)
299 # elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 7)
300 # define GLM_COMPILER (GLM_COMPILER_GCC47)
301 # elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 8)
302 # define GLM_COMPILER (GLM_COMPILER_GCC48)
303 # elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)
304 # define GLM_COMPILER (GLM_COMPILER_GCC49)
305 # elif (__GNUC__ == 5) && (__GNUC_MINOR__ == 0)
306 # define GLM_COMPILER (GLM_COMPILER_GCC50)
307 # elif (__GNUC__ == 5) && (__GNUC_MINOR__ == 1)
308 # define GLM_COMPILER (GLM_COMPILER_GCC51)
309 # elif (__GNUC__ == 5) && (__GNUC_MINOR__ == 2)
310 # define GLM_COMPILER (GLM_COMPILER_GCC52)
311 # elif (__GNUC__ == 5) && (__GNUC_MINOR__ >= 3)
312 # define GLM_COMPILER (GLM_COMPILER_GCC53)
313 # else
314 # define GLM_COMPILER (GLM_COMPILER_GCC)
315 # endif
316 
317 #else
318 # define GLM_COMPILER GLM_COMPILER_UNKNOWN
319 #endif
320 
321 #ifndef GLM_COMPILER
322 #error "GLM_COMPILER undefined, your compiler may not be supported by GLM. Add #define GLM_COMPILER 0 to ignore this message."
323 #endif//GLM_COMPILER
324 
325 // Report compiler detection
326 #if defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_COMPILER_DISPLAYED)
327 # define GLM_MESSAGE_COMPILER_DISPLAYED
328 # if GLM_COMPILER & GLM_COMPILER_CUDA
329 # pragma message("GLM: CUDA compiler detected")
330 # elif GLM_COMPILER & GLM_COMPILER_VC
331 # pragma message("GLM: Visual C++ compiler detected")
332 # elif GLM_COMPILER & GLM_COMPILER_APPLE_CLANG
333 # pragma message("GLM: Clang compiler detected")
334 # elif GLM_COMPILER & GLM_COMPILER_LLVM
335 # pragma message("GLM: LLVM compiler detected")
336 # elif GLM_COMPILER & GLM_COMPILER_INTEL
337 # pragma message("GLM: Intel Compiler detected")
338 # elif GLM_COMPILER & GLM_COMPILER_GCC
339 # pragma message("GLM: GCC compiler detected")
340 # else
341 # pragma message("GLM: Compiler not detected")
342 # endif
343 #endif//GLM_MESSAGE
344 
346 // Build model
347 
348 #if defined(__arch64__) || defined(__LP64__) || defined(_M_X64) || defined(__ppc64__) || defined(__x86_64__)
349 # define GLM_MODEL GLM_MODEL_64
350 #elif defined(__i386__) || defined(__ppc__)
351 # define GLM_MODEL GLM_MODEL_32
352 #else
353 # define GLM_MODEL GLM_MODEL_32
354 #endif//
355 
356 #if !defined(GLM_MODEL) && GLM_COMPILER != 0
357 # error "GLM_MODEL undefined, your compiler may not be supported by GLM. Add #define GLM_MODEL 0 to ignore this message."
358 #endif//GLM_MODEL
359 
360 #if defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_MODEL_DISPLAYED)
361 # define GLM_MESSAGE_MODEL_DISPLAYED
362 # if(GLM_MODEL == GLM_MODEL_64)
363 # pragma message("GLM: 64 bits model")
364 # elif(GLM_MODEL == GLM_MODEL_32)
365 # pragma message("GLM: 32 bits model")
366 # endif//GLM_MODEL
367 #endif//GLM_MESSAGE
368 
370 // C++ Version
371 
372 // User defines: GLM_FORCE_CXX98, GLM_FORCE_CXX03, GLM_FORCE_CXX11, GLM_FORCE_CXX14
373 
374 #define GLM_LANG_CXX98_FLAG (1 << 1)
375 #define GLM_LANG_CXX03_FLAG (1 << 2)
376 #define GLM_LANG_CXX0X_FLAG (1 << 3)
377 #define GLM_LANG_CXX11_FLAG (1 << 4)
378 #define GLM_LANG_CXX1Y_FLAG (1 << 5)
379 #define GLM_LANG_CXX14_FLAG (1 << 6)
380 #define GLM_LANG_CXX1Z_FLAG (1 << 7)
381 #define GLM_LANG_CXXMS_FLAG (1 << 8)
382 #define GLM_LANG_CXXGNU_FLAG (1 << 9)
383 
384 #define GLM_LANG_CXX98 GLM_LANG_CXX98_FLAG
385 #define GLM_LANG_CXX03 (GLM_LANG_CXX98 | GLM_LANG_CXX03_FLAG)
386 #define GLM_LANG_CXX0X (GLM_LANG_CXX03 | GLM_LANG_CXX0X_FLAG)
387 #define GLM_LANG_CXX11 (GLM_LANG_CXX0X | GLM_LANG_CXX11_FLAG)
388 #define GLM_LANG_CXX1Y (GLM_LANG_CXX11 | GLM_LANG_CXX1Y_FLAG)
389 #define GLM_LANG_CXX14 (GLM_LANG_CXX1Y | GLM_LANG_CXX14_FLAG)
390 #define GLM_LANG_CXX1Z (GLM_LANG_CXX14 | GLM_LANG_CXX1Z_FLAG)
391 #define GLM_LANG_CXXMS GLM_LANG_CXXMS_FLAG
392 #define GLM_LANG_CXXGNU GLM_LANG_CXXGNU_FLAG
393 
394 #if defined(GLM_FORCE_CXX14)
395 # undef GLM_FORCE_CXX11
396 # undef GLM_FORCE_CXX03
397 # undef GLM_FORCE_CXX98
398 # define GLM_LANG GLM_LANG_CXX14
399 #elif defined(GLM_FORCE_CXX11)
400 # undef GLM_FORCE_CXX03
401 # undef GLM_FORCE_CXX98
402 # define GLM_LANG GLM_LANG_CXX11
403 #elif defined(GLM_FORCE_CXX03)
404 # undef GLM_FORCE_CXX98
405 # define GLM_LANG GLM_LANG_CXX03
406 #elif defined(GLM_FORCE_CXX98)
407 # define GLM_LANG GLM_LANG_CXX98
408 #else
409 # if GLM_COMPILER & (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM)
410 # if __cplusplus >= 201402L // GLM_COMPILER_LLVM34 + -std=c++14
411 # define GLM_LANG GLM_LANG_CXX14
412 # elif __has_feature(cxx_decltype_auto) && __has_feature(cxx_aggregate_nsdmi) // GLM_COMPILER_LLVM33 + -std=c++1y
413 # define GLM_LANG GLM_LANG_CXX1Y
414 # elif __cplusplus >= 201103L // GLM_COMPILER_LLVM33 + -std=c++11
415 # define GLM_LANG GLM_LANG_CXX11
416 # elif __has_feature(cxx_static_assert) // GLM_COMPILER_LLVM29 + -std=c++11
417 # define GLM_LANG GLM_LANG_CXX0X
418 # elif __cplusplus >= 199711L
419 # define GLM_LANG GLM_LANG_CXX98
420 # else
421 # define GLM_LANG GLM_LANG_CXX
422 # endif
423 # elif GLM_COMPILER & GLM_COMPILER_GCC
424 # if __cplusplus >= 201402L
425 # define GLM_LANG GLM_LANG_CXX14
426 # elif __cplusplus >= 201103L
427 # define GLM_LANG GLM_LANG_CXX11
428 # elif defined(__GXX_EXPERIMENTAL_CXX0X__)
429 # define GLM_LANG GLM_LANG_CXX0X
430 # else
431 # define GLM_LANG GLM_LANG_CXX98
432 # endif
433 # elif GLM_COMPILER & GLM_COMPILER_VC
434 # ifdef _MSC_EXTENSIONS
435 # if __cplusplus >= 201402L
436 # define GLM_LANG (GLM_LANG_CXX14 | GLM_LANG_CXXMS_FLAG)
437 //# elif GLM_COMPILER >= GLM_COMPILER_VC2015
438 //# define GLM_LANG (GLM_LANG_CXX1Y | GLM_LANG_CXXMS_FLAG)
439 # elif __cplusplus >= 201103L
440 # define GLM_LANG (GLM_LANG_CXX11 | GLM_LANG_CXXMS_FLAG)
441 # elif GLM_COMPILER >= GLM_COMPILER_VC2010
442 # define GLM_LANG (GLM_LANG_CXX0X | GLM_LANG_CXXMS_FLAG)
443 # elif __cplusplus >= 199711L
444 # define GLM_LANG (GLM_LANG_CXX98 | GLM_LANG_CXXMS_FLAG)
445 # else
446 # define GLM_LANG (GLM_LANG_CXX | GLM_LANG_CXXMS_FLAG)
447 # endif
448 # else
449 # if __cplusplus >= 201402L
450 # define GLM_LANG GLM_LANG_CXX14
451 //# elif GLM_COMPILER >= GLM_COMPILER_VC2015
452 //# define GLM_LANG GLM_LANG_CXX1Y
453 # elif __cplusplus >= 201103L
454 # define GLM_LANG GLM_LANG_CXX11
455 # elif GLM_COMPILER >= GLM_COMPILER_VC2010
456 # define GLM_LANG GLM_LANG_CXX0X
457 # elif __cplusplus >= 199711L
458 # define GLM_LANG GLM_LANG_CXX98
459 # else
460 # define GLM_LANG GLM_LANG_CXX
461 # endif
462 # endif
463 # elif GLM_COMPILER & GLM_COMPILER_INTEL
464 # ifdef _MSC_EXTENSIONS
465 # if __cplusplus >= 201402L
466 # define GLM_LANG (GLM_LANG_CXX14 | GLM_LANG_CXXMS_FLAG)
467 # elif __cplusplus >= 201103L
468 # define GLM_LANG (GLM_LANG_CXX11 | GLM_LANG_CXXMS_FLAG)
469 # elif GLM_COMPILER >= GLM_COMPILER_INTEL13
470 # define GLM_LANG (GLM_LANG_CXX0X | GLM_LANG_CXXMS_FLAG)
471 # elif __cplusplus >= 199711L
472 # define GLM_LANG (GLM_LANG_CXX98 | GLM_LANG_CXXMS_FLAG)
473 # else
474 # define GLM_LANG (GLM_LANG_CXX | GLM_LANG_CXXMS_FLAG)
475 # endif
476 # else
477 # if __cplusplus >= 201402L
478 # define GLM_LANG (GLM_LANG_CXX14 | GLM_LANG_CXXMS_FLAG)
479 # elif __cplusplus >= 201103L
480 # define GLM_LANG (GLM_LANG_CXX11 | GLM_LANG_CXXMS_FLAG)
481 # elif GLM_COMPILER >= GLM_COMPILER_INTEL13
482 # define GLM_LANG (GLM_LANG_CXX0X | GLM_LANG_CXXMS_FLAG)
483 # elif __cplusplus >= 199711L
484 # define GLM_LANG (GLM_LANG_CXX98 | GLM_LANG_CXXMS_FLAG)
485 # else
486 # define GLM_LANG (GLM_LANG_CXX | GLM_LANG_CXXMS_FLAG)
487 # endif
488 # endif
489 # else // Unkown compiler
490 # if __cplusplus >= 201402L
491 # define GLM_LANG GLM_LANG_CXX14
492 # elif __cplusplus >= 201103L
493 # define GLM_LANG GLM_LANG_CXX11
494 # elif __cplusplus >= 199711L
495 # define GLM_LANG GLM_LANG_CXX98
496 # else
497 # define GLM_LANG GLM_LANG_CXX // Good luck with that!
498 # endif
499 # ifndef GLM_FORCE_PURE
500 # define GLM_FORCE_PURE
501 # endif
502 # endif
503 #endif
504 
505 #if defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_LANG_DISPLAYED)
506 # define GLM_MESSAGE_LANG_DISPLAYED
507 
508 # if GLM_LANG & GLM_LANG_CXX1Z_FLAG
509 # pragma message("GLM: C++1z")
510 # elif GLM_LANG & GLM_LANG_CXX14_FLAG
511 # pragma message("GLM: C++14")
512 # elif GLM_LANG & GLM_LANG_CXX1Y_FLAG
513 # pragma message("GLM: C++1y")
514 # elif GLM_LANG & GLM_LANG_CXX11_FLAG
515 # pragma message("GLM: C++11")
516 # elif GLM_LANG & GLM_LANG_CXX0X_FLAG
517 # pragma message("GLM: C++0x")
518 # elif GLM_LANG & GLM_LANG_CXX03_FLAG
519 # pragma message("GLM: C++03")
520 # elif GLM_LANG & GLM_LANG_CXX98_FLAG
521 # pragma message("GLM: C++98")
522 # else
523 # pragma message("GLM: C++ language undetected")
524 # endif//GLM_LANG
525 
526 # if GLM_LANG & (GLM_LANG_CXXGNU_FLAG | GLM_LANG_CXXMS_FLAG)
527 # pragma message("GLM: Language extensions enabled")
528 # endif//GLM_LANG
529 #endif//GLM_MESSAGE
530 
532 // Has of C++ features
533 
534 // http://clang.llvm.org/cxx_status.html
535 // http://gcc.gnu.org/projects/cxx0x.html
536 // http://msdn.microsoft.com/en-us/library/vstudio/hh567368(v=vs.120).aspx
537 
538 #if GLM_PLATFORM == GLM_PLATFORM_ANDROID
539 # define GLM_HAS_CXX11_STL 0
540 #elif GLM_COMPILER & (GLM_COMPILER_LLVM | GLM_COMPILER_APPLE_CLANG)
541 # if __has_include(<__config>) // libc++
542 # include <__config>
543 //# else // libstdc++
544 //# include <bits/c++config.h>
545 # endif
546 # if defined(_LIBCPP_VERSION)// || defined(__GLIBCXX__)
547 # define GLM_HAS_CXX11_STL 1
548 # else
549 # define GLM_HAS_CXX11_STL 0
550 # endif
551 #else
552 # define GLM_HAS_CXX11_STL ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && \
553  ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC48)) || \
554  ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2013)) || \
555  ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL15)))
556 #endif
557 
558 // N1720
559 #if GLM_COMPILER & (GLM_COMPILER_LLVM | GLM_COMPILER_APPLE_CLANG)
560 # define GLM_HAS_STATIC_ASSERT __has_feature(cxx_static_assert)
561 #elif GLM_LANG & GLM_LANG_CXX11_FLAG
562 # define GLM_HAS_STATIC_ASSERT 1
563 #else
564 # define GLM_HAS_STATIC_ASSERT (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
565  ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC43)) || \
566  ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2010)))
567 #endif
568 
569 // N1988
570 #if GLM_LANG & GLM_LANG_CXX11_FLAG
571 # define GLM_HAS_EXTENDED_INTEGER_TYPE 1
572 #else
573 # define GLM_HAS_EXTENDED_INTEGER_TYPE (\
574  ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2012)) || \
575  ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC43)) || \
576  ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_LLVM) && (GLM_COMPILER >= GLM_COMPILER_LLVM30)) || \
577  ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_APPLE_CLANG) && (GLM_COMPILER >= GLM_COMPILER_APPLE_CLANG40)))
578 #endif
579 
580 // N2235
581 #if GLM_COMPILER & (GLM_COMPILER_LLVM | GLM_COMPILER_APPLE_CLANG)
582 # define GLM_HAS_CONSTEXPR __has_feature(cxx_constexpr)
583 # define GLM_HAS_CONSTEXPR_PARTIAL GLM_HAS_CONSTEXPR
584 #elif GLM_LANG & GLM_LANG_CXX11_FLAG
585 # define GLM_HAS_CONSTEXPR 1
586 # define GLM_HAS_CONSTEXPR_PARTIAL GLM_HAS_CONSTEXPR
587 #else
588 # define GLM_HAS_CONSTEXPR (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
589  ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC46)))
590 # define GLM_HAS_CONSTEXPR_PARTIAL GLM_HAS_CONSTEXPR || ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2015))
591 #endif
592 
593 // N2672
594 #if GLM_COMPILER & (GLM_COMPILER_LLVM | GLM_COMPILER_APPLE_CLANG)
595 # define GLM_HAS_INITIALIZER_LISTS __has_feature(cxx_generalized_initializers)
596 #elif GLM_LANG & GLM_LANG_CXX11_FLAG
597 # define GLM_HAS_INITIALIZER_LISTS 1
598 #else
599 # define GLM_HAS_INITIALIZER_LISTS (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
600  ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC44)) || \
601  ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2013)))
602 #endif
603 
604 // N2544 Unrestricted unions
605 #if GLM_COMPILER & (GLM_COMPILER_LLVM | GLM_COMPILER_APPLE_CLANG)
606 # define GLM_HAS_UNRESTRICTED_UNIONS __has_feature(cxx_unrestricted_unions)
607 #elif GLM_LANG & (GLM_LANG_CXX11_FLAG | GLM_LANG_CXXMS_FLAG)
608 # define GLM_HAS_UNRESTRICTED_UNIONS 1
609 #else
610 # define GLM_HAS_UNRESTRICTED_UNIONS (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
611  ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC46)))
612 #endif
613 
614 // N2346
615 #if GLM_COMPILER & (GLM_COMPILER_LLVM | GLM_COMPILER_APPLE_CLANG)
616 # define GLM_HAS_DEFAULTED_FUNCTIONS __has_feature(cxx_defaulted_functions)
617 #elif GLM_LANG & GLM_LANG_CXX11_FLAG
618 # define GLM_HAS_DEFAULTED_FUNCTIONS 1
619 #else
620 # define GLM_HAS_DEFAULTED_FUNCTIONS (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
621  ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC44)) || \
622  ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2013)) || \
623  ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL12)))
624 #endif
625 
626 // N2118
627 #if GLM_COMPILER & (GLM_COMPILER_LLVM | GLM_COMPILER_APPLE_CLANG)
628 # define GLM_HAS_RVALUE_REFERENCES __has_feature(cxx_rvalue_references)
629 #elif GLM_LANG & GLM_LANG_CXX11_FLAG
630 # define GLM_HAS_RVALUE_REFERENCES 1
631 #else
632 # define GLM_HAS_RVALUE_REFERENCES (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
633  ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC43)) || \
634  ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2012)))
635 #endif
636 
637 // N2437 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf
638 #if GLM_COMPILER & (GLM_COMPILER_LLVM | GLM_COMPILER_APPLE_CLANG)
639 # define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS __has_feature(cxx_explicit_conversions)
640 #elif GLM_LANG & GLM_LANG_CXX11_FLAG
641 # define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS 1
642 #else
643 # define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
644  ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC45)) || \
645  ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL14)) || \
646  ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2013)))
647 #endif
648 
649 // N2258 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf
650 #if GLM_COMPILER & (GLM_COMPILER_LLVM | GLM_COMPILER_APPLE_CLANG)
651 # define GLM_HAS_TEMPLATE_ALIASES __has_feature(cxx_alias_templates)
652 #elif GLM_LANG & GLM_LANG_CXX11_FLAG
653 # define GLM_HAS_TEMPLATE_ALIASES 1
654 #else
655 # define GLM_HAS_TEMPLATE_ALIASES (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
656  ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL12_1)) || \
657  ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC47)) || \
658  ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2013)))
659 #endif
660 
661 // N2930 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2930.html
662 #if GLM_COMPILER & (GLM_COMPILER_LLVM | GLM_COMPILER_APPLE_CLANG)
663 # define GLM_HAS_RANGE_FOR __has_feature(cxx_range_for)
664 #elif GLM_LANG & GLM_LANG_CXX11_FLAG
665 # define GLM_HAS_RANGE_FOR 1
666 #else
667 # define GLM_HAS_RANGE_FOR (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
668  ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC46)) || \
669  ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL13)) || \
670  ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2012)))
671 #endif
672 
673 //
674 #if GLM_LANG & GLM_LANG_CXX11_FLAG
675 # define GLM_HAS_ASSIGNABLE 1
676 #else
677 # define GLM_HAS_ASSIGNABLE (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
678  ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC49)))
679 #endif
680 
681 //
682 #define GLM_HAS_TRIVIAL_QUERIES 0
683 
684 //
685 #if GLM_LANG & GLM_LANG_CXX11_FLAG
686 # define GLM_HAS_MAKE_SIGNED 1
687 #else
688 # define GLM_HAS_MAKE_SIGNED (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
689  ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2013)))
690 #endif
691 
692 //
693 #if GLM_ARCH == GLM_ARCH_PURE
694 # define GLM_HAS_BITSCAN_WINDOWS 0
695 #else
696 # define GLM_HAS_BITSCAN_WINDOWS (GLM_PLATFORM & GLM_PLATFORM_WINDOWS) && (\
697  (GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_LLVM | GLM_COMPILER_INTEL))
698 #endif
699 
700 // OpenMP
701 #ifdef _OPENMP
702 # if GLM_COMPILER & GLM_COMPILER_GCC
703 # if GLM_COMPILER >= GLM_COMPILER_GCC47
704 # define GLM_HAS_OPENMP 31
705 # elif GLM_COMPILER >= GLM_COMPILER_GCC44
706 # define GLM_HAS_OPENMP 30
707 # elif GLM_COMPILER >= GLM_COMPILER_GCC42
708 # define GLM_HAS_OPENMP 25
709 # endif
710 # endif// GLM_COMPILER & GLM_COMPILER_GCC
711 
712 # if GLM_COMPILER & GLM_COMPILER_VC
713 # if GLM_COMPILER >= GLM_COMPILER_VC2010
714 # define GLM_HAS_OPENMP 20
715 # endif
716 # endif// GLM_COMPILER & GLM_COMPILER_VC
717 #endif
718 
719 // Not standard
720 #define GLM_HAS_ANONYMOUS_UNION (GLM_LANG & GLM_LANG_CXXMS_FLAG)
721 
723 // Platform
724 
725 // User defines: GLM_FORCE_PURE GLM_FORCE_SSE2 GLM_FORCE_SSE3 GLM_FORCE_AVX GLM_FORCE_AVX2
726 
727 #define GLM_ARCH_PURE 0x0000
728 #define GLM_ARCH_ARM 0x0001
729 #define GLM_ARCH_X86 0x0002
730 #define GLM_ARCH_SSE2 0x0004
731 #define GLM_ARCH_SSE3 0x0008
732 #define GLM_ARCH_SSE4 0x0010
733 #define GLM_ARCH_AVX 0x0020
734 #define GLM_ARCH_AVX2 0x0040
735 
736 #if defined(GLM_FORCE_PURE)
737 # define GLM_ARCH GLM_ARCH_PURE
738 #elif defined(GLM_FORCE_AVX2)
739 # define GLM_ARCH (GLM_ARCH_AVX2 | GLM_ARCH_AVX | GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
740 #elif defined(GLM_FORCE_AVX)
741 # define GLM_ARCH (GLM_ARCH_AVX | GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
742 #elif defined(GLM_FORCE_SSE4)
743 # define GLM_ARCH (GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
744 #elif defined(GLM_FORCE_SSE3)
745 # define GLM_ARCH (GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
746 #elif defined(GLM_FORCE_SSE2)
747 # define GLM_ARCH (GLM_ARCH_SSE2)
748 #elif (GLM_COMPILER & (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM | GLM_COMPILER_GCC)) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_LINUX))
749 # if(__AVX2__)
750 # define GLM_ARCH (GLM_ARCH_AVX2 | GLM_ARCH_AVX | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
751 # elif(__AVX__)
752 # define GLM_ARCH (GLM_ARCH_AVX | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
753 # elif(__SSE3__)
754 # define GLM_ARCH (GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
755 # elif(__SSE2__)
756 # define GLM_ARCH (GLM_ARCH_SSE2)
757 # else
758 # define GLM_ARCH GLM_ARCH_PURE
759 # endif
760 #elif (GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS))
761 # if defined(_M_ARM_FP)
762 # define GLM_ARCH (GLM_ARCH_ARM)
763 # elif defined(__AVX2__)
764 # define GLM_ARCH (GLM_ARCH_AVX2 | GLM_ARCH_AVX | GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
765 # elif defined(__AVX__)
766 # define GLM_ARCH (GLM_ARCH_AVX | GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
767 # elif _M_IX86_FP == 2
768 # define GLM_ARCH (GLM_ARCH_SSE2)
769 # else
770 # define GLM_ARCH (GLM_ARCH_PURE)
771 # endif
772 #elif (GLM_COMPILER & GLM_COMPILER_GCC) && (defined(__i386__) || defined(__x86_64__))
773 # if defined(__AVX2__)
774 # define GLM_ARCH (GLM_ARCH_AVX2 | GLM_ARCH_AVX | GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
775 # elif defined(__AVX__)
776 # define GLM_ARCH (GLM_ARCH_AVX | GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
777 # elif defined(__SSE4_1__ )
778 # define GLM_ARCH (GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
779 # elif defined(__SSE3__)
780 # define GLM_ARCH (GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
781 # elif defined(__SSE2__)
782 # define GLM_ARCH (GLM_ARCH_SSE2)
783 # else
784 # define GLM_ARCH (GLM_ARCH_PURE)
785 # endif
786 #else
787 # define GLM_ARCH GLM_ARCH_PURE
788 #endif
789 
790 // With MinGW-W64, including intrinsic headers before intrin.h will produce some errors. The problem is
791 // that windows.h (and maybe other headers) will silently include intrin.h, which of course causes problems.
792 // To fix, we just explicitly include intrin.h here.
793 #if defined(__MINGW64__) && (GLM_ARCH != GLM_ARCH_PURE)
794 # include <intrin.h>
795 #endif
796 
797 #if GLM_ARCH & GLM_ARCH_AVX2
798 # include <immintrin.h>
799 #endif//GLM_ARCH
800 #if GLM_ARCH & GLM_ARCH_AVX
801 # include <immintrin.h>
802 #endif//GLM_ARCH
803 #if GLM_ARCH & GLM_ARCH_SSE4
804 # include <smmintrin.h>
805 #endif//GLM_ARCH
806 #if GLM_ARCH & GLM_ARCH_SSE3
807 # include <pmmintrin.h>
808 #endif//GLM_ARCH
809 #if GLM_ARCH & GLM_ARCH_SSE2
810 # include <emmintrin.h>
811 # if(GLM_COMPILER == GLM_COMPILER_VC2005) // VC2005 is missing some intrinsics, workaround
812  inline float _mm_cvtss_f32(__m128 A) { return A.m128_f32[0]; }
813  inline __m128 _mm_castpd_ps(__m128d PD) { union { __m128 ps; __m128d pd; } c; c.pd = PD; return c.ps; }
814  inline __m128d _mm_castps_pd(__m128 PS) { union { __m128 ps; __m128d pd; } c; c.ps = PS; return c.pd; }
815  inline __m128i _mm_castps_si128(__m128 PS) { union { __m128 ps; __m128i pi; } c; c.ps = PS; return c.pi; }
816  inline __m128 _mm_castsi128_ps(__m128i PI) { union { __m128 ps; __m128i pi; } c; c.pi = PI; return c.ps; }
817 # endif
818 #endif//GLM_ARCH
819 
820 #if defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_ARCH_DISPLAYED)
821 # define GLM_MESSAGE_ARCH_DISPLAYED
822 # if(GLM_ARCH == GLM_ARCH_PURE)
823 # pragma message("GLM: Platform independent code")
824 # elif(GLM_ARCH & GLM_ARCH_ARM)
825 # pragma message("GLM: ARM instruction set")
826 # elif(GLM_ARCH & GLM_ARCH_AVX2)
827 # pragma message("GLM: AVX2 instruction set")
828 # elif(GLM_ARCH & GLM_ARCH_AVX)
829 # pragma message("GLM: AVX instruction set")
830 # elif(GLM_ARCH & GLM_ARCH_SSE3)
831 # pragma message("GLM: SSE3 instruction set")
832 # elif(GLM_ARCH & GLM_ARCH_SSE2)
833 # pragma message("GLM: SSE2 instruction set")
834 # endif//GLM_ARCH
835 #endif//GLM_MESSAGE
836 
838 // Static assert
839 
840 #if GLM_HAS_STATIC_ASSERT
841 # define GLM_STATIC_ASSERT(x, message) static_assert(x, message)
842 #elif defined(BOOST_STATIC_ASSERT)
843 # define GLM_STATIC_ASSERT(x, message) BOOST_STATIC_ASSERT(x)
844 #elif GLM_COMPILER & GLM_COMPILER_VC
845 # define GLM_STATIC_ASSERT(x, message) typedef char __CASSERT__##__LINE__[(x) ? 1 : -1]
846 #else
847 # define GLM_STATIC_ASSERT(x, message)
848 # define GLM_STATIC_ASSERT_NULL
849 #endif//GLM_LANG
850 
852 // Qualifiers
853 
854 #if GLM_COMPILER & GLM_COMPILER_CUDA
855 # define GLM_CUDA_FUNC_DEF __device__ __host__
856 # define GLM_CUDA_FUNC_DECL __device__ __host__
857 #else
858 # define GLM_CUDA_FUNC_DEF
859 # define GLM_CUDA_FUNC_DECL
860 #endif
861 
862 #if GLM_COMPILER & GLM_COMPILER_GCC
863 # define GLM_VAR_USED __attribute__ ((unused))
864 #else
865 # define GLM_VAR_USED
866 #endif
867 
868 #if defined(GLM_FORCE_INLINE)
869 # if GLM_COMPILER & GLM_COMPILER_VC
870 # define GLM_INLINE __forceinline
871 # define GLM_NEVER_INLINE __declspec((noinline))
872 # elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM)
873 # define GLM_INLINE inline __attribute__((__always_inline__))
874 # define GLM_NEVER_INLINE __attribute__((__noinline__))
875 # else
876 # define GLM_INLINE inline
877 # define GLM_NEVER_INLINE
878 # endif//GLM_COMPILER
879 #else
880 # define GLM_INLINE inline
881 # define GLM_NEVER_INLINE
882 #endif//defined(GLM_FORCE_INLINE)
883 
884 #define GLM_FUNC_DECL GLM_CUDA_FUNC_DECL
885 #define GLM_FUNC_QUALIFIER GLM_CUDA_FUNC_DEF GLM_INLINE
886 
888 // Swizzle operators
889 
890 // User defines: GLM_SWIZZLE
891 
892 #if defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_SWIZZLE_DISPLAYED)
893 # define GLM_MESSAGE_SWIZZLE_DISPLAYED
894 # if defined(GLM_SWIZZLE)
895 # pragma message("GLM: Swizzling operators enabled")
896 # else
897 # pragma message("GLM: Swizzling operators disabled, #define GLM_SWIZZLE to enable swizzle operators")
898 # endif
899 #endif//GLM_MESSAGE
900 
902 // Qualifiers
903 
904 #if (GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS))
905 # define GLM_DEPRECATED __declspec(deprecated)
906 # define GLM_ALIGN(x) __declspec(align(x))
907 # define GLM_ALIGNED_STRUCT(x) struct __declspec(align(x))
908 # define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef __declspec(align(alignment)) type name
909 # define GLM_RESTRICT __declspec(restrict)
910 # define GLM_RESTRICT_VAR __restrict
911 #elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM | GLM_COMPILER_CUDA | GLM_COMPILER_INTEL)
912 # define GLM_DEPRECATED __attribute__((__deprecated__))
913 # define GLM_ALIGN(x) __attribute__((aligned(x)))
914 # define GLM_ALIGNED_STRUCT(x) struct __attribute__((aligned(x)))
915 # define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef type name __attribute__((aligned(alignment)))
916 # define GLM_RESTRICT __restrict__
917 # define GLM_RESTRICT_VAR __restrict__
918 #else
919 # define GLM_DEPRECATED
920 # define GLM_ALIGN
921 # define GLM_ALIGNED_STRUCT(x) struct
922 # define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef type name
923 # define GLM_RESTRICT
924 # define GLM_RESTRICT_VAR
925 #endif//GLM_COMPILER
926 
927 #if GLM_HAS_DEFAULTED_FUNCTIONS
928 # define GLM_DEFAULT = default
929 # ifdef GLM_FORCE_NO_CTOR_INIT
930 # define GLM_DEFAULT_CTOR = default
931 # else
932 # define GLM_DEFAULT_CTOR
933 # endif
934 #else
935 # define GLM_DEFAULT
936 # define GLM_DEFAULT_CTOR
937 #endif
938 
939 #if GLM_HAS_CONSTEXPR
940 # define GLM_CONSTEXPR constexpr
941 # define GLM_RELAXED_CONSTEXPR constexpr
942 #else
943 # define GLM_CONSTEXPR
944 # define GLM_RELAXED_CONSTEXPR const
945 #endif
946 
947 #ifdef GLM_FORCE_EXPLICIT_CTOR
948 # define GLM_EXPLICIT explicit
949 #else
950 # define GLM_EXPLICIT
951 #endif
952 
954 // Length type
955 
956 // User defines: GLM_FORCE_SIZE_T_LENGTH GLM_FORCE_SIZE_FUNC
957 
958 namespace glm
959 {
960  using std::size_t;
961 # if defined(GLM_FORCE_SIZE_T_LENGTH) || defined(GLM_FORCE_SIZE_FUNC)
962  typedef size_t length_t;
963 # else
964  typedef int length_t;
965 # endif
966 
967 namespace detail
968 {
969 # ifdef GLM_FORCE_SIZE_FUNC
970  typedef size_t component_count_t;
971 # else
972  typedef length_t component_count_t;
973 # endif
974 
975  template <typename genType>
976  GLM_FUNC_QUALIFIER GLM_CONSTEXPR component_count_t component_count(genType const & m)
977  {
978 # ifdef GLM_FORCE_SIZE_FUNC
979  return m.size();
980 # else
981  return m.length();
982 # endif
983  }
984 }//namespace detail
985 }//namespace glm
986 
987 #if defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_FORCE_SIZE_T_LENGTH)
988 # define GLM_MESSAGE_FORCE_SIZE_T_LENGTH
989 # if defined GLM_FORCE_SIZE_FUNC
990 # pragma message("GLM: .length() is replaced by .size() and returns a std::size_t")
991 # elif defined GLM_FORCE_SIZE_T_LENGTH
992 # pragma message("GLM: .length() returns glm::length_t, a typedef of std::size_t")
993 # else
994 # pragma message("GLM: .length() returns glm::length_t, a typedef of int following the GLSL specification")
995 # endif
996 #endif//GLM_MESSAGE
997 
999 // countof
1000 
1001 #ifndef __has_feature
1002 # define __has_feature(x) 0 // Compatibility with non-clang compilers.
1003 #endif
1004 
1005 #if GLM_HAS_CONSTEXPR_PARTIAL
1006  namespace glm
1007  {
1008  template <typename T, std::size_t N>
1009  constexpr std::size_t countof(T const (&)[N])
1010  {
1011  return N;
1012  }
1013  }//namespace glm
1014 # define GLM_COUNTOF(arr) glm::countof(arr)
1015 #elif _MSC_VER
1016 # define GLM_COUNTOF(arr) _countof(arr)
1017 #else
1018 # define GLM_COUNTOF(arr) sizeof(arr) / sizeof(arr[0])
1019 #endif
1020 
1022 // Uninitialize constructors
1023 
1024 namespace glm
1025 {
1026  enum ctor{uninitialize};
1027 }//namespace glm
glm
Definition: _noise.hpp:40
glm::pi
GLM_FUNC_DECL genType pi()
Return the pi constant.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00106.html000066400000000000000000000107051356361734700216440ustar00rootroot00000000000000 0.9.7: simd_mat4.hpp File Reference
simd_mat4.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_simd_mat4

Date
2009-05-07 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file simd_mat4.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00106_source.html000066400000000000000000000706501356361734700232310ustar00rootroot00000000000000 0.9.7: simd_mat4.hpp Source File
simd_mat4.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependencies
45 #include "../detail/setup.hpp"
46 
47 #if(GLM_ARCH != GLM_ARCH_PURE)
48 
49 #if(GLM_ARCH & GLM_ARCH_SSE2)
50 # include "../detail/intrinsic_matrix.hpp"
51 # include "../gtx/simd_vec4.hpp"
52 #else
53 # error "GLM: GLM_GTX_simd_mat4 requires compiler support of SSE2 through intrinsics"
54 #endif
55 
56 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
57 # pragma message("GLM: GLM_GTX_simd_mat4 extension included")
58 #endif
59 
60 namespace glm{
61 namespace detail
62 {
65  GLM_ALIGNED_STRUCT(16) fmat4x4SIMD
66  {
67  typedef float value_type;
68  typedef fvec4SIMD col_type;
69  typedef fvec4SIMD row_type;
70  typedef std::size_t size_type;
71  typedef fmat4x4SIMD type;
72  typedef fmat4x4SIMD transpose_type;
73 
74  typedef tmat4x4<float, defaultp> pure_type;
75  typedef tvec4<float, defaultp> pure_row_type;
76  typedef tvec4<float, defaultp> pure_col_type;
77  typedef tmat4x4<float, defaultp> pure_transpose_type;
78 
79 # ifdef GLM_META_PROG_HELPERS
80  static GLM_RELAXED_CONSTEXPR length_t components = 4;
81  static GLM_RELAXED_CONSTEXPR length_t cols = 4;
82  static GLM_RELAXED_CONSTEXPR length_t rows = 4;
83  static GLM_RELAXED_CONSTEXPR precision prec = defaultp;
84 # endif//GLM_META_PROG_HELPERS
85 
86  GLM_FUNC_DECL length_t length() const;
87 
88  fvec4SIMD Data[4];
89 
91  // Constructors
92 
93  fmat4x4SIMD() GLM_DEFAULT_CTOR;
94  explicit fmat4x4SIMD(float const & s);
95  explicit fmat4x4SIMD(
96  float const & x0, float const & y0, float const & z0, float const & w0,
97  float const & x1, float const & y1, float const & z1, float const & w1,
98  float const & x2, float const & y2, float const & z2, float const & w2,
99  float const & x3, float const & y3, float const & z3, float const & w3);
100  explicit fmat4x4SIMD(
101  fvec4SIMD const & v0,
102  fvec4SIMD const & v1,
103  fvec4SIMD const & v2,
104  fvec4SIMD const & v3);
105  explicit fmat4x4SIMD(
106  mat4x4 const & m);
107  explicit fmat4x4SIMD(
108  __m128 const in[4]);
109 
110  // Conversions
111  //template <typename U>
112  //explicit tmat4x4(tmat4x4<U> const & m);
113 
114  //explicit tmat4x4(tmat2x2<T> const & x);
115  //explicit tmat4x4(tmat3x3<T> const & x);
116  //explicit tmat4x4(tmat2x3<T> const & x);
117  //explicit tmat4x4(tmat3x2<T> const & x);
118  //explicit tmat4x4(tmat2x4<T> const & x);
119  //explicit tmat4x4(tmat4x2<T> const & x);
120  //explicit tmat4x4(tmat3x4<T> const & x);
121  //explicit tmat4x4(tmat4x3<T> const & x);
122 
123  // Accesses
124  fvec4SIMD & operator[](length_t i);
125  fvec4SIMD const & operator[](length_t i) const;
126 
127  // Unary updatable operators
128  fmat4x4SIMD & operator= (fmat4x4SIMD const & m) GLM_DEFAULT;
129  fmat4x4SIMD & operator+= (float const & s);
130  fmat4x4SIMD & operator+= (fmat4x4SIMD const & m);
131  fmat4x4SIMD & operator-= (float const & s);
132  fmat4x4SIMD & operator-= (fmat4x4SIMD const & m);
133  fmat4x4SIMD & operator*= (float const & s);
134  fmat4x4SIMD & operator*= (fmat4x4SIMD const & m);
135  fmat4x4SIMD & operator/= (float const & s);
136  fmat4x4SIMD & operator/= (fmat4x4SIMD const & m);
137  fmat4x4SIMD & operator++ ();
138  fmat4x4SIMD & operator-- ();
139  };
140 
141  // Binary operators
142  fmat4x4SIMD operator+ (fmat4x4SIMD const & m, float const & s);
143  fmat4x4SIMD operator+ (float const & s, fmat4x4SIMD const & m);
144  fmat4x4SIMD operator+ (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
145 
146  fmat4x4SIMD operator- (fmat4x4SIMD const & m, float const & s);
147  fmat4x4SIMD operator- (float const & s, fmat4x4SIMD const & m);
148  fmat4x4SIMD operator- (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
149 
150  fmat4x4SIMD operator* (fmat4x4SIMD const & m, float const & s);
151  fmat4x4SIMD operator* (float const & s, fmat4x4SIMD const & m);
152 
153  fvec4SIMD operator* (fmat4x4SIMD const & m, fvec4SIMD const & v);
154  fvec4SIMD operator* (fvec4SIMD const & v, fmat4x4SIMD const & m);
155 
156  fmat4x4SIMD operator* (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
157 
158  fmat4x4SIMD operator/ (fmat4x4SIMD const & m, float const & s);
159  fmat4x4SIMD operator/ (float const & s, fmat4x4SIMD const & m);
160 
161  fvec4SIMD operator/ (fmat4x4SIMD const & m, fvec4SIMD const & v);
162  fvec4SIMD operator/ (fvec4SIMD const & v, fmat4x4SIMD const & m);
163 
164  fmat4x4SIMD operator/ (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
165 
166  // Unary constant operators
167  fmat4x4SIMD const operator- (fmat4x4SIMD const & m);
168  fmat4x4SIMD const operator-- (fmat4x4SIMD const & m, int);
169  fmat4x4SIMD const operator++ (fmat4x4SIMD const & m, int);
170 }//namespace detail
171 
172  typedef detail::fmat4x4SIMD simdMat4;
173 
176 
179  mat4 mat4_cast(
180  detail::fmat4x4SIMD const & x);
181 
185  detail::fmat4x4SIMD matrixCompMult(
186  detail::fmat4x4SIMD const & x,
187  detail::fmat4x4SIMD const & y);
188 
193  detail::fmat4x4SIMD outerProduct(
194  detail::fvec4SIMD const & c,
195  detail::fvec4SIMD const & r);
196 
199  detail::fmat4x4SIMD transpose(
200  detail::fmat4x4SIMD const & x);
201 
204  float determinant(
205  detail::fmat4x4SIMD const & m);
206 
209  detail::fmat4x4SIMD inverse(
210  detail::fmat4x4SIMD const & m);
211 
213 }// namespace glm
214 
215 #include "simd_mat4.inl"
216 
217 #endif//(GLM_ARCH != GLM_ARCH_PURE)
glm::determinant
GLM_FUNC_DECL T determinant(matType< T, P > const &m)
Returns the transposed matrix of x.
glm::length
GLM_FUNC_DECL T length(vecType< T, P > const &x)
Returns the length of x, i.e., sqrt(x * x).
glm::mat4_cast
GLM_FUNC_DECL tmat4x4< T, P > mat4_cast(tquat< T, P > const &x)
Converts a quaternion to a 4 * 4 matrix.
glm::mat4x4
highp_mat4x4 mat4x4
4 columns of 4 components matrix of floating-point numbers.
Definition: type_mat.hpp:425
glm
Definition: _noise.hpp:40
glm::inverse
GLM_FUNC_DECL matType< T, P > inverse(matType< T, P > const &m)
Return the inverse of a squared matrix.
glm::mat4
mat4x4 mat4
4 columns of 4 components matrix of floating-point numbers.
Definition: type_mat.hpp:442
glm::outerProduct
GLM_FUNC_DECL detail::outerProduct_trait< T, P, vecTypeA, vecTypeB >::type outerProduct(vecTypeA< T, P > const &c, vecTypeB< T, P > const &r)
Treats the first parameter c as a column vector and the second parameter r as a row vector and does a...
glm::matrixCompMult
GLM_FUNC_DECL matType< T, P > matrixCompMult(matType< T, P > const &x, matType< T, P > const &y)
Multiply matrix x by matrix y component-wise, i.e., result[i][j] is the scalar product of x[i][j] and...
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00107.html000066400000000000000000000107051356361734700216450ustar00rootroot00000000000000 0.9.7: simd_quat.hpp File Reference
simd_quat.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_simd_quat

Date
2013-04-22 / 2014-11-25
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file simd_quat.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00107_source.html000066400000000000000000001070611356361734700232270ustar00rootroot00000000000000 0.9.7: simd_quat.hpp Source File
simd_quat.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../glm.hpp"
46 #include "../gtc/quaternion.hpp"
47 #include "../gtx/fast_trigonometry.hpp"
48 
49 #if(GLM_ARCH != GLM_ARCH_PURE)
50 
51 #if(GLM_ARCH & GLM_ARCH_SSE2)
52 # include "../gtx/simd_mat4.hpp"
53 #else
54 # error "GLM: GLM_GTX_simd_quat requires compiler support of SSE2 through intrinsics"
55 #endif
56 
57 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
58 # pragma message("GLM: GLM_GTX_simd_quat extension included")
59 #endif
60 
61 // Warning silencer for nameless struct/union.
62 #if (GLM_COMPILER & GLM_COMPILER_VC)
63 # pragma warning(push)
64 # pragma warning(disable:4201) // warning C4201: nonstandard extension used : nameless struct/union
65 #endif
66 
67 namespace glm{
68 namespace detail
69 {
70  GLM_ALIGNED_STRUCT(16) fquatSIMD
71  {
72  typedef float value_type;
73  typedef std::size_t size_type;
74 
75  typedef fquatSIMD type;
76  typedef tquat<bool, defaultp> bool_type;
77  typedef tquat<float, defaultp> pure_type;
78 
79 # ifdef GLM_META_PROG_HELPERS
80  static GLM_RELAXED_CONSTEXPR length_t components = 4;
81  static GLM_RELAXED_CONSTEXPR precision prec = defaultp;
82 # endif//GLM_META_PROG_HELPERS
83 
84 #ifdef GLM_SIMD_ENABLE_XYZW_UNION
85  union
86  {
87  __m128 Data;
88  struct {float x, y, z, w;};
89  };
90 #else
91  __m128 Data;
92 #endif
93 
95  // Implicit basic constructors
96 
97  fquatSIMD() GLM_DEFAULT_CTOR;
98  fquatSIMD(fquatSIMD const & q) GLM_DEFAULT;
99  fquatSIMD(__m128 const & Data);
100 
102  // Explicit basic constructors
103 
104  explicit fquatSIMD(
105  ctor);
106  explicit fquatSIMD(
107  float const & w,
108  float const & x,
109  float const & y,
110  float const & z);
111  explicit fquatSIMD(
112  quat const & v);
113  explicit fquatSIMD(
114  vec3 const & eulerAngles);
115 
116 
118  // Unary arithmetic operators
119 
120  fquatSIMD& operator= (fquatSIMD const & q) GLM_DEFAULT;
121  fquatSIMD& operator*=(float const & s);
122  fquatSIMD& operator/=(float const & s);
123  };
124 
125 
127  // Arithmetic operators
128 
129  detail::fquatSIMD operator- (
130  detail::fquatSIMD const & q);
131 
132  detail::fquatSIMD operator+ (
133  detail::fquatSIMD const & q,
134  detail::fquatSIMD const & p);
135 
136  detail::fquatSIMD operator* (
137  detail::fquatSIMD const & q,
138  detail::fquatSIMD const & p);
139 
140  detail::fvec4SIMD operator* (
141  detail::fquatSIMD const & q,
142  detail::fvec4SIMD const & v);
143 
144  detail::fvec4SIMD operator* (
145  detail::fvec4SIMD const & v,
146  detail::fquatSIMD const & q);
147 
148  detail::fquatSIMD operator* (
149  detail::fquatSIMD const & q,
150  float s);
151 
152  detail::fquatSIMD operator* (
153  float s,
154  detail::fquatSIMD const & q);
155 
156  detail::fquatSIMD operator/ (
157  detail::fquatSIMD const & q,
158  float s);
159 
160 }//namespace detail
161 
164 
165  typedef glm::detail::fquatSIMD simdQuat;
166 
169  quat quat_cast(
170  detail::fquatSIMD const & x);
171 
174  detail::fquatSIMD quatSIMD_cast(
175  detail::fmat4x4SIMD const & m);
176 
179  template <typename T, precision P>
180  detail::fquatSIMD quatSIMD_cast(
181  tmat4x4<T, P> const & m);
182 
185  template <typename T, precision P>
186  detail::fquatSIMD quatSIMD_cast(
187  tmat3x3<T, P> const & m);
188 
191  detail::fmat4x4SIMD mat4SIMD_cast(
192  detail::fquatSIMD const & q);
193 
196  mat4 mat4_cast(
197  detail::fquatSIMD const & q);
198 
199 
203  float length(
204  detail::fquatSIMD const & x);
205 
209  detail::fquatSIMD normalize(
210  detail::fquatSIMD const & x);
211 
215  float dot(
216  detail::fquatSIMD const & q1,
217  detail::fquatSIMD const & q2);
218 
229  detail::fquatSIMD mix(
230  detail::fquatSIMD const & x,
231  detail::fquatSIMD const & y,
232  float const & a);
233 
242  detail::fquatSIMD lerp(
243  detail::fquatSIMD const & x,
244  detail::fquatSIMD const & y,
245  float const & a);
246 
255  detail::fquatSIMD slerp(
256  detail::fquatSIMD const & x,
257  detail::fquatSIMD const & y,
258  float const & a);
259 
260 
271  detail::fquatSIMD fastMix(
272  detail::fquatSIMD const & x,
273  detail::fquatSIMD const & y,
274  float const & a);
275 
283  detail::fquatSIMD fastSlerp(
284  detail::fquatSIMD const & x,
285  detail::fquatSIMD const & y,
286  float const & a);
287 
288 
292  detail::fquatSIMD conjugate(
293  detail::fquatSIMD const & q);
294 
298  detail::fquatSIMD inverse(
299  detail::fquatSIMD const & q);
300 
307  detail::fquatSIMD angleAxisSIMD(
308  float const & angle,
309  vec3 const & axis);
310 
319  detail::fquatSIMD angleAxisSIMD(
320  float const & angle,
321  float const & x,
322  float const & y,
323  float const & z);
324 
325  // TODO: Move this to somewhere more appropriate. Used with fastMix() and fastSlerp().
327  __m128 fastSin(__m128 x);
328 
330 }//namespace glm
331 
332 #include "simd_quat.inl"
333 
334 
335 #if (GLM_COMPILER & GLM_COMPILER_VC)
336 # pragma warning(pop)
337 #endif
338 
339 
340 #endif//(GLM_ARCH != GLM_ARCH_PURE)
glm::fastMix
GLM_FUNC_DECL tquat< T, P > fastMix(tquat< T, P > const &x, tquat< T, P > const &y, T const &a)
Quaternion normalized linear interpolation.
glm::length
GLM_FUNC_DECL T length(vecType< T, P > const &x)
Returns the length of x, i.e., sqrt(x * x).
glm::conjugate
GLM_FUNC_DECL tquat< T, P > conjugate(tquat< T, P > const &q)
Returns the q conjugate.
glm::mat4_cast
GLM_FUNC_DECL tmat4x4< T, P > mat4_cast(tquat< T, P > const &x)
Converts a quaternion to a 4 * 4 matrix.
glm::lerp
GLM_FUNC_DECL tquat< T, P > lerp(tquat< T, P > const &x, tquat< T, P > const &y, T a)
Linear interpolation of two quaternions.
glm::normalize
GLM_FUNC_DECL vecType< T, P > normalize(vecType< T, P > const &x)
Returns a vector in the same direction as x but with length of 1.
glm::axis
GLM_FUNC_DECL tvec3< T, P > axis(tquat< T, P > const &x)
Returns the q rotation axis.
glm
Definition: _noise.hpp:40
glm::eulerAngles
GLM_FUNC_DECL tvec3< T, P > eulerAngles(tquat< T, P > const &x)
Returns euler angles, yitch as x, yaw as y, roll as z.
glm::angle
GLM_FUNC_DECL T angle(tquat< T, P > const &x)
Returns the quaternion rotation angle.
glm::vec3
highp_vec3 vec3
3 components vector of floating-point numbers.
Definition: type_vec.hpp:395
glm::inverse
GLM_FUNC_DECL matType< T, P > inverse(matType< T, P > const &m)
Return the inverse of a squared matrix.
glm::fastSin
GLM_FUNC_DECL T fastSin(T angle)
Faster than the common sin function but less accurate.
glm::quat_cast
GLM_FUNC_DECL tquat< T, P > quat_cast(tmat3x3< T, P > const &x)
Converts a 3 * 3 matrix to a quaternion.
glm::slerp
GLM_FUNC_DECL tquat< T, P > slerp(tquat< T, P > const &x, tquat< T, P > const &y, T a)
Spherical linear interpolation of two quaternions.
glm::dot
GLM_FUNC_DECL T dot(vecType< T, P > const &x, vecType< T, P > const &y)
Returns the dot product of x and y, i.e., result = x * y.
glm::mix
GLM_FUNC_DECL vecType< T, P > mix(vecType< T, P > const &x, vecType< T, P > const &y, vecType< U, P > const &a)
If genTypeU is a floating scalar or vector: Returns x * (1.0 - a) + y * a, i.e., the linear blend of ...
glm::mat4
mat4x4 mat4
4 columns of 4 components matrix of floating-point numbers.
Definition: type_mat.hpp:442
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00108.html000066400000000000000000000107051356361734700216460ustar00rootroot00000000000000 0.9.7: simd_vec4.hpp File Reference
simd_vec4.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_simd_vec4

Date
2009-05-07 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file simd_vec4.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00108_source.html000066400000000000000000001560461356361734700232370ustar00rootroot00000000000000 0.9.7: simd_vec4.hpp Source File
simd_vec4.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../glm.hpp"
46 
47 #if(GLM_ARCH != GLM_ARCH_PURE)
48 
49 #if(GLM_ARCH & GLM_ARCH_SSE2)
50 # include "../detail/intrinsic_common.hpp"
51 # include "../detail/intrinsic_geometric.hpp"
52 # include "../detail/intrinsic_integer.hpp"
53 #else
54 # error "GLM: GLM_GTX_simd_vec4 requires compiler support of SSE2 through intrinsics"
55 #endif
56 
57 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
58 # pragma message("GLM: GLM_GTX_simd_vec4 extension included")
59 #endif
60 
61 
62 // Warning silencer for nameless struct/union.
63 #if (GLM_COMPILER & GLM_COMPILER_VC)
64 # pragma warning(push)
65 # pragma warning(disable:4201) // warning C4201: nonstandard extension used : nameless struct/union
66 #endif
67 
68 namespace glm
69 {
70  enum comp
71  {
72  X = 0,
73  R = 0,
74  S = 0,
75  Y = 1,
76  G = 1,
77  T = 1,
78  Z = 2,
79  B = 2,
80  P = 2,
81  W = 3,
82  A = 3,
83  Q = 3
84  };
85 
86 }//namespace glm
87 
88 namespace glm{
89 namespace detail
90 {
93  GLM_ALIGNED_STRUCT(16) fvec4SIMD
94  {
95  typedef float value_type;
96  typedef std::size_t size_type;
97 
98  typedef fvec4SIMD type;
99  typedef tvec4<float, defaultp> pure_type;
100  typedef tvec4<bool, highp> bool_type;
101 
102 # ifdef GLM_META_PROG_HELPERS
103  static GLM_RELAXED_CONSTEXPR length_t components = 4;
104  static GLM_RELAXED_CONSTEXPR precision prec = defaultp;
105 # endif//GLM_META_PROG_HELPERS
106 
107 #ifdef GLM_SIMD_ENABLE_XYZW_UNION
108  union
109  {
110  __m128 Data;
111  struct {float x, y, z, w;};
112  };
113 #else
114  __m128 Data;
115 #endif
116 
118  // Implicit basic constructors
119 
120  fvec4SIMD() GLM_DEFAULT_CTOR;
121  fvec4SIMD(fvec4SIMD const & v) GLM_DEFAULT;
122  fvec4SIMD(__m128 const & Data);
123 
125  // Explicit basic constructors
126 
127  explicit fvec4SIMD(
128  ctor);
129  explicit fvec4SIMD(
130  float const & s);
131  explicit fvec4SIMD(
132  float const & x,
133  float const & y,
134  float const & z,
135  float const & w);
136  explicit fvec4SIMD(
137  vec4 const & v);
138 
141 
142  fvec4SIMD(vec2 const & v, float const & s1, float const & s2);
143  fvec4SIMD(float const & s1, vec2 const & v, float const & s2);
144  fvec4SIMD(float const & s1, float const & s2, vec2 const & v);
145  fvec4SIMD(vec3 const & v, float const & s);
146  fvec4SIMD(float const & s, vec3 const & v);
147  fvec4SIMD(vec2 const & v1, vec2 const & v2);
148  //fvec4SIMD(ivec4SIMD const & v);
149 
151  // Unary arithmetic operators
152 
153  fvec4SIMD& operator= (fvec4SIMD const & v) GLM_DEFAULT;
154  fvec4SIMD& operator+=(fvec4SIMD const & v);
155  fvec4SIMD& operator-=(fvec4SIMD const & v);
156  fvec4SIMD& operator*=(fvec4SIMD const & v);
157  fvec4SIMD& operator/=(fvec4SIMD const & v);
158 
159  fvec4SIMD& operator+=(float const & s);
160  fvec4SIMD& operator-=(float const & s);
161  fvec4SIMD& operator*=(float const & s);
162  fvec4SIMD& operator/=(float const & s);
163 
164  fvec4SIMD& operator++();
165  fvec4SIMD& operator--();
166 
168  // Swizzle operators
169 
170  template <comp X, comp Y, comp Z, comp W>
171  fvec4SIMD& swizzle();
172  template <comp X, comp Y, comp Z, comp W>
173  fvec4SIMD swizzle() const;
174  template <comp X, comp Y, comp Z>
175  fvec4SIMD swizzle() const;
176  template <comp X, comp Y>
177  fvec4SIMD swizzle() const;
178  template <comp X>
179  fvec4SIMD swizzle() const;
180  };
181 }//namespace detail
182 
183  typedef glm::detail::fvec4SIMD simdVec4;
184 
187 
190  vec4 vec4_cast(
191  detail::fvec4SIMD const & x);
192 
195  detail::fvec4SIMD abs(detail::fvec4SIMD const & x);
196 
199  detail::fvec4SIMD sign(detail::fvec4SIMD const & x);
200 
203  detail::fvec4SIMD floor(detail::fvec4SIMD const & x);
204 
208  detail::fvec4SIMD trunc(detail::fvec4SIMD const & x);
209 
217  detail::fvec4SIMD round(detail::fvec4SIMD const & x);
218 
224  //detail::fvec4SIMD roundEven(detail::fvec4SIMD const & x);
225 
229  detail::fvec4SIMD ceil(detail::fvec4SIMD const & x);
230 
234  detail::fvec4SIMD fract(detail::fvec4SIMD const & x);
235 
240  detail::fvec4SIMD mod(
241  detail::fvec4SIMD const & x,
242  detail::fvec4SIMD const & y);
243 
248  detail::fvec4SIMD mod(
249  detail::fvec4SIMD const & x,
250  float const & y);
251 
257  //detail::fvec4SIMD modf(
258  // detail::fvec4SIMD const & x,
259  // detail::fvec4SIMD & i);
260 
264  detail::fvec4SIMD min(
265  detail::fvec4SIMD const & x,
266  detail::fvec4SIMD const & y);
267 
268  detail::fvec4SIMD min(
269  detail::fvec4SIMD const & x,
270  float const & y);
271 
275  detail::fvec4SIMD max(
276  detail::fvec4SIMD const & x,
277  detail::fvec4SIMD const & y);
278 
279  detail::fvec4SIMD max(
280  detail::fvec4SIMD const & x,
281  float const & y);
282 
287  detail::fvec4SIMD clamp(
288  detail::fvec4SIMD const & x,
289  detail::fvec4SIMD const & minVal,
290  detail::fvec4SIMD const & maxVal);
291 
292  detail::fvec4SIMD clamp(
293  detail::fvec4SIMD const & x,
294  float const & minVal,
295  float const & maxVal);
296 
323  detail::fvec4SIMD mix(
324  detail::fvec4SIMD const & x,
325  detail::fvec4SIMD const & y,
326  detail::fvec4SIMD const & a);
327 
331  detail::fvec4SIMD step(
332  detail::fvec4SIMD const & edge,
333  detail::fvec4SIMD const & x);
334 
335  detail::fvec4SIMD step(
336  float const & edge,
337  detail::fvec4SIMD const & x);
338 
350  detail::fvec4SIMD smoothstep(
351  detail::fvec4SIMD const & edge0,
352  detail::fvec4SIMD const & edge1,
353  detail::fvec4SIMD const & x);
354 
355  detail::fvec4SIMD smoothstep(
356  float const & edge0,
357  float const & edge1,
358  detail::fvec4SIMD const & x);
359 
367  //bvec4 isnan(detail::fvec4SIMD const & x);
368 
376  //bvec4 isinf(detail::fvec4SIMD const & x);
377 
383  //detail::ivec4SIMD floatBitsToInt(detail::fvec4SIMD const & value);
384 
392  //detail::fvec4SIMD intBitsToFloat(detail::ivec4SIMD const & value);
393 
397  detail::fvec4SIMD fma(
398  detail::fvec4SIMD const & a,
399  detail::fvec4SIMD const & b,
400  detail::fvec4SIMD const & c);
401 
412  //detail::fvec4SIMD frexp(detail::fvec4SIMD const & x, detail::ivec4SIMD & exp);
413 
421  //detail::fvec4SIMD ldexp(detail::fvec4SIMD const & x, detail::ivec4SIMD const & exp);
422 
426  float length(
427  detail::fvec4SIMD const & x);
428 
433  float fastLength(
434  detail::fvec4SIMD const & x);
435 
440  float niceLength(
441  detail::fvec4SIMD const & x);
442 
446  detail::fvec4SIMD length4(
447  detail::fvec4SIMD const & x);
448 
453  detail::fvec4SIMD fastLength4(
454  detail::fvec4SIMD const & x);
455 
460  detail::fvec4SIMD niceLength4(
461  detail::fvec4SIMD const & x);
462 
466  float distance(
467  detail::fvec4SIMD const & p0,
468  detail::fvec4SIMD const & p1);
469 
473  detail::fvec4SIMD distance4(
474  detail::fvec4SIMD const & p0,
475  detail::fvec4SIMD const & p1);
476 
480  float simdDot(
481  detail::fvec4SIMD const & x,
482  detail::fvec4SIMD const & y);
483 
487  detail::fvec4SIMD dot4(
488  detail::fvec4SIMD const & x,
489  detail::fvec4SIMD const & y);
490 
494  detail::fvec4SIMD cross(
495  detail::fvec4SIMD const & x,
496  detail::fvec4SIMD const & y);
497 
501  detail::fvec4SIMD normalize(
502  detail::fvec4SIMD const & x);
503 
508  detail::fvec4SIMD fastNormalize(
509  detail::fvec4SIMD const & x);
510 
514  detail::fvec4SIMD simdFaceforward(
515  detail::fvec4SIMD const & N,
516  detail::fvec4SIMD const & I,
517  detail::fvec4SIMD const & Nref);
518 
523  detail::fvec4SIMD reflect(
524  detail::fvec4SIMD const & I,
525  detail::fvec4SIMD const & N);
526 
532  detail::fvec4SIMD refract(
533  detail::fvec4SIMD const & I,
534  detail::fvec4SIMD const & N,
535  float const & eta);
536 
540  detail::fvec4SIMD sqrt(
541  detail::fvec4SIMD const & x);
542 
547  detail::fvec4SIMD niceSqrt(
548  detail::fvec4SIMD const & x);
549 
554  detail::fvec4SIMD fastSqrt(
555  detail::fvec4SIMD const & x);
556 
560  detail::fvec4SIMD inversesqrt(
561  detail::fvec4SIMD const & x);
562 
567  detail::fvec4SIMD fastInversesqrt(
568  detail::fvec4SIMD const & x);
569 
571 }//namespace glm
572 
573 #include "simd_vec4.inl"
574 
575 #if (GLM_COMPILER & GLM_COMPILER_VC)
576 # pragma warning(pop)
577 #endif
578 
579 #endif//(GLM_ARCH != GLM_ARCH_PURE)
glm::distance
GLM_FUNC_DECL T distance(vecType< T, P > const &p0, vecType< T, P > const &p1)
Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
glm::clamp
GLM_FUNC_DECL genType clamp(genType x, genType minVal, genType maxVal)
Returns min(max(x, minVal), maxVal) for each component in x using the floating-point values minVal an...
glm::fma
GLM_FUNC_DECL genType fma(genType const &a, genType const &b, genType const &c)
Computes and returns a * b + c.
glm::floor
GLM_FUNC_DECL vecType< T, P > floor(vecType< T, P > const &x)
Returns a value equal to the nearest integer that is less then or equal to x.
glm::fract
GLM_FUNC_DECL genType fract(genType x)
Return x - floor(x).
glm::length
GLM_FUNC_DECL T length(vecType< T, P > const &x)
Returns the length of x, i.e., sqrt(x * x).
glm::fastNormalize
GLM_FUNC_DECL genType fastNormalize(genType const &x)
Faster than the common normalize function but less accurate.
glm::vec2
highp_vec2 vec2
2 components vector of floating-point numbers.
Definition: type_vec.hpp:390
glm::ceil
GLM_FUNC_DECL vecType< T, P > ceil(vecType< T, P > const &x)
Returns a value equal to the nearest integer that is greater than or equal to x.
glm::smoothstep
GLM_FUNC_DECL genType smoothstep(genType edge0, genType edge1, genType x)
Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and performs smooth Hermite interpolation between 0 a...
glm::trunc
GLM_FUNC_DECL vecType< T, P > trunc(vecType< T, P > const &x)
Returns a value equal to the nearest integer to x whose absolute value is not larger than the absolut...
glm::refract
GLM_FUNC_DECL vecType< T, P > refract(vecType< T, P > const &I, vecType< T, P > const &N, T eta)
For the incident vector I and surface normal N, and the ratio of indices of refraction eta...
glm::fastLength
GLM_FUNC_DECL genType fastLength(genType x)
Faster than the common length function but less accurate.
glm::round
GLM_FUNC_DECL vecType< T, P > round(vecType< T, P > const &x)
Returns a value equal to the nearest integer to x.
glm::normalize
GLM_FUNC_DECL vecType< T, P > normalize(vecType< T, P > const &x)
Returns a vector in the same direction as x but with length of 1.
glm
Definition: _noise.hpp:40
glm::sign
GLM_FUNC_DECL vecType< T, P > sign(vecType< T, P > const &x)
Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0.
glm::reflect
GLM_FUNC_DECL genType reflect(genType const &I, genType const &N)
For the incident vector I and surface orientation N, returns the reflection direction : result = I - ...
glm::fastSqrt
GLM_FUNC_DECL genType fastSqrt(genType x)
Faster than the common sqrt function but less accurate.
glm::vec4
highp_vec4 vec4
4 components vector of floating-point numbers.
Definition: type_vec.hpp:400
glm::max
GLM_FUNC_DECL genType max(genType x, genType y)
Returns y if x < y; otherwise, it returns x.
glm::vec3
highp_vec3 vec3
3 components vector of floating-point numbers.
Definition: type_vec.hpp:395
glm::abs
GLM_FUNC_DECL genType abs(genType x)
Returns x if x >= 0; otherwise, it returns -x.
glm::min
GLM_FUNC_DECL genType min(genType x, genType y)
Returns y if y < x; otherwise, it returns x.
glm::inversesqrt
GLM_FUNC_DECL vecType< T, P > inversesqrt(vecType< T, P > const &v)
Returns the reciprocal of the positive square root of v.
glm::mix
GLM_FUNC_DECL vecType< T, P > mix(vecType< T, P > const &x, vecType< T, P > const &y, vecType< U, P > const &a)
If genTypeU is a floating scalar or vector: Returns x * (1.0 - a) + y * a, i.e., the linear blend of ...
glm::step
GLM_FUNC_DECL genType step(genType edge, genType x)
Returns 0.0 if x < edge, otherwise it returns 1.0 for each component of a genType.
glm::mod
GLM_FUNC_DECL genType mod(genType x, genType y)
Modulus.
glm::sqrt
GLM_FUNC_DECL vecType< T, P > sqrt(vecType< T, P > const &v)
Returns the positive square root of v.
glm::cross
GLM_FUNC_DECL tvec3< T, P > cross(tvec3< T, P > const &x, tvec3< T, P > const &y)
Returns the cross product of x and y.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00109.html000066400000000000000000000151411356361734700216460ustar00rootroot00000000000000 0.9.7: spline.hpp File Reference
Functions
spline.hpp File Reference

Go to the source code of this file.

Functions

template<typename genType >
GLM_FUNC_DECL genType catmullRom (genType const &v1, genType const &v2, genType const &v3, genType const &v4, typename genType::value_type const &s)
 
template<typename genType >
GLM_FUNC_DECL genType cubic (genType const &v1, genType const &v2, genType const &v3, genType const &v4, typename genType::value_type const &s)
 
template<typename genType >
GLM_FUNC_DECL genType hermite (genType const &v1, genType const &t1, genType const &v2, genType const &t2, typename genType::value_type const &s)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_spline

Date
2007-01-25 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file spline.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00109_source.html000066400000000000000000000236441356361734700232350ustar00rootroot00000000000000 0.9.7: spline.hpp Source File
spline.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../glm.hpp"
46 #include "../gtx/optimum_pow.hpp"
47 
48 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
49 # pragma message("GLM: GLM_GTX_spline extension included")
50 #endif
51 
52 namespace glm
53 {
56 
59  template <typename genType>
60  GLM_FUNC_DECL genType catmullRom(
61  genType const & v1,
62  genType const & v2,
63  genType const & v3,
64  genType const & v4,
65  typename genType::value_type const & s);
66 
69  template <typename genType>
70  GLM_FUNC_DECL genType hermite(
71  genType const & v1,
72  genType const & t1,
73  genType const & v2,
74  genType const & t2,
75  typename genType::value_type const & s);
76 
79  template <typename genType>
80  GLM_FUNC_DECL genType cubic(
81  genType const & v1,
82  genType const & v2,
83  genType const & v3,
84  genType const & v4,
85  typename genType::value_type const & s);
86 
88 }//namespace glm
89 
90 #include "spline.inl"
glm::cubic
GLM_FUNC_DECL genType cubic(genType const &v1, genType const &v2, genType const &v3, genType const &v4, typename genType::value_type const &s)
Return a point from a cubic curve.
glm::catmullRom
GLM_FUNC_DECL genType catmullRom(genType const &v1, genType const &v2, genType const &v3, genType const &v4, typename genType::value_type const &s)
Return a point from a catmull rom curve.
glm
Definition: _noise.hpp:40
glm::hermite
GLM_FUNC_DECL genType hermite(genType const &v1, genType const &t1, genType const &v2, genType const &t2, typename genType::value_type const &s)
Return a point from a hermite curve.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00110.html000066400000000000000000000177251356361734700216500ustar00rootroot00000000000000 0.9.7: std_based_type.hpp File Reference
Typedefs
std_based_type.hpp File Reference

Go to the source code of this file.

Typedefs

typedef tvec1< std::size_t, defaultp > size1
 
typedef tvec1< std::size_t, defaultp > size1_t
 
typedef tvec2< std::size_t, defaultp > size2
 
typedef tvec2< std::size_t, defaultp > size2_t
 
typedef tvec3< std::size_t, defaultp > size3
 
typedef tvec3< std::size_t, defaultp > size3_t
 
typedef tvec4< std::size_t, defaultp > size4
 
typedef tvec4< std::size_t, defaultp > size4_t
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_std_based_type

Date
2008-06-08 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTX_extented_min_max (dependence)

Definition in file std_based_type.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00110_source.html000066400000000000000000000266551356361734700232320ustar00rootroot00000000000000 0.9.7: std_based_type.hpp Source File
std_based_type.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../glm.hpp"
46 #include <cstdlib>
47 
48 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
49 # pragma message("GLM: GLM_GTX_std_based_type extension included")
50 #endif
51 
52 namespace glm
53 {
56 
59  typedef tvec1<std::size_t, defaultp> size1;
60 
63  typedef tvec2<std::size_t, defaultp> size2;
64 
67  typedef tvec3<std::size_t, defaultp> size3;
68 
71  typedef tvec4<std::size_t, defaultp> size4;
72 
75  typedef tvec1<std::size_t, defaultp> size1_t;
76 
79  typedef tvec2<std::size_t, defaultp> size2_t;
80 
83  typedef tvec3<std::size_t, defaultp> size3_t;
84 
87  typedef tvec4<std::size_t, defaultp> size4_t;
88 
90 }//namespace glm
91 
92 #include "std_based_type.inl"
glm::size4
tvec4< std::size_t, defaultp > size4
Vector type based of four std::size_t components.
Definition: std_based_type.hpp:71
glm::size1
tvec1< std::size_t, defaultp > size1
Vector type based of one std::size_t component.
Definition: std_based_type.hpp:59
glm::size2_t
tvec2< std::size_t, defaultp > size2_t
Vector type based of two std::size_t components.
Definition: std_based_type.hpp:79
glm::size3
tvec3< std::size_t, defaultp > size3
Vector type based of three std::size_t components.
Definition: std_based_type.hpp:67
glm::size1_t
tvec1< std::size_t, defaultp > size1_t
Vector type based of one std::size_t component.
Definition: std_based_type.hpp:75
glm::size3_t
tvec3< std::size_t, defaultp > size3_t
Vector type based of three std::size_t components.
Definition: std_based_type.hpp:83
glm
Definition: _noise.hpp:40
glm::size4_t
tvec4< std::size_t, defaultp > size4_t
Vector type based of four std::size_t components.
Definition: std_based_type.hpp:87
glm::size2
tvec2< std::size_t, defaultp > size2
Vector type based of two std::size_t components.
Definition: std_based_type.hpp:63
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00111.html000066400000000000000000000131141356361734700216350ustar00rootroot00000000000000 0.9.7: string_cast.hpp File Reference
Functions
string_cast.hpp File Reference

Go to the source code of this file.

Functions

template<template< typename, precision > class matType, typename T , precision P>
GLM_FUNC_DECL std::string to_string (matType< T, P > const &x)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_string_cast

Date
2008-04-26 / 2014-05-10
Author
Christophe Riccio
See also
GLM Core (dependence)
gtc_half_float (dependence)
GLM_GTX_integer (dependence)
GLM_GTX_quaternion (dependence)

Definition in file string_cast.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00111_source.html000066400000000000000000000151321356361734700232170ustar00rootroot00000000000000 0.9.7: string_cast.hpp Source File
string_cast.hpp
Go to the documentation of this file.
1 
46 #pragma once
47 
48 // Dependency:
49 #include "../glm.hpp"
50 #include "../gtc/type_precision.hpp"
51 #include <string>
52 
53 #if(GLM_COMPILER & GLM_COMPILER_CUDA)
54 # error "GLM_GTX_string_cast is not supported on CUDA compiler"
55 #endif
56 
57 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
58 # pragma message("GLM: GLM_GTX_string_cast extension included")
59 #endif
60 
61 namespace glm
62 {
65 
68  template <template <typename, precision> class matType, typename T, precision P>
69  GLM_FUNC_DECL std::string to_string(matType<T, P> const & x);
70 
72 }//namespace glm
73 
74 #include "string_cast.inl"
glm::to_string
GLM_FUNC_DECL std::string to_string(matType< T, P > const &x)
Create a string from a GLM vector or matrix typed variable.
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00112.html000066400000000000000000000153721356361734700216460ustar00rootroot00000000000000 0.9.7: transform.hpp File Reference
Functions
transform.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > rotate (T angle, tvec3< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > scale (tvec3< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > translate (tvec3< T, P > const &v)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_transform

Date
2005-12-21 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTC_matrix_transform (dependence)
GLM_GTX_transform
GLM_GTX_transform2

Definition in file transform.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00112_source.html000066400000000000000000000206451356361734700232250ustar00rootroot00000000000000 0.9.7: transform.hpp Source File
transform.hpp
Go to the documentation of this file.
1 
45 #pragma once
46 
47 // Dependency:
48 #include "../glm.hpp"
49 #include "../gtc/matrix_transform.hpp"
50 
51 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
52 # pragma message("GLM: GLM_GTX_transform extension included")
53 #endif
54 
55 namespace glm
56 {
59 
63  template <typename T, precision P>
64  GLM_FUNC_DECL tmat4x4<T, P> translate(
65  tvec3<T, P> const & v);
66 
70  template <typename T, precision P>
71  GLM_FUNC_DECL tmat4x4<T, P> rotate(
72  T angle,
73  tvec3<T, P> const & v);
74 
78  template <typename T, precision P>
79  GLM_FUNC_DECL tmat4x4<T, P> scale(
80  tvec3<T, P> const & v);
81 
83 }// namespace glm
84 
85 #include "transform.inl"
glm::rotate
GLM_FUNC_DECL tmat4x4< T, P > rotate(T angle, tvec3< T, P > const &v)
Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in degrees...
glm::translate
GLM_FUNC_DECL tmat4x4< T, P > translate(tvec3< T, P > const &v)
Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars.
glm
Definition: _noise.hpp:40
glm::angle
GLM_FUNC_DECL T angle(tquat< T, P > const &x)
Returns the quaternion rotation angle.
glm::scale
GLM_FUNC_DECL tmat4x4< T, P > scale(tvec3< T, P > const &v)
Transforms a matrix with a scale 4 * 4 matrix created from a vector of 3 components.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00113.html000066400000000000000000000241561356361734700216470ustar00rootroot00000000000000 0.9.7: transform2.hpp File Reference
Functions
transform2.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > proj2D (const tmat3x3< T, P > &m, const tvec3< T, P > &normal)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > proj3D (const tmat4x4< T, P > &m, const tvec3< T, P > &normal)
 
template<typename valType , precision P>
GLM_FUNC_DECL tmat4x4< valType, P > scaleBias (valType scale, valType bias)
 
template<typename valType , precision P>
GLM_FUNC_DECL tmat4x4< valType, P > scaleBias (tmat4x4< valType, P > const &m, valType scale, valType bias)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > shearX2D (tmat3x3< T, P > const &m, T y)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > shearX3D (const tmat4x4< T, P > &m, T y, T z)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > shearY2D (tmat3x3< T, P > const &m, T x)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > shearY3D (const tmat4x4< T, P > &m, T x, T z)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > shearZ3D (const tmat4x4< T, P > &m, T x, T y)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_transform2

Date
2005-12-21 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTX_transform (dependence)

Definition in file transform2.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00113_source.html000066400000000000000000000425131356361734700232240ustar00rootroot00000000000000 0.9.7: transform2.hpp Source File
transform2.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependency:
46 #include "../glm.hpp"
47 #include "../gtx/transform.hpp"
48 
49 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
50 # pragma message("GLM: GLM_GTX_transform2 extension included")
51 #endif
52 
53 namespace glm
54 {
57 
60  template <typename T, precision P>
61  GLM_FUNC_DECL tmat3x3<T, P> shearX2D(
62  tmat3x3<T, P> const & m,
63  T y);
64 
67  template <typename T, precision P>
68  GLM_FUNC_DECL tmat3x3<T, P> shearY2D(
69  tmat3x3<T, P> const & m,
70  T x);
71 
74  template <typename T, precision P>
75  GLM_FUNC_DECL tmat4x4<T, P> shearX3D(
76  const tmat4x4<T, P> & m,
77  T y,
78  T z);
79 
82  template <typename T, precision P>
83  GLM_FUNC_DECL tmat4x4<T, P> shearY3D(
84  const tmat4x4<T, P> & m,
85  T x,
86  T z);
87 
90  template <typename T, precision P>
91  GLM_FUNC_DECL tmat4x4<T, P> shearZ3D(
92  const tmat4x4<T, P> & m,
93  T x,
94  T y);
95 
96  //template <typename T> GLM_FUNC_QUALIFIER tmat4x4<T, P> shear(const tmat4x4<T, P> & m, shearPlane, planePoint, angle)
97  // Identity + tan(angle) * cross(Normal, OnPlaneVector) 0
98  // - dot(PointOnPlane, normal) * OnPlaneVector 1
99 
100  // Reflect functions seem to don't work
101  //template <typename T> tmat3x3<T, P> reflect2D(const tmat3x3<T, P> & m, const tvec3<T, P>& normal){return reflect2DGTX(m, normal);} //!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension)
102  //template <typename T> tmat4x4<T, P> reflect3D(const tmat4x4<T, P> & m, const tvec3<T, P>& normal){return reflect3DGTX(m, normal);} //!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension)
103 
106  template <typename T, precision P>
107  GLM_FUNC_DECL tmat3x3<T, P> proj2D(
108  const tmat3x3<T, P> & m,
109  const tvec3<T, P>& normal);
110 
113  template <typename T, precision P>
114  GLM_FUNC_DECL tmat4x4<T, P> proj3D(
115  const tmat4x4<T, P> & m,
116  const tvec3<T, P>& normal);
117 
120  template <typename valType, precision P>
121  GLM_FUNC_DECL tmat4x4<valType, P> scaleBias(
122  valType scale,
123  valType bias);
124 
127  template <typename valType, precision P>
128  GLM_FUNC_DECL tmat4x4<valType, P> scaleBias(
129  tmat4x4<valType, P> const & m,
130  valType scale,
131  valType bias);
132 
134 }// namespace glm
135 
136 #include "transform2.inl"
glm::scaleBias
GLM_FUNC_DECL tmat4x4< valType, P > scaleBias(tmat4x4< valType, P > const &m, valType scale, valType bias)
Build a scale bias matrix.
glm::shearZ3D
GLM_FUNC_DECL tmat4x4< T, P > shearZ3D(const tmat4x4< T, P > &m, T x, T y)
Transforms a matrix with a shearing on Z axis.
glm::shearY2D
GLM_FUNC_DECL tmat3x3< T, P > shearY2D(tmat3x3< T, P > const &m, T x)
Transforms a matrix with a shearing on Y axis.
glm::shearY3D
GLM_FUNC_DECL tmat4x4< T, P > shearY3D(const tmat4x4< T, P > &m, T x, T z)
Transforms a matrix with a shearing on Y axis.
glm::shearX2D
GLM_FUNC_DECL tmat3x3< T, P > shearX2D(tmat3x3< T, P > const &m, T y)
Transforms a matrix with a shearing on X axis.
glm::proj2D
GLM_FUNC_DECL tmat3x3< T, P > proj2D(const tmat3x3< T, P > &m, const tvec3< T, P > &normal)
Build planar projection matrix along normal axis.
glm::shearX3D
GLM_FUNC_DECL tmat4x4< T, P > shearX3D(const tmat4x4< T, P > &m, T y, T z)
Transforms a matrix with a shearing on X axis From GLM_GTX_transform2 extension.
glm::proj3D
GLM_FUNC_DECL tmat4x4< T, P > proj3D(const tmat4x4< T, P > &m, const tvec3< T, P > &normal)
Build planar projection matrix along normal axis.
glm
Definition: _noise.hpp:40
glm::scale
GLM_FUNC_DECL tmat4x4< T, P > scale(tmat4x4< T, P > const &m, tvec3< T, P > const &v)
Builds a scale 4 * 4 matrix created from 3 scalars.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00114.html000066400000000000000000000102131356361734700216350ustar00rootroot00000000000000 0.9.7: trigonometric.hpp File Reference
trigonometric.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-12-24 / 2013-12-24
Author
Christophe Riccio

Definition in file trigonometric.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00114_source.html000066400000000000000000000063051356361734700232240ustar00rootroot00000000000000 0.9.7: trigonometric.hpp Source File
trigonometric.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "detail/func_trigonometric.hpp"
func_trigonometric.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00115.html000066400000000000000000002563271356361734700216600ustar00rootroot00000000000000 0.9.7: type_aligned.hpp File Reference
Functions
type_aligned.hpp File Reference

Go to the source code of this file.

Functions

 GLM_ALIGNED_TYPEDEF (lowp_int8, aligned_lowp_int8, 1)
 
 GLM_ALIGNED_TYPEDEF (lowp_int16, aligned_lowp_int16, 2)
 
 GLM_ALIGNED_TYPEDEF (lowp_int32, aligned_lowp_int32, 4)
 
 GLM_ALIGNED_TYPEDEF (lowp_int64, aligned_lowp_int64, 8)
 
 GLM_ALIGNED_TYPEDEF (lowp_int8_t, aligned_lowp_int8_t, 1)
 
 GLM_ALIGNED_TYPEDEF (lowp_int16_t, aligned_lowp_int16_t, 2)
 
 GLM_ALIGNED_TYPEDEF (lowp_int32_t, aligned_lowp_int32_t, 4)
 
 GLM_ALIGNED_TYPEDEF (lowp_int64_t, aligned_lowp_int64_t, 8)
 
 GLM_ALIGNED_TYPEDEF (lowp_i8, aligned_lowp_i8, 1)
 
 GLM_ALIGNED_TYPEDEF (lowp_i16, aligned_lowp_i16, 2)
 
 GLM_ALIGNED_TYPEDEF (lowp_i32, aligned_lowp_i32, 4)
 
 GLM_ALIGNED_TYPEDEF (lowp_i64, aligned_lowp_i64, 8)
 
 GLM_ALIGNED_TYPEDEF (mediump_int8, aligned_mediump_int8, 1)
 
 GLM_ALIGNED_TYPEDEF (mediump_int16, aligned_mediump_int16, 2)
 
 GLM_ALIGNED_TYPEDEF (mediump_int32, aligned_mediump_int32, 4)
 
 GLM_ALIGNED_TYPEDEF (mediump_int64, aligned_mediump_int64, 8)
 
 GLM_ALIGNED_TYPEDEF (mediump_int8_t, aligned_mediump_int8_t, 1)
 
 GLM_ALIGNED_TYPEDEF (mediump_int16_t, aligned_mediump_int16_t, 2)
 
 GLM_ALIGNED_TYPEDEF (mediump_int32_t, aligned_mediump_int32_t, 4)
 
 GLM_ALIGNED_TYPEDEF (mediump_int64_t, aligned_mediump_int64_t, 8)
 
 GLM_ALIGNED_TYPEDEF (mediump_i8, aligned_mediump_i8, 1)
 
 GLM_ALIGNED_TYPEDEF (mediump_i16, aligned_mediump_i16, 2)
 
 GLM_ALIGNED_TYPEDEF (mediump_i32, aligned_mediump_i32, 4)
 
 GLM_ALIGNED_TYPEDEF (mediump_i64, aligned_mediump_i64, 8)
 
 GLM_ALIGNED_TYPEDEF (highp_int8, aligned_highp_int8, 1)
 
 GLM_ALIGNED_TYPEDEF (highp_int16, aligned_highp_int16, 2)
 
 GLM_ALIGNED_TYPEDEF (highp_int32, aligned_highp_int32, 4)
 
 GLM_ALIGNED_TYPEDEF (highp_int64, aligned_highp_int64, 8)
 
 GLM_ALIGNED_TYPEDEF (highp_int8_t, aligned_highp_int8_t, 1)
 
 GLM_ALIGNED_TYPEDEF (highp_int16_t, aligned_highp_int16_t, 2)
 
 GLM_ALIGNED_TYPEDEF (highp_int32_t, aligned_highp_int32_t, 4)
 
 GLM_ALIGNED_TYPEDEF (highp_int64_t, aligned_highp_int64_t, 8)
 
 GLM_ALIGNED_TYPEDEF (highp_i8, aligned_highp_i8, 1)
 
 GLM_ALIGNED_TYPEDEF (highp_i16, aligned_highp_i16, 2)
 
 GLM_ALIGNED_TYPEDEF (highp_i32, aligned_highp_i32, 4)
 
 GLM_ALIGNED_TYPEDEF (highp_i64, aligned_highp_i64, 8)
 
 GLM_ALIGNED_TYPEDEF (int8, aligned_int8, 1)
 
 GLM_ALIGNED_TYPEDEF (int16, aligned_int16, 2)
 
 GLM_ALIGNED_TYPEDEF (int32, aligned_int32, 4)
 
 GLM_ALIGNED_TYPEDEF (int64, aligned_int64, 8)
 
 GLM_ALIGNED_TYPEDEF (int8_t, aligned_int8_t, 1)
 
 GLM_ALIGNED_TYPEDEF (int16_t, aligned_int16_t, 2)
 
 GLM_ALIGNED_TYPEDEF (int32_t, aligned_int32_t, 4)
 
 GLM_ALIGNED_TYPEDEF (int64_t, aligned_int64_t, 8)
 
 GLM_ALIGNED_TYPEDEF (i8, aligned_i8, 1)
 
 GLM_ALIGNED_TYPEDEF (i16, aligned_i16, 2)
 
 GLM_ALIGNED_TYPEDEF (i32, aligned_i32, 4)
 
 GLM_ALIGNED_TYPEDEF (i64, aligned_i64, 8)
 
 GLM_ALIGNED_TYPEDEF (ivec1, aligned_ivec1, 4)
 
 GLM_ALIGNED_TYPEDEF (ivec2, aligned_ivec2, 8)
 
 GLM_ALIGNED_TYPEDEF (ivec3, aligned_ivec3, 16)
 
 GLM_ALIGNED_TYPEDEF (ivec4, aligned_ivec4, 16)
 
 GLM_ALIGNED_TYPEDEF (i8vec1, aligned_i8vec1, 1)
 
 GLM_ALIGNED_TYPEDEF (i8vec2, aligned_i8vec2, 2)
 
 GLM_ALIGNED_TYPEDEF (i8vec3, aligned_i8vec3, 4)
 
 GLM_ALIGNED_TYPEDEF (i8vec4, aligned_i8vec4, 4)
 
 GLM_ALIGNED_TYPEDEF (i16vec1, aligned_i16vec1, 2)
 
 GLM_ALIGNED_TYPEDEF (i16vec2, aligned_i16vec2, 4)
 
 GLM_ALIGNED_TYPEDEF (i16vec3, aligned_i16vec3, 8)
 
 GLM_ALIGNED_TYPEDEF (i16vec4, aligned_i16vec4, 8)
 
 GLM_ALIGNED_TYPEDEF (i32vec1, aligned_i32vec1, 4)
 
 GLM_ALIGNED_TYPEDEF (i32vec2, aligned_i32vec2, 8)
 
 GLM_ALIGNED_TYPEDEF (i32vec3, aligned_i32vec3, 16)
 
 GLM_ALIGNED_TYPEDEF (i32vec4, aligned_i32vec4, 16)
 
 GLM_ALIGNED_TYPEDEF (i64vec1, aligned_i64vec1, 8)
 
 GLM_ALIGNED_TYPEDEF (i64vec2, aligned_i64vec2, 16)
 
 GLM_ALIGNED_TYPEDEF (i64vec3, aligned_i64vec3, 32)
 
 GLM_ALIGNED_TYPEDEF (i64vec4, aligned_i64vec4, 32)
 
 GLM_ALIGNED_TYPEDEF (lowp_uint8, aligned_lowp_uint8, 1)
 
 GLM_ALIGNED_TYPEDEF (lowp_uint16, aligned_lowp_uint16, 2)
 
 GLM_ALIGNED_TYPEDEF (lowp_uint32, aligned_lowp_uint32, 4)
 
 GLM_ALIGNED_TYPEDEF (lowp_uint64, aligned_lowp_uint64, 8)
 
 GLM_ALIGNED_TYPEDEF (lowp_uint8_t, aligned_lowp_uint8_t, 1)
 
 GLM_ALIGNED_TYPEDEF (lowp_uint16_t, aligned_lowp_uint16_t, 2)
 
 GLM_ALIGNED_TYPEDEF (lowp_uint32_t, aligned_lowp_uint32_t, 4)
 
 GLM_ALIGNED_TYPEDEF (lowp_uint64_t, aligned_lowp_uint64_t, 8)
 
 GLM_ALIGNED_TYPEDEF (lowp_u8, aligned_lowp_u8, 1)
 
 GLM_ALIGNED_TYPEDEF (lowp_u16, aligned_lowp_u16, 2)
 
 GLM_ALIGNED_TYPEDEF (lowp_u32, aligned_lowp_u32, 4)
 
 GLM_ALIGNED_TYPEDEF (lowp_u64, aligned_lowp_u64, 8)
 
 GLM_ALIGNED_TYPEDEF (mediump_uint8, aligned_mediump_uint8, 1)
 
 GLM_ALIGNED_TYPEDEF (mediump_uint16, aligned_mediump_uint16, 2)
 
 GLM_ALIGNED_TYPEDEF (mediump_uint32, aligned_mediump_uint32, 4)
 
 GLM_ALIGNED_TYPEDEF (mediump_uint64, aligned_mediump_uint64, 8)
 
 GLM_ALIGNED_TYPEDEF (mediump_uint8_t, aligned_mediump_uint8_t, 1)
 
 GLM_ALIGNED_TYPEDEF (mediump_uint16_t, aligned_mediump_uint16_t, 2)
 
 GLM_ALIGNED_TYPEDEF (mediump_uint32_t, aligned_mediump_uint32_t, 4)
 
 GLM_ALIGNED_TYPEDEF (mediump_uint64_t, aligned_mediump_uint64_t, 8)
 
 GLM_ALIGNED_TYPEDEF (mediump_u8, aligned_mediump_u8, 1)
 
 GLM_ALIGNED_TYPEDEF (mediump_u16, aligned_mediump_u16, 2)
 
 GLM_ALIGNED_TYPEDEF (mediump_u32, aligned_mediump_u32, 4)
 
 GLM_ALIGNED_TYPEDEF (mediump_u64, aligned_mediump_u64, 8)
 
 GLM_ALIGNED_TYPEDEF (highp_uint8, aligned_highp_uint8, 1)
 
 GLM_ALIGNED_TYPEDEF (highp_uint16, aligned_highp_uint16, 2)
 
 GLM_ALIGNED_TYPEDEF (highp_uint32, aligned_highp_uint32, 4)
 
 GLM_ALIGNED_TYPEDEF (highp_uint64, aligned_highp_uint64, 8)
 
 GLM_ALIGNED_TYPEDEF (highp_uint8_t, aligned_highp_uint8_t, 1)
 
 GLM_ALIGNED_TYPEDEF (highp_uint16_t, aligned_highp_uint16_t, 2)
 
 GLM_ALIGNED_TYPEDEF (highp_uint32_t, aligned_highp_uint32_t, 4)
 
 GLM_ALIGNED_TYPEDEF (highp_uint64_t, aligned_highp_uint64_t, 8)
 
 GLM_ALIGNED_TYPEDEF (highp_u8, aligned_highp_u8, 1)
 
 GLM_ALIGNED_TYPEDEF (highp_u16, aligned_highp_u16, 2)
 
 GLM_ALIGNED_TYPEDEF (highp_u32, aligned_highp_u32, 4)
 
 GLM_ALIGNED_TYPEDEF (highp_u64, aligned_highp_u64, 8)
 
 GLM_ALIGNED_TYPEDEF (uint8, aligned_uint8, 1)
 
 GLM_ALIGNED_TYPEDEF (uint16, aligned_uint16, 2)
 
 GLM_ALIGNED_TYPEDEF (uint32, aligned_uint32, 4)
 
 GLM_ALIGNED_TYPEDEF (uint64, aligned_uint64, 8)
 
 GLM_ALIGNED_TYPEDEF (uint8_t, aligned_uint8_t, 1)
 
 GLM_ALIGNED_TYPEDEF (uint16_t, aligned_uint16_t, 2)
 
 GLM_ALIGNED_TYPEDEF (uint32_t, aligned_uint32_t, 4)
 
 GLM_ALIGNED_TYPEDEF (uint64_t, aligned_uint64_t, 8)
 
 GLM_ALIGNED_TYPEDEF (u8, aligned_u8, 1)
 
 GLM_ALIGNED_TYPEDEF (u16, aligned_u16, 2)
 
 GLM_ALIGNED_TYPEDEF (u32, aligned_u32, 4)
 
 GLM_ALIGNED_TYPEDEF (u64, aligned_u64, 8)
 
 GLM_ALIGNED_TYPEDEF (uvec1, aligned_uvec1, 4)
 
 GLM_ALIGNED_TYPEDEF (uvec2, aligned_uvec2, 8)
 
 GLM_ALIGNED_TYPEDEF (uvec3, aligned_uvec3, 16)
 
 GLM_ALIGNED_TYPEDEF (uvec4, aligned_uvec4, 16)
 
 GLM_ALIGNED_TYPEDEF (u8vec1, aligned_u8vec1, 1)
 
 GLM_ALIGNED_TYPEDEF (u8vec2, aligned_u8vec2, 2)
 
 GLM_ALIGNED_TYPEDEF (u8vec3, aligned_u8vec3, 4)
 
 GLM_ALIGNED_TYPEDEF (u8vec4, aligned_u8vec4, 4)
 
 GLM_ALIGNED_TYPEDEF (u16vec1, aligned_u16vec1, 2)
 
 GLM_ALIGNED_TYPEDEF (u16vec2, aligned_u16vec2, 4)
 
 GLM_ALIGNED_TYPEDEF (u16vec3, aligned_u16vec3, 8)
 
 GLM_ALIGNED_TYPEDEF (u16vec4, aligned_u16vec4, 8)
 
 GLM_ALIGNED_TYPEDEF (u32vec1, aligned_u32vec1, 4)
 
 GLM_ALIGNED_TYPEDEF (u32vec2, aligned_u32vec2, 8)
 
 GLM_ALIGNED_TYPEDEF (u32vec3, aligned_u32vec3, 16)
 
 GLM_ALIGNED_TYPEDEF (u32vec4, aligned_u32vec4, 16)
 
 GLM_ALIGNED_TYPEDEF (u64vec1, aligned_u64vec1, 8)
 
 GLM_ALIGNED_TYPEDEF (u64vec2, aligned_u64vec2, 16)
 
 GLM_ALIGNED_TYPEDEF (u64vec3, aligned_u64vec3, 32)
 
 GLM_ALIGNED_TYPEDEF (u64vec4, aligned_u64vec4, 32)
 
 GLM_ALIGNED_TYPEDEF (float32, aligned_float32, 4)
 
 GLM_ALIGNED_TYPEDEF (float64, aligned_float64, 8)
 
 GLM_ALIGNED_TYPEDEF (float32_t, aligned_float32_t, 4)
 
 GLM_ALIGNED_TYPEDEF (float64_t, aligned_float64_t, 8)
 
 GLM_ALIGNED_TYPEDEF (float32, aligned_f32, 4)
 
 GLM_ALIGNED_TYPEDEF (float64, aligned_f64, 8)
 
 GLM_ALIGNED_TYPEDEF (vec1, aligned_vec1, 4)
 
 GLM_ALIGNED_TYPEDEF (vec2, aligned_vec2, 8)
 
 GLM_ALIGNED_TYPEDEF (vec3, aligned_vec3, 16)
 
 GLM_ALIGNED_TYPEDEF (vec4, aligned_vec4, 16)
 
 GLM_ALIGNED_TYPEDEF (fvec1, aligned_fvec1, 4)
 
 GLM_ALIGNED_TYPEDEF (fvec2, aligned_fvec2, 8)
 
 GLM_ALIGNED_TYPEDEF (fvec3, aligned_fvec3, 16)
 
 GLM_ALIGNED_TYPEDEF (fvec4, aligned_fvec4, 16)
 
 GLM_ALIGNED_TYPEDEF (f32vec1, aligned_f32vec1, 4)
 
 GLM_ALIGNED_TYPEDEF (f32vec2, aligned_f32vec2, 8)
 
 GLM_ALIGNED_TYPEDEF (f32vec3, aligned_f32vec3, 16)
 
 GLM_ALIGNED_TYPEDEF (f32vec4, aligned_f32vec4, 16)
 
 GLM_ALIGNED_TYPEDEF (dvec1, aligned_dvec1, 8)
 
 GLM_ALIGNED_TYPEDEF (dvec2, aligned_dvec2, 16)
 
 GLM_ALIGNED_TYPEDEF (dvec3, aligned_dvec3, 32)
 
 GLM_ALIGNED_TYPEDEF (dvec4, aligned_dvec4, 32)
 
 GLM_ALIGNED_TYPEDEF (f64vec1, aligned_f64vec1, 8)
 
 GLM_ALIGNED_TYPEDEF (f64vec2, aligned_f64vec2, 16)
 
 GLM_ALIGNED_TYPEDEF (f64vec3, aligned_f64vec3, 32)
 
 GLM_ALIGNED_TYPEDEF (f64vec4, aligned_f64vec4, 32)
 
 GLM_ALIGNED_TYPEDEF (mat2, aligned_mat2, 16)
 
 GLM_ALIGNED_TYPEDEF (mat3, aligned_mat3, 16)
 
 GLM_ALIGNED_TYPEDEF (mat4, aligned_mat4, 16)
 
 GLM_ALIGNED_TYPEDEF (mat2x2, aligned_mat2x2, 16)
 
 GLM_ALIGNED_TYPEDEF (mat3x3, aligned_mat3x3, 16)
 
 GLM_ALIGNED_TYPEDEF (mat4x4, aligned_mat4x4, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat2x2, aligned_fmat2, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat3x3, aligned_fmat3, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat4x4, aligned_fmat4, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat2x2, aligned_fmat2x2, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat2x3, aligned_fmat2x3, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat2x4, aligned_fmat2x4, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat3x2, aligned_fmat3x2, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat3x3, aligned_fmat3x3, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat3x4, aligned_fmat3x4, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat4x2, aligned_fmat4x2, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat4x3, aligned_fmat4x3, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat4x4, aligned_fmat4x4, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat2x2, aligned_f32mat2, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat3x3, aligned_f32mat3, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat4x4, aligned_f32mat4, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat2x2, aligned_f32mat2x2, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat2x3, aligned_f32mat2x3, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat2x4, aligned_f32mat2x4, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat3x2, aligned_f32mat3x2, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat3x3, aligned_f32mat3x3, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat3x4, aligned_f32mat3x4, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat4x2, aligned_f32mat4x2, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat4x3, aligned_f32mat4x3, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat4x4, aligned_f32mat4x4, 16)
 
 GLM_ALIGNED_TYPEDEF (f64mat2x2, aligned_f64mat2, 32)
 
 GLM_ALIGNED_TYPEDEF (f64mat3x3, aligned_f64mat3, 32)
 
 GLM_ALIGNED_TYPEDEF (f64mat4x4, aligned_f64mat4, 32)
 
 GLM_ALIGNED_TYPEDEF (f64mat2x2, aligned_f64mat2x2, 32)
 
 GLM_ALIGNED_TYPEDEF (f64mat2x3, aligned_f64mat2x3, 32)
 
 GLM_ALIGNED_TYPEDEF (f64mat2x4, aligned_f64mat2x4, 32)
 
 GLM_ALIGNED_TYPEDEF (f64mat3x2, aligned_f64mat3x2, 32)
 
 GLM_ALIGNED_TYPEDEF (f64mat3x3, aligned_f64mat3x3, 32)
 
 GLM_ALIGNED_TYPEDEF (f64mat3x4, aligned_f64mat3x4, 32)
 
 GLM_ALIGNED_TYPEDEF (f64mat4x2, aligned_f64mat4x2, 32)
 
 GLM_ALIGNED_TYPEDEF (f64mat4x3, aligned_f64mat4x3, 32)
 
 GLM_ALIGNED_TYPEDEF (f64mat4x4, aligned_f64mat4x4, 32)
 
 GLM_ALIGNED_TYPEDEF (quat, aligned_quat, 16)
 
 GLM_ALIGNED_TYPEDEF (fquat, aligned_fquat, 16)
 
 GLM_ALIGNED_TYPEDEF (dquat, aligned_dquat, 32)
 
 GLM_ALIGNED_TYPEDEF (f32quat, aligned_f32quat, 16)
 
 GLM_ALIGNED_TYPEDEF (f64quat, aligned_f64quat, 32)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_type_aligned

Date
2014-11-23 / 2014-12-23
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTC_quaternion (dependence)

Definition in file type_aligned.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00115_source.html000066400000000000000000004741211356361734700232320ustar00rootroot00000000000000 0.9.7: type_aligned.hpp Source File
type_aligned.hpp
Go to the documentation of this file.
1 
45 #pragma once
46 
47 // Dependency:
48 #include "../gtc/type_precision.hpp"
49 
50 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
51 # pragma message("GLM: GLM_GTX_type_aligned extension included")
52 #endif
53 
54 namespace glm
55 {
57  // Signed int vector types
58 
61 
64  GLM_ALIGNED_TYPEDEF(lowp_int8, aligned_lowp_int8, 1);
65 
68  GLM_ALIGNED_TYPEDEF(lowp_int16, aligned_lowp_int16, 2);
69 
72  GLM_ALIGNED_TYPEDEF(lowp_int32, aligned_lowp_int32, 4);
73 
76  GLM_ALIGNED_TYPEDEF(lowp_int64, aligned_lowp_int64, 8);
77 
78 
81  GLM_ALIGNED_TYPEDEF(lowp_int8_t, aligned_lowp_int8_t, 1);
82 
85  GLM_ALIGNED_TYPEDEF(lowp_int16_t, aligned_lowp_int16_t, 2);
86 
89  GLM_ALIGNED_TYPEDEF(lowp_int32_t, aligned_lowp_int32_t, 4);
90 
93  GLM_ALIGNED_TYPEDEF(lowp_int64_t, aligned_lowp_int64_t, 8);
94 
95 
98  GLM_ALIGNED_TYPEDEF(lowp_i8, aligned_lowp_i8, 1);
99 
102  GLM_ALIGNED_TYPEDEF(lowp_i16, aligned_lowp_i16, 2);
103 
106  GLM_ALIGNED_TYPEDEF(lowp_i32, aligned_lowp_i32, 4);
107 
110  GLM_ALIGNED_TYPEDEF(lowp_i64, aligned_lowp_i64, 8);
111 
112 
115  GLM_ALIGNED_TYPEDEF(mediump_int8, aligned_mediump_int8, 1);
116 
119  GLM_ALIGNED_TYPEDEF(mediump_int16, aligned_mediump_int16, 2);
120 
123  GLM_ALIGNED_TYPEDEF(mediump_int32, aligned_mediump_int32, 4);
124 
127  GLM_ALIGNED_TYPEDEF(mediump_int64, aligned_mediump_int64, 8);
128 
129 
132  GLM_ALIGNED_TYPEDEF(mediump_int8_t, aligned_mediump_int8_t, 1);
133 
136  GLM_ALIGNED_TYPEDEF(mediump_int16_t, aligned_mediump_int16_t, 2);
137 
140  GLM_ALIGNED_TYPEDEF(mediump_int32_t, aligned_mediump_int32_t, 4);
141 
144  GLM_ALIGNED_TYPEDEF(mediump_int64_t, aligned_mediump_int64_t, 8);
145 
146 
149  GLM_ALIGNED_TYPEDEF(mediump_i8, aligned_mediump_i8, 1);
150 
153  GLM_ALIGNED_TYPEDEF(mediump_i16, aligned_mediump_i16, 2);
154 
157  GLM_ALIGNED_TYPEDEF(mediump_i32, aligned_mediump_i32, 4);
158 
161  GLM_ALIGNED_TYPEDEF(mediump_i64, aligned_mediump_i64, 8);
162 
163 
166  GLM_ALIGNED_TYPEDEF(highp_int8, aligned_highp_int8, 1);
167 
170  GLM_ALIGNED_TYPEDEF(highp_int16, aligned_highp_int16, 2);
171 
174  GLM_ALIGNED_TYPEDEF(highp_int32, aligned_highp_int32, 4);
175 
178  GLM_ALIGNED_TYPEDEF(highp_int64, aligned_highp_int64, 8);
179 
180 
183  GLM_ALIGNED_TYPEDEF(highp_int8_t, aligned_highp_int8_t, 1);
184 
187  GLM_ALIGNED_TYPEDEF(highp_int16_t, aligned_highp_int16_t, 2);
188 
191  GLM_ALIGNED_TYPEDEF(highp_int32_t, aligned_highp_int32_t, 4);
192 
195  GLM_ALIGNED_TYPEDEF(highp_int64_t, aligned_highp_int64_t, 8);
196 
197 
200  GLM_ALIGNED_TYPEDEF(highp_i8, aligned_highp_i8, 1);
201 
204  GLM_ALIGNED_TYPEDEF(highp_i16, aligned_highp_i16, 2);
205 
208  GLM_ALIGNED_TYPEDEF(highp_i32, aligned_highp_i32, 4);
209 
212  GLM_ALIGNED_TYPEDEF(highp_i64, aligned_highp_i64, 8);
213 
214 
217  GLM_ALIGNED_TYPEDEF(int8, aligned_int8, 1);
218 
221  GLM_ALIGNED_TYPEDEF(int16, aligned_int16, 2);
222 
225  GLM_ALIGNED_TYPEDEF(int32, aligned_int32, 4);
226 
229  GLM_ALIGNED_TYPEDEF(int64, aligned_int64, 8);
230 
231 
234  GLM_ALIGNED_TYPEDEF(int8_t, aligned_int8_t, 1);
235 
238  GLM_ALIGNED_TYPEDEF(int16_t, aligned_int16_t, 2);
239 
242  GLM_ALIGNED_TYPEDEF(int32_t, aligned_int32_t, 4);
243 
246  GLM_ALIGNED_TYPEDEF(int64_t, aligned_int64_t, 8);
247 
248 
251  GLM_ALIGNED_TYPEDEF(i8, aligned_i8, 1);
252 
255  GLM_ALIGNED_TYPEDEF(i16, aligned_i16, 2);
256 
259  GLM_ALIGNED_TYPEDEF(i32, aligned_i32, 4);
260 
263  GLM_ALIGNED_TYPEDEF(i64, aligned_i64, 8);
264 
265 
268  GLM_ALIGNED_TYPEDEF(ivec1, aligned_ivec1, 4);
269 
272  GLM_ALIGNED_TYPEDEF(ivec2, aligned_ivec2, 8);
273 
276  GLM_ALIGNED_TYPEDEF(ivec3, aligned_ivec3, 16);
277 
280  GLM_ALIGNED_TYPEDEF(ivec4, aligned_ivec4, 16);
281 
282 
285  GLM_ALIGNED_TYPEDEF(i8vec1, aligned_i8vec1, 1);
286 
289  GLM_ALIGNED_TYPEDEF(i8vec2, aligned_i8vec2, 2);
290 
293  GLM_ALIGNED_TYPEDEF(i8vec3, aligned_i8vec3, 4);
294 
297  GLM_ALIGNED_TYPEDEF(i8vec4, aligned_i8vec4, 4);
298 
299 
302  GLM_ALIGNED_TYPEDEF(i16vec1, aligned_i16vec1, 2);
303 
306  GLM_ALIGNED_TYPEDEF(i16vec2, aligned_i16vec2, 4);
307 
310  GLM_ALIGNED_TYPEDEF(i16vec3, aligned_i16vec3, 8);
311 
314  GLM_ALIGNED_TYPEDEF(i16vec4, aligned_i16vec4, 8);
315 
316 
319  GLM_ALIGNED_TYPEDEF(i32vec1, aligned_i32vec1, 4);
320 
323  GLM_ALIGNED_TYPEDEF(i32vec2, aligned_i32vec2, 8);
324 
327  GLM_ALIGNED_TYPEDEF(i32vec3, aligned_i32vec3, 16);
328 
331  GLM_ALIGNED_TYPEDEF(i32vec4, aligned_i32vec4, 16);
332 
333 
336  GLM_ALIGNED_TYPEDEF(i64vec1, aligned_i64vec1, 8);
337 
340  GLM_ALIGNED_TYPEDEF(i64vec2, aligned_i64vec2, 16);
341 
344  GLM_ALIGNED_TYPEDEF(i64vec3, aligned_i64vec3, 32);
345 
348  GLM_ALIGNED_TYPEDEF(i64vec4, aligned_i64vec4, 32);
349 
350 
352  // Unsigned int vector types
353 
356  GLM_ALIGNED_TYPEDEF(lowp_uint8, aligned_lowp_uint8, 1);
357 
360  GLM_ALIGNED_TYPEDEF(lowp_uint16, aligned_lowp_uint16, 2);
361 
364  GLM_ALIGNED_TYPEDEF(lowp_uint32, aligned_lowp_uint32, 4);
365 
368  GLM_ALIGNED_TYPEDEF(lowp_uint64, aligned_lowp_uint64, 8);
369 
370 
373  GLM_ALIGNED_TYPEDEF(lowp_uint8_t, aligned_lowp_uint8_t, 1);
374 
377  GLM_ALIGNED_TYPEDEF(lowp_uint16_t, aligned_lowp_uint16_t, 2);
378 
381  GLM_ALIGNED_TYPEDEF(lowp_uint32_t, aligned_lowp_uint32_t, 4);
382 
385  GLM_ALIGNED_TYPEDEF(lowp_uint64_t, aligned_lowp_uint64_t, 8);
386 
387 
390  GLM_ALIGNED_TYPEDEF(lowp_u8, aligned_lowp_u8, 1);
391 
394  GLM_ALIGNED_TYPEDEF(lowp_u16, aligned_lowp_u16, 2);
395 
398  GLM_ALIGNED_TYPEDEF(lowp_u32, aligned_lowp_u32, 4);
399 
402  GLM_ALIGNED_TYPEDEF(lowp_u64, aligned_lowp_u64, 8);
403 
404 
407  GLM_ALIGNED_TYPEDEF(mediump_uint8, aligned_mediump_uint8, 1);
408 
411  GLM_ALIGNED_TYPEDEF(mediump_uint16, aligned_mediump_uint16, 2);
412 
415  GLM_ALIGNED_TYPEDEF(mediump_uint32, aligned_mediump_uint32, 4);
416 
419  GLM_ALIGNED_TYPEDEF(mediump_uint64, aligned_mediump_uint64, 8);
420 
421 
424  GLM_ALIGNED_TYPEDEF(mediump_uint8_t, aligned_mediump_uint8_t, 1);
425 
428  GLM_ALIGNED_TYPEDEF(mediump_uint16_t, aligned_mediump_uint16_t, 2);
429 
432  GLM_ALIGNED_TYPEDEF(mediump_uint32_t, aligned_mediump_uint32_t, 4);
433 
436  GLM_ALIGNED_TYPEDEF(mediump_uint64_t, aligned_mediump_uint64_t, 8);
437 
438 
441  GLM_ALIGNED_TYPEDEF(mediump_u8, aligned_mediump_u8, 1);
442 
445  GLM_ALIGNED_TYPEDEF(mediump_u16, aligned_mediump_u16, 2);
446 
449  GLM_ALIGNED_TYPEDEF(mediump_u32, aligned_mediump_u32, 4);
450 
453  GLM_ALIGNED_TYPEDEF(mediump_u64, aligned_mediump_u64, 8);
454 
455 
458  GLM_ALIGNED_TYPEDEF(highp_uint8, aligned_highp_uint8, 1);
459 
462  GLM_ALIGNED_TYPEDEF(highp_uint16, aligned_highp_uint16, 2);
463 
466  GLM_ALIGNED_TYPEDEF(highp_uint32, aligned_highp_uint32, 4);
467 
470  GLM_ALIGNED_TYPEDEF(highp_uint64, aligned_highp_uint64, 8);
471 
472 
475  GLM_ALIGNED_TYPEDEF(highp_uint8_t, aligned_highp_uint8_t, 1);
476 
479  GLM_ALIGNED_TYPEDEF(highp_uint16_t, aligned_highp_uint16_t, 2);
480 
483  GLM_ALIGNED_TYPEDEF(highp_uint32_t, aligned_highp_uint32_t, 4);
484 
487  GLM_ALIGNED_TYPEDEF(highp_uint64_t, aligned_highp_uint64_t, 8);
488 
489 
492  GLM_ALIGNED_TYPEDEF(highp_u8, aligned_highp_u8, 1);
493 
496  GLM_ALIGNED_TYPEDEF(highp_u16, aligned_highp_u16, 2);
497 
500  GLM_ALIGNED_TYPEDEF(highp_u32, aligned_highp_u32, 4);
501 
504  GLM_ALIGNED_TYPEDEF(highp_u64, aligned_highp_u64, 8);
505 
506 
509  GLM_ALIGNED_TYPEDEF(uint8, aligned_uint8, 1);
510 
513  GLM_ALIGNED_TYPEDEF(uint16, aligned_uint16, 2);
514 
517  GLM_ALIGNED_TYPEDEF(uint32, aligned_uint32, 4);
518 
521  GLM_ALIGNED_TYPEDEF(uint64, aligned_uint64, 8);
522 
523 
526  GLM_ALIGNED_TYPEDEF(uint8_t, aligned_uint8_t, 1);
527 
530  GLM_ALIGNED_TYPEDEF(uint16_t, aligned_uint16_t, 2);
531 
534  GLM_ALIGNED_TYPEDEF(uint32_t, aligned_uint32_t, 4);
535 
538  GLM_ALIGNED_TYPEDEF(uint64_t, aligned_uint64_t, 8);
539 
540 
543  GLM_ALIGNED_TYPEDEF(u8, aligned_u8, 1);
544 
547  GLM_ALIGNED_TYPEDEF(u16, aligned_u16, 2);
548 
551  GLM_ALIGNED_TYPEDEF(u32, aligned_u32, 4);
552 
555  GLM_ALIGNED_TYPEDEF(u64, aligned_u64, 8);
556 
557 
560  GLM_ALIGNED_TYPEDEF(uvec1, aligned_uvec1, 4);
561 
564  GLM_ALIGNED_TYPEDEF(uvec2, aligned_uvec2, 8);
565 
568  GLM_ALIGNED_TYPEDEF(uvec3, aligned_uvec3, 16);
569 
572  GLM_ALIGNED_TYPEDEF(uvec4, aligned_uvec4, 16);
573 
574 
577  GLM_ALIGNED_TYPEDEF(u8vec1, aligned_u8vec1, 1);
578 
581  GLM_ALIGNED_TYPEDEF(u8vec2, aligned_u8vec2, 2);
582 
585  GLM_ALIGNED_TYPEDEF(u8vec3, aligned_u8vec3, 4);
586 
589  GLM_ALIGNED_TYPEDEF(u8vec4, aligned_u8vec4, 4);
590 
591 
594  GLM_ALIGNED_TYPEDEF(u16vec1, aligned_u16vec1, 2);
595 
598  GLM_ALIGNED_TYPEDEF(u16vec2, aligned_u16vec2, 4);
599 
602  GLM_ALIGNED_TYPEDEF(u16vec3, aligned_u16vec3, 8);
603 
606  GLM_ALIGNED_TYPEDEF(u16vec4, aligned_u16vec4, 8);
607 
608 
611  GLM_ALIGNED_TYPEDEF(u32vec1, aligned_u32vec1, 4);
612 
615  GLM_ALIGNED_TYPEDEF(u32vec2, aligned_u32vec2, 8);
616 
619  GLM_ALIGNED_TYPEDEF(u32vec3, aligned_u32vec3, 16);
620 
623  GLM_ALIGNED_TYPEDEF(u32vec4, aligned_u32vec4, 16);
624 
625 
628  GLM_ALIGNED_TYPEDEF(u64vec1, aligned_u64vec1, 8);
629 
632  GLM_ALIGNED_TYPEDEF(u64vec2, aligned_u64vec2, 16);
633 
636  GLM_ALIGNED_TYPEDEF(u64vec3, aligned_u64vec3, 32);
637 
640  GLM_ALIGNED_TYPEDEF(u64vec4, aligned_u64vec4, 32);
641 
642 
644  // Float vector types
645 
648  GLM_ALIGNED_TYPEDEF(float32, aligned_float32, 4);
649 
652  GLM_ALIGNED_TYPEDEF(float64, aligned_float64, 8);
653 
654 
657  GLM_ALIGNED_TYPEDEF(float32_t, aligned_float32_t, 4);
658 
661  GLM_ALIGNED_TYPEDEF(float64_t, aligned_float64_t, 8);
662 
663 
666  GLM_ALIGNED_TYPEDEF(float32, aligned_f32, 4);
667 
670  GLM_ALIGNED_TYPEDEF(float64, aligned_f64, 8);
671 
672 
675  GLM_ALIGNED_TYPEDEF(vec1, aligned_vec1, 4);
676 
679  GLM_ALIGNED_TYPEDEF(vec2, aligned_vec2, 8);
680 
683  GLM_ALIGNED_TYPEDEF(vec3, aligned_vec3, 16);
684 
687  GLM_ALIGNED_TYPEDEF(vec4, aligned_vec4, 16);
688 
689 
692  GLM_ALIGNED_TYPEDEF(fvec1, aligned_fvec1, 4);
693 
696  GLM_ALIGNED_TYPEDEF(fvec2, aligned_fvec2, 8);
697 
700  GLM_ALIGNED_TYPEDEF(fvec3, aligned_fvec3, 16);
701 
704  GLM_ALIGNED_TYPEDEF(fvec4, aligned_fvec4, 16);
705 
706 
709  GLM_ALIGNED_TYPEDEF(f32vec1, aligned_f32vec1, 4);
710 
713  GLM_ALIGNED_TYPEDEF(f32vec2, aligned_f32vec2, 8);
714 
717  GLM_ALIGNED_TYPEDEF(f32vec3, aligned_f32vec3, 16);
718 
721  GLM_ALIGNED_TYPEDEF(f32vec4, aligned_f32vec4, 16);
722 
723 
726  GLM_ALIGNED_TYPEDEF(dvec1, aligned_dvec1, 8);
727 
730  GLM_ALIGNED_TYPEDEF(dvec2, aligned_dvec2, 16);
731 
734  GLM_ALIGNED_TYPEDEF(dvec3, aligned_dvec3, 32);
735 
738  GLM_ALIGNED_TYPEDEF(dvec4, aligned_dvec4, 32);
739 
740 
743  GLM_ALIGNED_TYPEDEF(f64vec1, aligned_f64vec1, 8);
744 
747  GLM_ALIGNED_TYPEDEF(f64vec2, aligned_f64vec2, 16);
748 
751  GLM_ALIGNED_TYPEDEF(f64vec3, aligned_f64vec3, 32);
752 
755  GLM_ALIGNED_TYPEDEF(f64vec4, aligned_f64vec4, 32);
756 
757 
759  // Float matrix types
760 
763  //typedef detail::tmat1<f32> mat1;
764 
767  GLM_ALIGNED_TYPEDEF(mat2, aligned_mat2, 16);
768 
771  GLM_ALIGNED_TYPEDEF(mat3, aligned_mat3, 16);
772 
775  GLM_ALIGNED_TYPEDEF(mat4, aligned_mat4, 16);
776 
777 
780  //typedef detail::tmat1x1<f32> mat1;
781 
784  GLM_ALIGNED_TYPEDEF(mat2x2, aligned_mat2x2, 16);
785 
788  GLM_ALIGNED_TYPEDEF(mat3x3, aligned_mat3x3, 16);
789 
792  GLM_ALIGNED_TYPEDEF(mat4x4, aligned_mat4x4, 16);
793 
794 
797  //typedef detail::tmat1x1<f32> fmat1;
798 
801  GLM_ALIGNED_TYPEDEF(fmat2x2, aligned_fmat2, 16);
802 
805  GLM_ALIGNED_TYPEDEF(fmat3x3, aligned_fmat3, 16);
806 
809  GLM_ALIGNED_TYPEDEF(fmat4x4, aligned_fmat4, 16);
810 
811 
814  //typedef f32 fmat1x1;
815 
818  GLM_ALIGNED_TYPEDEF(fmat2x2, aligned_fmat2x2, 16);
819 
822  GLM_ALIGNED_TYPEDEF(fmat2x3, aligned_fmat2x3, 16);
823 
826  GLM_ALIGNED_TYPEDEF(fmat2x4, aligned_fmat2x4, 16);
827 
830  GLM_ALIGNED_TYPEDEF(fmat3x2, aligned_fmat3x2, 16);
831 
834  GLM_ALIGNED_TYPEDEF(fmat3x3, aligned_fmat3x3, 16);
835 
838  GLM_ALIGNED_TYPEDEF(fmat3x4, aligned_fmat3x4, 16);
839 
842  GLM_ALIGNED_TYPEDEF(fmat4x2, aligned_fmat4x2, 16);
843 
846  GLM_ALIGNED_TYPEDEF(fmat4x3, aligned_fmat4x3, 16);
847 
850  GLM_ALIGNED_TYPEDEF(fmat4x4, aligned_fmat4x4, 16);
851 
852 
855  //typedef detail::tmat1x1<f32, defaultp> f32mat1;
856 
859  GLM_ALIGNED_TYPEDEF(f32mat2x2, aligned_f32mat2, 16);
860 
863  GLM_ALIGNED_TYPEDEF(f32mat3x3, aligned_f32mat3, 16);
864 
867  GLM_ALIGNED_TYPEDEF(f32mat4x4, aligned_f32mat4, 16);
868 
869 
872  //typedef f32 f32mat1x1;
873 
876  GLM_ALIGNED_TYPEDEF(f32mat2x2, aligned_f32mat2x2, 16);
877 
880  GLM_ALIGNED_TYPEDEF(f32mat2x3, aligned_f32mat2x3, 16);
881 
884  GLM_ALIGNED_TYPEDEF(f32mat2x4, aligned_f32mat2x4, 16);
885 
888  GLM_ALIGNED_TYPEDEF(f32mat3x2, aligned_f32mat3x2, 16);
889 
892  GLM_ALIGNED_TYPEDEF(f32mat3x3, aligned_f32mat3x3, 16);
893 
896  GLM_ALIGNED_TYPEDEF(f32mat3x4, aligned_f32mat3x4, 16);
897 
900  GLM_ALIGNED_TYPEDEF(f32mat4x2, aligned_f32mat4x2, 16);
901 
904  GLM_ALIGNED_TYPEDEF(f32mat4x3, aligned_f32mat4x3, 16);
905 
908  GLM_ALIGNED_TYPEDEF(f32mat4x4, aligned_f32mat4x4, 16);
909 
910 
913  //typedef detail::tmat1x1<f64, defaultp> f64mat1;
914 
917  GLM_ALIGNED_TYPEDEF(f64mat2x2, aligned_f64mat2, 32);
918 
921  GLM_ALIGNED_TYPEDEF(f64mat3x3, aligned_f64mat3, 32);
922 
925  GLM_ALIGNED_TYPEDEF(f64mat4x4, aligned_f64mat4, 32);
926 
927 
930  //typedef f64 f64mat1x1;
931 
934  GLM_ALIGNED_TYPEDEF(f64mat2x2, aligned_f64mat2x2, 32);
935 
938  GLM_ALIGNED_TYPEDEF(f64mat2x3, aligned_f64mat2x3, 32);
939 
942  GLM_ALIGNED_TYPEDEF(f64mat2x4, aligned_f64mat2x4, 32);
943 
946  GLM_ALIGNED_TYPEDEF(f64mat3x2, aligned_f64mat3x2, 32);
947 
950  GLM_ALIGNED_TYPEDEF(f64mat3x3, aligned_f64mat3x3, 32);
951 
954  GLM_ALIGNED_TYPEDEF(f64mat3x4, aligned_f64mat3x4, 32);
955 
958  GLM_ALIGNED_TYPEDEF(f64mat4x2, aligned_f64mat4x2, 32);
959 
962  GLM_ALIGNED_TYPEDEF(f64mat4x3, aligned_f64mat4x3, 32);
963 
966  GLM_ALIGNED_TYPEDEF(f64mat4x4, aligned_f64mat4x4, 32);
967 
968 
970  // Quaternion types
971 
974  GLM_ALIGNED_TYPEDEF(quat, aligned_quat, 16);
975 
978  GLM_ALIGNED_TYPEDEF(fquat, aligned_fquat, 16);
979 
982  GLM_ALIGNED_TYPEDEF(dquat, aligned_dquat, 32);
983 
986  GLM_ALIGNED_TYPEDEF(f32quat, aligned_f32quat, 16);
987 
990  GLM_ALIGNED_TYPEDEF(f64quat, aligned_f64quat, 32);
991 
993 }//namespace glm
994 
995 #include "type_aligned.inl"
glm::int8_t
detail::int8 int8_t
8 bit signed integer type.
Definition: fwd.hpp:297
glm::lowp_uint32
detail::uint32 lowp_uint32
Low precision 32 bit unsigned integer type.
Definition: fwd.hpp:740
glm::lowp_int64_t
detail::int64 lowp_int64_t
Low precision 64 bit signed integer type.
Definition: fwd.hpp:157
glm::lowp_int16
detail::int16 lowp_int16
Low precision 16 bit signed integer type.
Definition: fwd.hpp:133
glm::u16vec1
highp_u16vec1 u16vec1
Default precision 16 bit unsigned integer scalar type.
Definition: fwd.hpp:1082
glm::ivec3
highp_ivec3 ivec3
3 components vector of signed integer numbers.
Definition: type_vec.hpp:449
glm::u32
detail::uint32 u32
32 bit unsigned integer type.
Definition: fwd.hpp:931
glm::dvec2
highp_dvec2 dvec2
2 components vector of double-precision floating-point numbers.
Definition: type_vec.hpp:417
glm::lowp_uint16
detail::uint16 lowp_uint16
Low precision 16 bit unsigned integer type.
Definition: fwd.hpp:736
glm::fvec3
highp_f32vec3 fvec3
Default single-precision floating-point vector of 3 components.
Definition: fwd.hpp:2364
glm::fmat3x3
highp_f32mat3x3 fmat3x3
Default single-precision floating-point 3x3 matrix.
Definition: fwd.hpp:2388
glm::i64vec4
highp_i64vec4 i64vec4
Default precision 64 bit signed integer vector of 4 components type.
Definition: fwd.hpp:723
glm::GLM_ALIGNED_TYPEDEF
GLM_ALIGNED_TYPEDEF(f64quat, aligned_f64quat, 32)
Double-precision floating-point aligned quaternion.
glm::mediump_u8
detail::uint8 mediump_u8
Medium precision 8 bit unsigned integer type.
Definition: fwd.hpp:816
glm::highp_i64
detail::int64 highp_i64
High precision 64 bit signed integer type.
Definition: fwd.hpp:269
glm::u32vec2
highp_u32vec2 u32vec2
Default precision 32 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:1165
glm::u8vec4
highp_u8vec4 u8vec4
Default precision 8 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:1014
glm::uvec3
highp_uvec3 uvec3
3 components vector of unsigned integer numbers.
Definition: type_vec.hpp:476
glm::highp_int64_t
detail::int64 highp_int64_t
High precision 64 bit signed integer type.
Definition: fwd.hpp:253
glm::i64vec2
highp_i64vec2 i64vec2
Default precision 64 bit signed integer vector of 2 components type.
Definition: fwd.hpp:715
glm::int32_t
detail::int32 int32_t
32 bit signed integer type.
Definition: fwd.hpp:305
glm::i16vec4
highp_i16vec4 i16vec4
Default precision 16 bit signed integer vector of 4 components type.
Definition: fwd.hpp:485
glm::mediump_i32
detail::int32 mediump_i32
Medium precision 32 bit signed integer type.
Definition: fwd.hpp:217
glm::mat2
mat2x2 mat2
2 columns of 2 components matrix of floating-point numbers.
Definition: type_mat.hpp:432
glm::lowp_int8
detail::int8 lowp_int8
Low precision 8 bit signed integer type.
Definition: fwd.hpp:129
glm::u64
detail::uint64 u64
64 bit unsigned integer type.
Definition: fwd.hpp:935
glm::lowp_u8
detail::uint8 lowp_u8
Low precision 8 bit unsigned integer type.
Definition: fwd.hpp:766
glm::i8
detail::int8 i8
8 bit signed integer type.
Definition: fwd.hpp:314
glm::mediump_uint8
detail::uint8 mediump_uint8
Medium precision 8 bit unsigned integer type.
Definition: fwd.hpp:784
glm::lowp_uint32_t
detail::uint32 lowp_uint32_t
Low precision 32 bit unsigned integer type.
Definition: fwd.hpp:757
glm::mediump_i64
detail::int64 mediump_i64
Medium precision 64 bit signed integer type.
Definition: fwd.hpp:221
glm::i64vec3
highp_i64vec3 i64vec3
Default precision 64 bit signed integer vector of 3 components type.
Definition: fwd.hpp:719
glm::highp_i32
detail::int32 highp_i32
High precision 32 bit signed integer type.
Definition: fwd.hpp:265
glm::lowp_u32
detail::uint32 lowp_u32
Low precision 32 bit unsigned integer type.
Definition: fwd.hpp:774
glm::highp_i16
detail::int16 highp_i16
High precision 16 bit signed integer type.
Definition: fwd.hpp:261
glm::highp_i8
detail::int8 highp_i8
High precision 8 bit signed integer type.
Definition: fwd.hpp:257
glm::u32vec3
highp_u32vec3 u32vec3
Default precision 32 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:1169
glm::mediump_u32
detail::uint32 mediump_u32
Medium precision 32 bit unsigned integer type.
Definition: fwd.hpp:824
glm::fvec2
highp_f32vec2 fvec2
Default single-precision floating-point vector of 2 components.
Definition: fwd.hpp:2360
glm::mediump_int8
detail::int8 mediump_int8
Medium precision 8 bit signed integer type.
Definition: fwd.hpp:177
glm::highp_u32
detail::uint32 highp_u32
Medium precision 32 bit unsigned integer type.
Definition: fwd.hpp:874
glm::uvec4
highp_uvec4 uvec4
4 components vector of unsigned integer numbers.
Definition: type_vec.hpp:481
glm::mediump_uint64_t
detail::uint64 mediump_uint64_t
Medium precision 64 bit unsigned integer type.
Definition: fwd.hpp:812
glm::i32vec1
highp_i32vec1 i32vec1
Default precision 32 bit signed integer scalar type.
Definition: fwd.hpp:552
glm::highp_u8
detail::uint8 highp_u8
Medium precision 8 bit unsigned integer type.
Definition: fwd.hpp:866
glm::u16vec3
highp_u16vec3 u16vec3
Default precision 16 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:1090
glm::dvec4
highp_dvec4 dvec4
4 components vector of double-precision floating-point numbers.
Definition: type_vec.hpp:427
glm::mat3
mat3x3 mat3
3 columns of 3 components matrix of floating-point numbers.
Definition: type_mat.hpp:437
glm::mat2x2
highp_mat2x2 mat2x2
2 columns of 2 components matrix of floating-point numbers.
Definition: type_mat.hpp:385
glm::i16vec2
highp_i16vec2 i16vec2
Default precision 16 bit signed integer vector of 2 components type.
Definition: fwd.hpp:477
glm::i32vec4
highp_i32vec4 i32vec4
Default precision 32 bit signed integer vector of 4 components type.
Definition: fwd.hpp:564
glm::lowp_int64
detail::int64 lowp_int64
Low precision 64 bit signed integer type.
Definition: fwd.hpp:141
glm::f32mat2x4
highp_f32mat2x4 f32mat2x4
Default single-precision floating-point 2x4 matrix.
Definition: fwd.hpp:2450
glm::f32mat3x2
highp_f32mat3x2 f32mat3x2
Default single-precision floating-point 3x2 matrix.
Definition: fwd.hpp:2454
glm::f64vec4
highp_f64vec4 f64vec4
Default double-precision floating-point vector of 4 components.
Definition: fwd.hpp:2544
glm::lowp_i32
detail::int32 lowp_i32
Low precision 32 bit signed integer type.
Definition: fwd.hpp:169
glm::vec2
highp_vec2 vec2
2 components vector of floating-point numbers.
Definition: type_vec.hpp:390
glm::mediump_uint64
detail::uint64 mediump_uint64
Medium precision 64 bit unsigned integer type.
Definition: fwd.hpp:796
glm::f32vec2
highp_f32vec2 f32vec2
Default single-precision floating-point vector of 2 components.
Definition: fwd.hpp:2430
glm::u16
detail::uint16 u16
16 bit unsigned integer type.
Definition: fwd.hpp:927
glm::uvec2
highp_uvec2 uvec2
2 components vector of unsigned integer numbers.
Definition: type_vec.hpp:471
glm::f64vec1
highp_f64vec1 f64vec1
Default double-precision floating-point vector of 1 components.
Definition: fwd.hpp:2532
glm::fvec4
highp_f32vec4 fvec4
Default single-precision floating-point vector of 4 components.
Definition: fwd.hpp:2368
glm::mediump_i8
detail::int8 mediump_i8
Medium precision 8 bit signed integer type.
Definition: fwd.hpp:209
glm::f32mat4x4
highp_f32mat4x4 f32mat4x4
Default single-precision floating-point 4x4 matrix.
Definition: fwd.hpp:2474
glm::f64mat2x2
highp_f64mat2x2 f64mat2x2
Default double-precision floating-point 2x2 matrix.
Definition: fwd.hpp:2548
glm::float64_t
highp_float64_t float64_t
Default 64 bit double-precision floating-point scalar.
Definition: fwd.hpp:1530
glm::u8vec1
highp_u8vec1 u8vec1
Default precision 8 bit unsigned integer scalar type.
Definition: fwd.hpp:1002
glm::fmat4x2
highp_f32mat4x2 fmat4x2
Default single-precision floating-point 4x2 matrix.
Definition: fwd.hpp:2396
glm::u8vec2
highp_u8vec2 u8vec2
Default precision 8 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:1006
glm::u64vec1
highp_u64vec1 u64vec1
Default precision 64 bit unsigned integer scalar type.
Definition: fwd.hpp:1320
glm::highp_uint8
detail::uint8 highp_uint8
Medium precision 8 bit unsigned integer type.
Definition: fwd.hpp:834
glm::mediump_u16
detail::uint16 mediump_u16
Medium precision 16 bit unsigned integer type.
Definition: fwd.hpp:820
glm::f64mat3x3
highp_f64mat3x3 f64mat3x3
Default double-precision floating-point 3x3 matrix.
Definition: fwd.hpp:2564
glm::mediump_uint32
detail::uint32 mediump_uint32
Medium precision 32 bit unsigned integer type.
Definition: fwd.hpp:792
glm::f32mat4x2
highp_f32mat4x2 f32mat4x2
Default single-precision floating-point 4x2 matrix.
Definition: fwd.hpp:2466
glm::highp_int16
detail::int16 highp_int16
High precision 16 bit signed integer type.
Definition: fwd.hpp:229
glm::highp_int32
detail::int32 highp_int32
High precision 32 bit signed integer type.
Definition: fwd.hpp:233
glm::mediump_int8_t
detail::int8 mediump_int8_t
Medium precision 8 bit signed integer type.
Definition: fwd.hpp:193
glm::f32quat
highp_f32quat f32quat
Default single-precision floating-point quaternion.
Definition: fwd.hpp:2490
glm::mat4x4
highp_mat4x4 mat4x4
4 columns of 4 components matrix of floating-point numbers.
Definition: type_mat.hpp:425
glm::i8vec4
highp_i8vec4 i8vec4
Default precision 8 bit signed integer vector of 4 components type.
Definition: fwd.hpp:405
glm::highp_int8
detail::int8 highp_int8
High precision 8 bit signed integer type.
Definition: fwd.hpp:225
glm::f64mat2x4
highp_f64mat2x4 f64mat2x4
Default double-precision floating-point 2x4 matrix.
Definition: fwd.hpp:2556
glm::u16vec4
highp_u16vec4 u16vec4
Default precision 16 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:1094
glm::u64vec2
highp_u64vec2 u64vec2
Default precision 64 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:1324
glm::highp_uint64_t
detail::uint64 highp_uint64_t
Medium precision 64 bit unsigned integer type.
Definition: fwd.hpp:862
glm::lowp_i8
detail::int8 lowp_i8
Low precision 8 bit signed integer type.
Definition: fwd.hpp:161
glm::f32vec1
highp_f32vec1 f32vec1
Default single-precision floating-point vector of 1 components.
Definition: fwd.hpp:2426
glm::uint32_t
detail::uint32 uint32_t
32 bit unsigned integer type.
Definition: fwd.hpp:914
glm::u8
detail::uint8 u8
8 bit unsigned integer type.
Definition: fwd.hpp:923
glm::lowp_u16
detail::uint16 lowp_u16
Low precision 16 bit unsigned integer type.
Definition: fwd.hpp:770
glm::fmat2x4
highp_f32mat2x4 fmat2x4
Default single-precision floating-point 2x4 matrix.
Definition: fwd.hpp:2380
glm::fvec1
highp_f32vec1 fvec1
Default single-precision floating-point vector of 1 components.
Definition: fwd.hpp:2356
glm::mat3x3
highp_mat3x3 mat3x3
3 columns of 3 components matrix of floating-point numbers.
Definition: type_mat.hpp:405
glm::lowp_i16
detail::int16 lowp_i16
Low precision 16 bit signed integer type.
Definition: fwd.hpp:165
glm::lowp_uint8_t
detail::uint8 lowp_uint8_t
Low precision 8 bit unsigned integer type.
Definition: fwd.hpp:749
glm::i32vec2
highp_i32vec2 i32vec2
Default precision 32 bit signed integer vector of 2 components type.
Definition: fwd.hpp:556
glm
Definition: _noise.hpp:40
glm::mediump_uint16
detail::uint16 mediump_uint16
Medium precision 16 bit unsigned integer type.
Definition: fwd.hpp:788
glm::ivec4
highp_ivec4 ivec4
4 components vector of signed integer numbers.
Definition: type_vec.hpp:454
glm::f64quat
highp_f64quat f64quat
Default double-precision floating-point quaternion.
Definition: fwd.hpp:2596
glm::highp_int8_t
detail::int8 highp_int8_t
High precision 8 bit signed integer type.
Definition: fwd.hpp:241
glm::highp_uint8_t
detail::uint8 highp_uint8_t
Medium precision 8 bit unsigned integer type.
Definition: fwd.hpp:850
glm::i8vec1
highp_i8vec1 i8vec1
Default precision 8 bit signed integer scalar type.
Definition: fwd.hpp:393
glm::i16vec1
highp_i16vec1 i16vec1
Default precision 16 bit signed integer scalar type.
Definition: fwd.hpp:473
glm::mediump_int64_t
detail::int64 mediump_int64_t
Medium precision 64 bit signed integer type.
Definition: fwd.hpp:205
glm::fmat2x2
highp_f32mat2x2 fmat2x2
Default single-precision floating-point 2x2 matrix.
Definition: fwd.hpp:2372
glm::lowp_int8_t
detail::int8 lowp_int8_t
Low precision 8 bit signed integer type.
Definition: fwd.hpp:145
glm::highp_uint16
detail::uint16 highp_uint16
Medium precision 16 bit unsigned integer type.
Definition: fwd.hpp:838
glm::lowp_uint64
detail::uint64 lowp_uint64
Low precision 64 bit unsigned integer type.
Definition: fwd.hpp:744
glm::fmat2x3
highp_f32mat2x3 fmat2x3
Default single-precision floating-point 2x3 matrix.
Definition: fwd.hpp:2376
glm::float32_t
highp_float32_t float32_t
Default 32 bit single-precision floating-point scalar.
Definition: fwd.hpp:1526
glm::i8vec3
highp_i8vec3 i8vec3
Default precision 8 bit signed integer vector of 3 components type.
Definition: fwd.hpp:401
glm::vec4
highp_vec4 vec4
4 components vector of floating-point numbers.
Definition: type_vec.hpp:400
glm::fmat3x2
highp_f32mat3x2 fmat3x2
Default single-precision floating-point 3x2 matrix.
Definition: fwd.hpp:2384
glm::mediump_i16
detail::int16 mediump_i16
Medium precision 16 bit signed integer type.
Definition: fwd.hpp:213
glm::mediump_uint16_t
detail::uint16 mediump_uint16_t
Medium precision 16 bit unsigned integer type.
Definition: fwd.hpp:804
glm::u32vec4
highp_u32vec4 u32vec4
Default precision 32 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:1173
glm::f64mat3x4
highp_f64mat3x4 f64mat3x4
Default double-precision floating-point 3x4 matrix.
Definition: fwd.hpp:2568
glm::lowp_uint16_t
detail::uint16 lowp_uint16_t
Low precision 16 bit unsigned integer type.
Definition: fwd.hpp:753
glm::mediump_int16
detail::int16 mediump_int16
Medium precision 16 bit signed integer type.
Definition: fwd.hpp:181
glm::fmat3x4
highp_f32mat3x4 fmat3x4
Default single-precision floating-point 3x4 matrix.
Definition: fwd.hpp:2392
glm::fmat4x3
highp_f32mat4x3 fmat4x3
Default single-precision floating-point 4x3 matrix.
Definition: fwd.hpp:2400
glm::u8vec3
highp_u8vec3 u8vec3
Default precision 8 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:1010
glm::f64vec3
highp_f64vec3 f64vec3
Default double-precision floating-point vector of 3 components.
Definition: fwd.hpp:2540
glm::vec3
highp_vec3 vec3
3 components vector of floating-point numbers.
Definition: type_vec.hpp:395
glm::u64vec4
highp_u64vec4 u64vec4
Default precision 64 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:1332
glm::mediump_int16_t
detail::int16 mediump_int16_t
Medium precision 16 bit signed integer type.
Definition: fwd.hpp:197
glm::lowp_int16_t
detail::int16 lowp_int16_t
Low precision 16 bit signed integer type.
Definition: fwd.hpp:149
glm::dvec3
highp_dvec3 dvec3
3 components vector of double-precision floating-point numbers.
Definition: type_vec.hpp:422
glm::f64mat4x3
highp_f64mat4x3 f64mat4x3
Default double-precision floating-point 4x3 matrix.
Definition: fwd.hpp:2576
glm::mediump_uint32_t
detail::uint32 mediump_uint32_t
Medium precision 32 bit unsigned integer type.
Definition: fwd.hpp:808
glm::mediump_int32_t
detail::int32 mediump_int32_t
Medium precision 32 bit signed integer type.
Definition: fwd.hpp:201
glm::uint8_t
detail::uint8 uint8_t
8 bit unsigned integer type.
Definition: fwd.hpp:906
glm::f64mat3x2
highp_f64mat3x2 f64mat3x2
Default double-precision floating-point 3x2 matrix.
Definition: fwd.hpp:2560
glm::f32mat2x2
highp_f32mat2x2 f32mat2x2
Default single-precision floating-point 2x2 matrix.
Definition: fwd.hpp:2442
glm::f32mat3x3
highp_f32mat3x3 f32mat3x3
Default single-precision floating-point 3x3 matrix.
Definition: fwd.hpp:2458
glm::highp_uint16_t
detail::uint16 highp_uint16_t
Medium precision 16 bit unsigned integer type.
Definition: fwd.hpp:854
glm::i8vec2
highp_i8vec2 i8vec2
Default precision 8 bit signed integer vector of 2 components type.
Definition: fwd.hpp:397
glm::highp_int16_t
detail::int16 highp_int16_t
High precision 16 bit signed integer type.
Definition: fwd.hpp:245
glm::lowp_int32
detail::int32 lowp_int32
Low precision 32 bit signed integer type.
Definition: fwd.hpp:137
glm::highp_u64
detail::uint64 highp_u64
Medium precision 64 bit unsigned integer type.
Definition: fwd.hpp:878
glm::f64mat4x2
highp_f64mat4x2 f64mat4x2
Default double-precision floating-point 4x2 matrix.
Definition: fwd.hpp:2572
glm::mediump_int32
detail::int32 mediump_int32
Medium precision 32 bit signed integer type.
Definition: fwd.hpp:185
glm::int64_t
detail::int64 int64_t
64 bit signed integer type.
Definition: fwd.hpp:309
glm::ivec2
highp_ivec2 ivec2
2 components vector of signed integer numbers.
Definition: type_vec.hpp:444
glm::lowp_u64
detail::uint64 lowp_u64
Low precision 64 bit unsigned integer type.
Definition: fwd.hpp:778
glm::mediump_u64
detail::uint64 mediump_u64
Medium precision 64 bit unsigned integer type.
Definition: fwd.hpp:828
glm::lowp_uint64_t
detail::uint64 lowp_uint64_t
Low precision 64 bit unsigned integer type.
Definition: fwd.hpp:761
glm::highp_uint32_t
detail::uint32 highp_uint32_t
Medium precision 32 bit unsigned integer type.
Definition: fwd.hpp:858
glm::i16vec3
highp_i16vec3 i16vec3
Default precision 16 bit signed integer vector of 3 components type.
Definition: fwd.hpp:481
glm::fmat4x4
highp_f32mat4x4 fmat4x4
Default single-precision floating-point 4x4 matrix.
Definition: fwd.hpp:2404
glm::highp_int32_t
detail::int32 highp_int32_t
32 bit signed integer type.
Definition: fwd.hpp:249
glm::uint16_t
detail::uint16 uint16_t
16 bit unsigned integer type.
Definition: fwd.hpp:910
glm::f32vec3
highp_f32vec3 f32vec3
Default single-precision floating-point vector of 3 components.
Definition: fwd.hpp:2434
glm::f64mat2x3
highp_f64mat2x3 f64mat2x3
Default double-precision floating-point 2x3 matrix.
Definition: fwd.hpp:2552
glm::f64mat4x4
highp_f64mat4x4 f64mat4x4
Default double-precision floating-point 4x4 matrix.
Definition: fwd.hpp:2580
glm::highp_uint32
detail::uint32 highp_uint32
Medium precision 32 bit unsigned integer type.
Definition: fwd.hpp:842
glm::highp_u16
detail::uint16 highp_u16
Medium precision 16 bit unsigned integer type.
Definition: fwd.hpp:870
glm::mat4
mat4x4 mat4
4 columns of 4 components matrix of floating-point numbers.
Definition: type_mat.hpp:442
glm::f32mat2x3
highp_f32mat2x3 f32mat2x3
Default single-precision floating-point 2x3 matrix.
Definition: fwd.hpp:2446
glm::mediump_uint8_t
detail::uint8 mediump_uint8_t
Medium precision 8 bit unsigned integer type.
Definition: fwd.hpp:800
glm::i32
detail::int32 i32
32 bit signed integer type.
Definition: fwd.hpp:322
glm::f32vec4
highp_f32vec4 f32vec4
Default single-precision floating-point vector of 4 components.
Definition: fwd.hpp:2438
glm::i32vec3
highp_i32vec3 i32vec3
Default precision 32 bit signed integer vector of 3 components type.
Definition: fwd.hpp:560
glm::u16vec2
highp_u16vec2 u16vec2
Default precision 16 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:1086
glm::lowp_uint8
detail::uint8 lowp_uint8
Low precision 8 bit unsigned integer type.
Definition: fwd.hpp:732
glm::i64vec1
highp_i64vec1 i64vec1
Default precision 64 bit signed integer scalar type.
Definition: fwd.hpp:711
glm::i16
detail::int16 i16
16 bit signed integer type.
Definition: fwd.hpp:318
glm::f32mat3x4
highp_f32mat3x4 f32mat3x4
Default single-precision floating-point 3x4 matrix.
Definition: fwd.hpp:2462
glm::uint64_t
detail::uint64 uint64_t
64 bit unsigned integer type.
Definition: fwd.hpp:918
glm::highp_int64
detail::int64 highp_int64
High precision 64 bit signed integer type.
Definition: fwd.hpp:237
glm::u32vec1
highp_u32vec1 u32vec1
Default precision 32 bit unsigned integer scalar type.
Definition: fwd.hpp:1161
glm::int16_t
detail::int16 int16_t
16 bit signed integer type.
Definition: fwd.hpp:301
glm::f32mat4x3
highp_f32mat4x3 f32mat4x3
Default single-precision floating-point 4x3 matrix.
Definition: fwd.hpp:2470
glm::mediump_int64
detail::int64 mediump_int64
Medium precision 64 bit signed integer type.
Definition: fwd.hpp:189
glm::lowp_int32_t
detail::int32 lowp_int32_t
Low precision 32 bit signed integer type.
Definition: fwd.hpp:153
glm::f64vec2
highp_f64vec2 f64vec2
Default double-precision floating-point vector of 2 components.
Definition: fwd.hpp:2536
glm::highp_uint64
detail::uint64 highp_uint64
Medium precision 64 bit unsigned integer type.
Definition: fwd.hpp:846
glm::i64
detail::int64 i64
64 bit signed integer type.
Definition: fwd.hpp:326
glm::u64vec3
highp_u64vec3 u64vec3
Default precision 64 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:1328
glm::lowp_i64
detail::int64 lowp_i64
Low precision 64 bit signed integer type.
Definition: fwd.hpp:173
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00116.html000066400000000000000000000144571356361734700216550ustar00rootroot00000000000000 0.9.7: type_float.hpp File Reference
Typedefs
type_float.hpp File Reference

Go to the source code of this file.

Typedefs

typedef float float32
 
typedef double float64
 
typedef highp_float_t highp_float
 
typedef lowp_float_t lowp_float
 
typedef mediump_float_t mediump_float
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2008-08-22 / 2011-06-15
Author
Christophe Riccio

Definition in file type_float.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00116_source.html000066400000000000000000000315631356361734700232320ustar00rootroot00000000000000 0.9.7: type_float.hpp Source File
type_float.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "setup.hpp"
36 
37 namespace glm{
38 namespace detail
39 {
40  typedef float float32;
41  typedef double float64;
42 }//namespace detail
43 
44  typedef float lowp_float_t;
45  typedef float mediump_float_t;
46  typedef double highp_float_t;
47 
50 
56  typedef lowp_float_t lowp_float;
57 
63  typedef mediump_float_t mediump_float;
64 
70  typedef highp_float_t highp_float;
71 
72 #if(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
73  typedef mediump_float float_t;
74 #elif(defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
75  typedef highp_float float_t;
76 #elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
77  typedef mediump_float float_t;
78 #elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && defined(GLM_PRECISION_LOWP_FLOAT))
79  typedef lowp_float float_t;
80 #else
81 # error "GLM error: multiple default precision requested for floating-point types"
82 #endif
83 
84  typedef float float32;
85  typedef double float64;
86 
88 // check type sizes
89 #ifndef GLM_STATIC_ASSERT_NULL
90  GLM_STATIC_ASSERT(sizeof(glm::float32) == 4, "float32 size isn't 4 bytes on this platform");
91  GLM_STATIC_ASSERT(sizeof(glm::float64) == 8, "float64 size isn't 8 bytes on this platform");
92 #endif//GLM_STATIC_ASSERT_NULL
93 
95 
96 }//namespace glm
glm::lowp_float
lowp_float_t lowp_float
Low precision floating-point numbers.
Definition: type_float.hpp:56
glm::float32
float float32
Default 32 bit single-precision floating-point scalar.
Definition: type_float.hpp:84
glm
Definition: _noise.hpp:40
glm::mediump_float
mediump_float_t mediump_float
Medium precision floating-point numbers.
Definition: type_float.hpp:63
setup.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::float64
double float64
Default 64 bit double-precision floating-point scalar.
Definition: type_float.hpp:85
glm::highp_float
highp_float_t highp_float
High precision floating-point numbers.
Definition: type_float.hpp:70
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00117.html000066400000000000000000000103521356361734700216440ustar00rootroot00000000000000 0.9.7: type_gentype.hpp File Reference
type_gentype.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2008-10-05 / 2011-06-15
Author
Christophe Riccio

Definition in file type_gentype.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00117_source.html000066400000000000000000000741741356361734700232400ustar00rootroot00000000000000 0.9.7: type_gentype.hpp Source File
type_gentype.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 namespace glm
36 {
37  enum profile
38  {
39  nice,
40  fast,
41  simd
42  };
43 
44  typedef std::size_t sizeType;
45 
46 namespace detail
47 {
48  template
49  <
50  typename VALTYPE,
51  template <typename> class TYPE
52  >
53  struct genType
54  {
55  public:
56  enum ctor{null};
57 
58  typedef VALTYPE value_type;
59  typedef VALTYPE & value_reference;
60  typedef VALTYPE * value_pointer;
61  typedef VALTYPE const * value_const_pointer;
62  typedef TYPE<bool> bool_type;
63 
64  typedef sizeType size_type;
65  static bool is_vector();
66  static bool is_matrix();
67 
68  typedef TYPE<VALTYPE> type;
69  typedef TYPE<VALTYPE> * pointer;
70  typedef TYPE<VALTYPE> const * const_pointer;
71  typedef TYPE<VALTYPE> const * const const_pointer_const;
72  typedef TYPE<VALTYPE> * const pointer_const;
73  typedef TYPE<VALTYPE> & reference;
74  typedef TYPE<VALTYPE> const & const_reference;
75  typedef TYPE<VALTYPE> const & param_type;
76 
78  // Address (Implementation details)
79 
80  value_const_pointer value_address() const{return value_pointer(this);}
81  value_pointer value_address(){return value_pointer(this);}
82 
83  //protected:
84  // enum kind
85  // {
86  // GEN_TYPE,
87  // VEC_TYPE,
88  // MAT_TYPE
89  // };
90 
91  // typedef typename TYPE::kind kind;
92  };
93 
94  template
95  <
96  typename VALTYPE,
97  template <typename> class TYPE
98  >
99  bool genType<VALTYPE, TYPE>::is_vector()
100  {
101  return true;
102  }
103 /*
104  template <typename valTypeT, unsigned int colT, unsigned int rowT, profile proT = nice>
105  class base
106  {
107  public:
109  // Traits
110 
111  typedef sizeType size_type;
112  typedef valTypeT value_type;
113 
114  typedef base<value_type, colT, rowT> class_type;
115 
116  typedef base<bool, colT, rowT> bool_type;
117  typedef base<value_type, rowT, 1> col_type;
118  typedef base<value_type, colT, 1> row_type;
119  typedef base<value_type, rowT, colT> transpose_type;
120 
121  static size_type col_size();
122  static size_type row_size();
123  static size_type value_size();
124  static bool is_scalar();
125  static bool is_vector();
126  static bool is_matrix();
127 
128  private:
129  // Data
130  col_type value[colT];
131 
132  public:
134  // Constructors
135  base();
136  base(class_type const & m);
137 
138  explicit base(T const & x);
139  explicit base(value_type const * const x);
140  explicit base(col_type const * const x);
141 
143  // Conversions
144  template <typename vU, uint cU, uint rU, profile pU>
145  explicit base(base<vU, cU, rU, pU> const & m);
146 
148  // Accesses
149  col_type& operator[](size_type i);
150  col_type const & operator[](size_type i) const;
151 
153  // Unary updatable operators
154  class_type& operator= (class_type const & x);
155  class_type& operator+= (T const & x);
156  class_type& operator+= (class_type const & x);
157  class_type& operator-= (T const & x);
158  class_type& operator-= (class_type const & x);
159  class_type& operator*= (T const & x);
160  class_type& operator*= (class_type const & x);
161  class_type& operator/= (T const & x);
162  class_type& operator/= (class_type const & x);
163  class_type& operator++ ();
164  class_type& operator-- ();
165  };
166 */
167 
168  //template <typename T>
169  //struct traits
170  //{
171  // static const bool is_signed = false;
172  // static const bool is_float = false;
173  // static const bool is_vector = false;
174  // static const bool is_matrix = false;
175  // static const bool is_genType = false;
176  // static const bool is_genIType = false;
177  // static const bool is_genUType = false;
178  //};
179 
180  //template <>
181  //struct traits<half>
182  //{
183  // static const bool is_float = true;
184  // static const bool is_genType = true;
185  //};
186 
187  //template <>
188  //struct traits<float>
189  //{
190  // static const bool is_float = true;
191  // static const bool is_genType = true;
192  //};
193 
194  //template <>
195  //struct traits<double>
196  //{
197  // static const bool is_float = true;
198  // static const bool is_genType = true;
199  //};
200 
201  //template <typename genType>
202  //struct desc
203  //{
204  // typedef genType type;
205  // typedef genType * pointer;
206  // typedef genType const* const_pointer;
207  // typedef genType const *const const_pointer_const;
208  // typedef genType *const pointer_const;
209  // typedef genType & reference;
210  // typedef genType const& const_reference;
211  // typedef genType const& param_type;
212 
213  // typedef typename genType::value_type value_type;
214  // typedef typename genType::size_type size_type;
215  // static const typename size_type value_size;
216  //};
217 
218  //template <typename genType>
219  //const typename desc<genType>::size_type desc<genType>::value_size = genType::value_size();
220 
221 }//namespace detail
222 }//namespace glm
223 
224 //#include "type_gentype.inl"
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00118.html000066400000000000000000000103411356361734700216430ustar00rootroot00000000000000 0.9.7: type_half.hpp File Reference
type_half.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2008-08-17 / 2011-09-20
Author
Christophe Riccio

Definition in file type_half.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00118_source.html000066400000000000000000000121341356361734700232250ustar00rootroot00000000000000 0.9.7: type_half.hpp Source File
type_half.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "setup.hpp"
36 
37 namespace glm{
38 namespace detail
39 {
40  typedef short hdata;
41 
42  GLM_FUNC_DECL float toFloat32(hdata value);
43  GLM_FUNC_DECL hdata toFloat16(float const & value);
44 
45 }//namespace detail
46 }//namespace glm
47 
48 #include "type_half.inl"
glm
Definition: _noise.hpp:40
setup.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00119.html000066400000000000000000000240541356361734700216520ustar00rootroot00000000000000 0.9.7: type_int.hpp File Reference
Typedefs
type_int.hpp File Reference

Go to the source code of this file.

Typedefs

typedef detail::highp_int_t highp_int
 
typedef detail::highp_uint_t highp_uint
 
typedef detail::int16 int16
 
typedef detail::int32 int32
 
typedef detail::int64 int64
 
typedef detail::int8 int8
 
typedef detail::lowp_int_t lowp_int
 
typedef detail::lowp_uint_t lowp_uint
 
typedef detail::mediump_int_t mediump_int
 
typedef detail::mediump_uint_t mediump_uint
 
typedef unsigned int uint
 
typedef detail::uint16 uint16
 
typedef detail::uint32 uint32
 
typedef detail::uint64 uint64
 
typedef detail::uint8 uint8
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2008-08-22 / 2013-03-30
Author
Christophe Riccio

Definition in file type_int.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00119_source.html000066400000000000000000001573001356361734700232330ustar00rootroot00000000000000 0.9.7: type_int.hpp Source File
type_int.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "setup.hpp"
36 #if GLM_HAS_MAKE_SIGNED
37 # include <type_traits>
38 #endif
39 
40 #if GLM_HAS_EXTENDED_INTEGER_TYPE
41 # include <cstdint>
42 #endif
43 
44 namespace glm{
45 namespace detail
46 {
47 # if GLM_HAS_EXTENDED_INTEGER_TYPE
48  typedef std::int8_t int8;
49  typedef std::int16_t int16;
50  typedef std::int32_t int32;
51  typedef std::int64_t int64;
52 
53  typedef std::uint8_t uint8;
54  typedef std::uint16_t uint16;
55  typedef std::uint32_t uint32;
56  typedef std::uint64_t uint64;
57 # else
58 # if(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) // C99 detected, 64 bit types available
59  typedef int64_t sint64;
60  typedef uint64_t uint64;
61 # elif GLM_COMPILER & GLM_COMPILER_VC
62  typedef signed __int64 sint64;
63  typedef unsigned __int64 uint64;
64 # elif GLM_COMPILER & GLM_COMPILER_GCC
65  __extension__ typedef signed long long sint64;
66  __extension__ typedef unsigned long long uint64;
67 # else//unknown compiler
68  typedef signed long long sint64;
69  typedef unsigned long long uint64;
70 # endif//GLM_COMPILER
71 
72  typedef signed char int8;
73  typedef signed short int16;
74  typedef signed int int32;
75  typedef sint64 int64;
76 
77  typedef unsigned char uint8;
78  typedef unsigned short uint16;
79  typedef unsigned int uint32;
80  typedef uint64 uint64;
81 #endif//
82 
83  typedef signed int lowp_int_t;
84  typedef signed int mediump_int_t;
85  typedef signed int highp_int_t;
86 
87  typedef unsigned int lowp_uint_t;
88  typedef unsigned int mediump_uint_t;
89  typedef unsigned int highp_uint_t;
90 
91 # if GLM_HAS_MAKE_SIGNED
92  using std::make_signed;
93  using std::make_unsigned;
94 
95 # else//GLM_HAS_MAKE_SIGNED
96  template <typename genType>
97  struct make_signed
98  {};
99 
100  template <>
101  struct make_signed<char>
102  {
103  typedef char type;
104  };
105 
106  template <>
107  struct make_signed<short>
108  {
109  typedef short type;
110  };
111 
112  template <>
113  struct make_signed<int>
114  {
115  typedef int type;
116  };
117 
118  template <>
119  struct make_signed<long>
120  {
121  typedef long type;
122  };
123 
124  template <>
125  struct make_signed<long long>
126  {
127  typedef long long type;
128  };
129 
130  template <>
131  struct make_signed<unsigned char>
132  {
133  typedef char type;
134  };
135 
136  template <>
137  struct make_signed<unsigned short>
138  {
139  typedef short type;
140  };
141 
142  template <>
143  struct make_signed<unsigned int>
144  {
145  typedef int type;
146  };
147 
148  template <>
149  struct make_signed<unsigned long>
150  {
151  typedef long type;
152  };
153 
154  template <>
155  struct make_signed<unsigned long long>
156  {
157  typedef long long type;
158  };
159 
160  template <typename genType>
161  struct make_unsigned
162  {};
163 
164  template <>
165  struct make_unsigned<char>
166  {
167  typedef unsigned char type;
168  };
169 
170  template <>
171  struct make_unsigned<short>
172  {
173  typedef unsigned short type;
174  };
175 
176  template <>
177  struct make_unsigned<int>
178  {
179  typedef unsigned int type;
180  };
181 
182  template <>
183  struct make_unsigned<long>
184  {
185  typedef unsigned long type;
186  };
187 
188  template <>
189  struct make_unsigned<long long>
190  {
191  typedef unsigned long long type;
192  };
193 
194  template <>
195  struct make_unsigned<unsigned char>
196  {
197  typedef unsigned char type;
198  };
199 
200  template <>
201  struct make_unsigned<unsigned short>
202  {
203  typedef unsigned short type;
204  };
205 
206  template <>
207  struct make_unsigned<unsigned int>
208  {
209  typedef unsigned int type;
210  };
211 
212  template <>
213  struct make_unsigned<unsigned long>
214  {
215  typedef unsigned long type;
216  };
217 
218  template <>
219  struct make_unsigned<unsigned long long>
220  {
221  typedef unsigned long long type;
222  };
223 # endif//GLM_HAS_MAKE_SIGNED
224 }//namespace detail
225 
226  typedef detail::int8 int8;
227  typedef detail::int16 int16;
228  typedef detail::int32 int32;
229  typedef detail::int64 int64;
230 
231  typedef detail::uint8 uint8;
232  typedef detail::uint16 uint16;
233  typedef detail::uint32 uint32;
234  typedef detail::uint64 uint64;
235 
238 
244  typedef detail::lowp_int_t lowp_int;
245 
251  typedef detail::mediump_int_t mediump_int;
252 
258  typedef detail::highp_int_t highp_int;
259 
265  typedef detail::lowp_uint_t lowp_uint;
266 
272  typedef detail::mediump_uint_t mediump_uint;
273 
279  typedef detail::highp_uint_t highp_uint;
280 
281 #if(!defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
282  typedef mediump_int int_t;
283 #elif(defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
284  typedef highp_int int_t;
285 #elif(!defined(GLM_PRECISION_HIGHP_INT) && defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
286  typedef mediump_int int_t;
287 #elif(!defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && defined(GLM_PRECISION_LOWP_INT))
288  typedef lowp_int int_t;
289 #else
290 # error "GLM error: multiple default precision requested for signed interger types"
291 #endif
292 
293 #if(!defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT))
294  typedef mediump_uint uint_t;
295 #elif(defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT))
296  typedef highp_uint uint_t;
297 #elif(!defined(GLM_PRECISION_HIGHP_UINT) && defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT))
298  typedef mediump_uint uint_t;
299 #elif(!defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && defined(GLM_PRECISION_LOWP_UINT))
300  typedef lowp_uint uint_t;
301 #else
302 # error "GLM error: multiple default precision requested for unsigned interger types"
303 #endif
304 
308  typedef unsigned int uint;
309 
311 
313 // check type sizes
314 #ifndef GLM_STATIC_ASSERT_NULL
315  GLM_STATIC_ASSERT(sizeof(glm::int8) == 1, "int8 size isn't 1 byte on this platform");
316  GLM_STATIC_ASSERT(sizeof(glm::int16) == 2, "int16 size isn't 2 bytes on this platform");
317  GLM_STATIC_ASSERT(sizeof(glm::int32) == 4, "int32 size isn't 4 bytes on this platform");
318  GLM_STATIC_ASSERT(sizeof(glm::int64) == 8, "int64 size isn't 8 bytes on this platform");
319 
320  GLM_STATIC_ASSERT(sizeof(glm::uint8) == 1, "uint8 size isn't 1 byte on this platform");
321  GLM_STATIC_ASSERT(sizeof(glm::uint16) == 2, "uint16 size isn't 2 bytes on this platform");
322  GLM_STATIC_ASSERT(sizeof(glm::uint32) == 4, "uint32 size isn't 4 bytes on this platform");
323  GLM_STATIC_ASSERT(sizeof(glm::uint64) == 8, "uint64 size isn't 8 bytes on this platform");
324 #endif//GLM_STATIC_ASSERT_NULL
325 
326 }//namespace glm
glm::int8_t
detail::int8 int8_t
8 bit signed integer type.
Definition: fwd.hpp:297
glm::int32_t
detail::int32 int32_t
32 bit signed integer type.
Definition: fwd.hpp:305
glm::int32
detail::int32 int32
32 bit signed integer type.
Definition: type_int.hpp:228
glm::uint8
detail::uint8 uint8
8 bit unsigned integer type.
Definition: type_int.hpp:231
glm::int8
detail::int8 int8
8 bit signed integer type.
Definition: type_int.hpp:226
glm::int16
detail::int16 int16
16 bit signed integer type.
Definition: type_int.hpp:227
glm::uint16
detail::uint16 uint16
16 bit unsigned integer type.
Definition: type_int.hpp:232
glm::uint
unsigned int uint
Unsigned integer type.
Definition: type_int.hpp:308
glm::highp_uint
detail::highp_uint_t highp_uint
High precision unsigned integer.
Definition: type_int.hpp:279
glm::uint32_t
detail::uint32 uint32_t
32 bit unsigned integer type.
Definition: fwd.hpp:914
glm::highp_int
detail::highp_int_t highp_int
High precision signed integer.
Definition: type_int.hpp:258
glm
Definition: _noise.hpp:40
setup.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::mediump_int
detail::mediump_int_t mediump_int
Medium precision signed integer.
Definition: type_int.hpp:251
glm::lowp_uint
detail::lowp_uint_t lowp_uint
Low precision unsigned integer.
Definition: type_int.hpp:265
glm::lowp_int
detail::lowp_int_t lowp_int
Low precision signed integer.
Definition: type_int.hpp:244
glm::mediump_uint
detail::mediump_uint_t mediump_uint
Medium precision unsigned integer.
Definition: type_int.hpp:272
glm::uint32
detail::uint32 uint32
32 bit unsigned integer type.
Definition: type_int.hpp:233
glm::uint8_t
detail::uint8 uint8_t
8 bit unsigned integer type.
Definition: fwd.hpp:906
glm::int64_t
detail::int64 int64_t
64 bit signed integer type.
Definition: fwd.hpp:309
glm::uint64
detail::uint64 uint64
64 bit unsigned integer type.
Definition: type_int.hpp:234
glm::int64
detail::int64 int64
64 bit signed integer type.
Definition: type_int.hpp:229
glm::uint16_t
detail::uint16 uint16_t
16 bit unsigned integer type.
Definition: fwd.hpp:910
glm::uint64_t
detail::uint64 uint64_t
64 bit unsigned integer type.
Definition: fwd.hpp:918
glm::int16_t
detail::int16 int16_t
16 bit signed integer type.
Definition: fwd.hpp:301
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00120.html000066400000000000000000001231031356361734700216350ustar00rootroot00000000000000 0.9.7: type_mat.hpp File Reference
Typedefs
type_mat.hpp File Reference

Go to the source code of this file.

Typedefs

typedef highp_dmat2x2 dmat2
 
typedef highp_dmat2x2 dmat2x2
 
typedef highp_dmat2x3 dmat2x3
 
typedef highp_dmat2x4 dmat2x4
 
typedef highp_dmat3x3 dmat3
 
typedef highp_dmat3x2 dmat3x2
 
typedef highp_dmat3x3 dmat3x3
 
typedef highp_dmat3x4 dmat3x4
 
typedef highp_dmat4x4 dmat4
 
typedef highp_dmat4x2 dmat4x2
 
typedef highp_dmat4x3 dmat4x3
 
typedef highp_dmat4x4 dmat4x4
 
typedef tmat2x2< double, highp > highp_dmat2
 
typedef tmat2x2< double, highp > highp_dmat2x2
 
typedef tmat2x3< double, highp > highp_dmat2x3
 
typedef tmat2x4< double, highp > highp_dmat2x4
 
typedef tmat3x3< double, highp > highp_dmat3
 
typedef tmat3x2< double, highp > highp_dmat3x2
 
typedef tmat3x3< double, highp > highp_dmat3x3
 
typedef tmat3x4< double, highp > highp_dmat3x4
 
typedef tmat4x4< double, highp > highp_dmat4
 
typedef tmat4x2< double, highp > highp_dmat4x2
 
typedef tmat4x3< double, highp > highp_dmat4x3
 
typedef tmat4x4< double, highp > highp_dmat4x4
 
typedef tmat2x2< float, highp > highp_mat2
 
typedef tmat2x2< float, highp > highp_mat2x2
 
typedef tmat2x3< float, highp > highp_mat2x3
 
typedef tmat2x4< float, highp > highp_mat2x4
 
typedef tmat3x3< float, highp > highp_mat3
 
typedef tmat3x2< float, highp > highp_mat3x2
 
typedef tmat3x3< float, highp > highp_mat3x3
 
typedef tmat3x4< float, highp > highp_mat3x4
 
typedef tmat4x4< float, highp > highp_mat4
 
typedef tmat4x2< float, highp > highp_mat4x2
 
typedef tmat4x3< float, highp > highp_mat4x3
 
typedef tmat4x4< float, highp > highp_mat4x4
 
typedef tmat2x2< double, lowp > lowp_dmat2
 
typedef tmat2x2< double, lowp > lowp_dmat2x2
 
typedef tmat2x3< double, lowp > lowp_dmat2x3
 
typedef tmat2x4< double, lowp > lowp_dmat2x4
 
typedef tmat3x3< float, lowp > lowp_dmat3
 
typedef tmat3x2< double, lowp > lowp_dmat3x2
 
typedef tmat3x3< double, lowp > lowp_dmat3x3
 
typedef tmat3x4< double, lowp > lowp_dmat3x4
 
typedef tmat4x4< double, lowp > lowp_dmat4
 
typedef tmat4x2< double, lowp > lowp_dmat4x2
 
typedef tmat4x3< double, lowp > lowp_dmat4x3
 
typedef tmat4x4< double, lowp > lowp_dmat4x4
 
typedef tmat2x2< float, lowp > lowp_mat2
 
typedef tmat2x2< float, lowp > lowp_mat2x2
 
typedef tmat2x3< float, lowp > lowp_mat2x3
 
typedef tmat2x4< float, lowp > lowp_mat2x4
 
typedef tmat3x3< float, lowp > lowp_mat3
 
typedef tmat3x2< float, lowp > lowp_mat3x2
 
typedef tmat3x3< float, lowp > lowp_mat3x3
 
typedef tmat3x4< float, lowp > lowp_mat3x4
 
typedef tmat4x4< float, lowp > lowp_mat4
 
typedef tmat4x2< float, lowp > lowp_mat4x2
 
typedef tmat4x3< float, lowp > lowp_mat4x3
 
typedef tmat4x4< float, lowp > lowp_mat4x4
 
typedef mat2x2 mat2
 
typedef highp_mat2x2 mat2x2
 
typedef highp_mat2x3 mat2x3
 
typedef highp_mat2x4 mat2x4
 
typedef mat3x3 mat3
 
typedef highp_mat3x2 mat3x2
 
typedef highp_mat3x3 mat3x3
 
typedef highp_mat3x4 mat3x4
 
typedef mat4x4 mat4
 
typedef highp_mat4x2 mat4x2
 
typedef highp_mat4x3 mat4x3
 
typedef highp_mat4x4 mat4x4
 
typedef tmat2x2< double, mediump > mediump_dmat2
 
typedef tmat2x2< double, mediump > mediump_dmat2x2
 
typedef tmat2x3< double, mediump > mediump_dmat2x3
 
typedef tmat2x4< double, mediump > mediump_dmat2x4
 
typedef tmat3x3< double, mediump > mediump_dmat3
 
typedef tmat3x2< double, mediump > mediump_dmat3x2
 
typedef tmat3x3< double, mediump > mediump_dmat3x3
 
typedef tmat3x4< double, mediump > mediump_dmat3x4
 
typedef tmat4x4< double, mediump > mediump_dmat4
 
typedef tmat4x2< double, mediump > mediump_dmat4x2
 
typedef tmat4x3< double, mediump > mediump_dmat4x3
 
typedef tmat4x4< double, mediump > mediump_dmat4x4
 
typedef tmat2x2< float, mediump > mediump_mat2
 
typedef tmat2x2< float, mediump > mediump_mat2x2
 
typedef tmat2x3< float, mediump > mediump_mat2x3
 
typedef tmat2x4< float, mediump > mediump_mat2x4
 
typedef tmat3x3< float, mediump > mediump_mat3
 
typedef tmat3x2< float, mediump > mediump_mat3x2
 
typedef tmat3x3< float, mediump > mediump_mat3x3
 
typedef tmat3x4< float, mediump > mediump_mat3x4
 
typedef tmat4x4< float, mediump > mediump_mat4
 
typedef tmat4x2< float, mediump > mediump_mat4x2
 
typedef tmat4x3< float, mediump > mediump_mat4x3
 
typedef tmat4x4< float, mediump > mediump_mat4x4
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2010-01-26 / 2011-06-15
Author
Christophe Riccio

Definition in file type_mat.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00120_source.html000066400000000000000000003131541356361734700232240ustar00rootroot00000000000000 0.9.7: type_mat.hpp Source File
type_mat.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "precision.hpp"
36 
37 namespace glm{
38 namespace detail
39 {
40  template <typename T, precision P, template <class, precision> class colType, template <class, precision> class rowType>
41  struct outerProduct_trait{};
42 }//namespace detail
43 
44  template <typename T, precision P> struct tvec2;
45  template <typename T, precision P> struct tvec3;
46  template <typename T, precision P> struct tvec4;
47  template <typename T, precision P> struct tmat2x2;
48  template <typename T, precision P> struct tmat2x3;
49  template <typename T, precision P> struct tmat2x4;
50  template <typename T, precision P> struct tmat3x2;
51  template <typename T, precision P> struct tmat3x3;
52  template <typename T, precision P> struct tmat3x4;
53  template <typename T, precision P> struct tmat4x2;
54  template <typename T, precision P> struct tmat4x3;
55  template <typename T, precision P> struct tmat4x4;
56 
59 
65  typedef tmat2x2<float, lowp> lowp_mat2;
66 
72  typedef tmat2x2<float, mediump> mediump_mat2;
73 
79  typedef tmat2x2<float, highp> highp_mat2;
80 
86  typedef tmat2x2<float, lowp> lowp_mat2x2;
87 
93  typedef tmat2x2<float, mediump> mediump_mat2x2;
94 
100  typedef tmat2x2<float, highp> highp_mat2x2;
101 
103 
106 
112  typedef tmat2x3<float, lowp> lowp_mat2x3;
113 
119  typedef tmat2x3<float, mediump> mediump_mat2x3;
120 
126  typedef tmat2x3<float, highp> highp_mat2x3;
127 
129 
132 
138  typedef tmat2x4<float, lowp> lowp_mat2x4;
139 
145  typedef tmat2x4<float, mediump> mediump_mat2x4;
146 
152  typedef tmat2x4<float, highp> highp_mat2x4;
153 
155 
158 
164  typedef tmat3x2<float, lowp> lowp_mat3x2;
165 
171  typedef tmat3x2<float, mediump> mediump_mat3x2;
172 
178  typedef tmat3x2<float, highp> highp_mat3x2;
179 
181 
184 
190  typedef tmat3x3<float, lowp> lowp_mat3;
191 
197  typedef tmat3x3<float, mediump> mediump_mat3;
198 
204  typedef tmat3x3<float, highp> highp_mat3;
205 
211  typedef tmat3x3<float, lowp> lowp_mat3x3;
212 
218  typedef tmat3x3<float, mediump> mediump_mat3x3;
219 
225  typedef tmat3x3<float, highp> highp_mat3x3;
226 
228 
231 
237  typedef tmat3x4<float, lowp> lowp_mat3x4;
238 
244  typedef tmat3x4<float, mediump> mediump_mat3x4;
245 
251  typedef tmat3x4<float, highp> highp_mat3x4;
252 
254 
257 
263  typedef tmat4x2<float, lowp> lowp_mat4x2;
264 
270  typedef tmat4x2<float, mediump> mediump_mat4x2;
271 
277  typedef tmat4x2<float, highp> highp_mat4x2;
278 
280 
283 
289  typedef tmat4x3<float, lowp> lowp_mat4x3;
290 
296  typedef tmat4x3<float, mediump> mediump_mat4x3;
297 
303  typedef tmat4x3<float, highp> highp_mat4x3;
304 
306 
307 
310 
316  typedef tmat4x4<float, lowp> lowp_mat4;
317 
323  typedef tmat4x4<float, mediump> mediump_mat4;
324 
330  typedef tmat4x4<float, highp> highp_mat4;
331 
337  typedef tmat4x4<float, lowp> lowp_mat4x4;
338 
344  typedef tmat4x4<float, mediump> mediump_mat4x4;
345 
351  typedef tmat4x4<float, highp> highp_mat4x4;
352 
354 
357 
359  // Float definition
360 
361 #if(defined(GLM_PRECISION_LOWP_FLOAT))
362  typedef lowp_mat2x2 mat2x2;
363  typedef lowp_mat2x3 mat2x3;
364  typedef lowp_mat2x4 mat2x4;
365  typedef lowp_mat3x2 mat3x2;
366  typedef lowp_mat3x3 mat3x3;
367  typedef lowp_mat3x4 mat3x4;
368  typedef lowp_mat4x2 mat4x2;
369  typedef lowp_mat4x3 mat4x3;
370  typedef lowp_mat4x4 mat4x4;
371 #elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
372  typedef mediump_mat2x2 mat2x2;
373  typedef mediump_mat2x3 mat2x3;
374  typedef mediump_mat2x4 mat2x4;
375  typedef mediump_mat3x2 mat3x2;
376  typedef mediump_mat3x3 mat3x3;
377  typedef mediump_mat3x4 mat3x4;
378  typedef mediump_mat4x2 mat4x2;
379  typedef mediump_mat4x3 mat4x3;
380  typedef mediump_mat4x4 mat4x4;
381 #else
382  typedef highp_mat2x2 mat2x2;
386 
390  typedef highp_mat2x3 mat2x3;
391 
395  typedef highp_mat2x4 mat2x4;
396 
400  typedef highp_mat3x2 mat3x2;
401 
405  typedef highp_mat3x3 mat3x3;
406 
410  typedef highp_mat3x4 mat3x4;
411 
415  typedef highp_mat4x2 mat4x2;
416 
420  typedef highp_mat4x3 mat4x3;
421 
425  typedef highp_mat4x4 mat4x4;
426 
427 #endif//GLM_PRECISION
428 
432  typedef mat2x2 mat2;
433 
437  typedef mat3x3 mat3;
438 
442  typedef mat4x4 mat4;
443 
445  // Double definition
446 
449 
454  typedef tmat2x2<double, lowp> lowp_dmat2;
455 
460  typedef tmat2x2<double, mediump> mediump_dmat2;
461 
466  typedef tmat2x2<double, highp> highp_dmat2;
467 
472  typedef tmat2x2<double, lowp> lowp_dmat2x2;
473 
478  typedef tmat2x2<double, mediump> mediump_dmat2x2;
479 
484  typedef tmat2x2<double, highp> highp_dmat2x2;
485 
487 
490 
495  typedef tmat2x3<double, lowp> lowp_dmat2x3;
496 
501  typedef tmat2x3<double, mediump> mediump_dmat2x3;
502 
507  typedef tmat2x3<double, highp> highp_dmat2x3;
508 
510 
513 
518  typedef tmat2x4<double, lowp> lowp_dmat2x4;
519 
524  typedef tmat2x4<double, mediump> mediump_dmat2x4;
525 
530  typedef tmat2x4<double, highp> highp_dmat2x4;
531 
533 
536 
541  typedef tmat3x2<double, lowp> lowp_dmat3x2;
542 
547  typedef tmat3x2<double, mediump> mediump_dmat3x2;
548 
553  typedef tmat3x2<double, highp> highp_dmat3x2;
554 
556 
559 
564  typedef tmat3x3<float, lowp> lowp_dmat3;
565 
570  typedef tmat3x3<double, mediump> mediump_dmat3;
571 
576  typedef tmat3x3<double, highp> highp_dmat3;
577 
582  typedef tmat3x3<double, lowp> lowp_dmat3x3;
583 
588  typedef tmat3x3<double, mediump> mediump_dmat3x3;
589 
594  typedef tmat3x3<double, highp> highp_dmat3x3;
595 
597 
600 
605  typedef tmat3x4<double, lowp> lowp_dmat3x4;
606 
611  typedef tmat3x4<double, mediump> mediump_dmat3x4;
612 
617  typedef tmat3x4<double, highp> highp_dmat3x4;
618 
620 
623 
628  typedef tmat4x2<double, lowp> lowp_dmat4x2;
629 
634  typedef tmat4x2<double, mediump> mediump_dmat4x2;
635 
640  typedef tmat4x2<double, highp> highp_dmat4x2;
641 
643 
646 
651  typedef tmat4x3<double, lowp> lowp_dmat4x3;
652 
657  typedef tmat4x3<double, mediump> mediump_dmat4x3;
658 
663  typedef tmat4x3<double, highp> highp_dmat4x3;
664 
666 
669 
674  typedef tmat4x4<double, lowp> lowp_dmat4;
675 
680  typedef tmat4x4<double, mediump> mediump_dmat4;
681 
686  typedef tmat4x4<double, highp> highp_dmat4;
687 
692  typedef tmat4x4<double, lowp> lowp_dmat4x4;
693 
698  typedef tmat4x4<double, mediump> mediump_dmat4x4;
699 
704  typedef tmat4x4<double, highp> highp_dmat4x4;
705 
707 
708 #if(defined(GLM_PRECISION_LOWP_DOUBLE))
709  typedef lowp_dmat2x2 dmat2x2;
710  typedef lowp_dmat2x3 dmat2x3;
711  typedef lowp_dmat2x4 dmat2x4;
712  typedef lowp_dmat3x2 dmat3x2;
713  typedef lowp_dmat3x3 dmat3x3;
714  typedef lowp_dmat3x4 dmat3x4;
715  typedef lowp_dmat4x2 dmat4x2;
716  typedef lowp_dmat4x3 dmat4x3;
717  typedef lowp_dmat4x4 dmat4x4;
718 #elif(defined(GLM_PRECISION_MEDIUMP_DOUBLE))
719  typedef mediump_dmat2x2 dmat2x2;
720  typedef mediump_dmat2x3 dmat2x3;
721  typedef mediump_dmat2x4 dmat2x4;
722  typedef mediump_dmat3x2 dmat3x2;
723  typedef mediump_dmat3x3 dmat3x3;
724  typedef mediump_dmat3x4 dmat3x4;
725  typedef mediump_dmat4x2 dmat4x2;
726  typedef mediump_dmat4x3 dmat4x3;
727  typedef mediump_dmat4x4 dmat4x4;
728 #else //defined(GLM_PRECISION_HIGHP_DOUBLE)
729 
733  typedef highp_dmat2x2 dmat2;
734 
738  typedef highp_dmat3x3 dmat3;
739 
743  typedef highp_dmat4x4 dmat4;
744 
748  typedef highp_dmat2x2 dmat2x2;
749 
753  typedef highp_dmat2x3 dmat2x3;
754 
758  typedef highp_dmat2x4 dmat2x4;
759 
763  typedef highp_dmat3x2 dmat3x2;
764 
768  typedef highp_dmat3x3 dmat3x3;
769 
773  typedef highp_dmat3x4 dmat3x4;
774 
778  typedef highp_dmat4x2 dmat4x2;
779 
783  typedef highp_dmat4x3 dmat4x3;
784 
788  typedef highp_dmat4x4 dmat4x4;
789 
790 #endif//GLM_PRECISION
791 
793 }//namespace glm
glm::highp_mat4x3
tmat4x3< float, highp > highp_mat4x3
4 columns of 3 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:303
glm::highp_mat3x2
tmat3x2< float, highp > highp_mat3x2
3 columns of 2 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:178
glm::lowp_dmat4x4
tmat4x4< double, lowp > lowp_dmat4x4
4 columns of 4 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:692
glm::dmat3x4
highp_dmat3x4 dmat3x4
3 * 4 matrix of double-precision floating-point numbers.
Definition: type_mat.hpp:773
glm::mediump_dmat2x2
tmat2x2< double, mediump > mediump_dmat2x2
2 columns of 2 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:478
glm::mediump_mat2
tmat2x2< float, mediump > mediump_mat2
2 columns of 2 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:72
glm::lowp_mat3x2
tmat3x2< float, lowp > lowp_mat3x2
3 columns of 2 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:164
glm::mat3x4
highp_mat3x4 mat3x4
3 columns of 4 components matrix of floating-point numbers.
Definition: type_mat.hpp:410
glm::mediump_mat2x4
tmat2x4< float, mediump > mediump_mat2x4
2 columns of 4 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:145
glm::mat2
mat2x2 mat2
2 columns of 2 components matrix of floating-point numbers.
Definition: type_mat.hpp:432
glm::lowp_mat2x3
tmat2x3< float, lowp > lowp_mat2x3
2 columns of 3 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:112
glm::mat2x4
highp_mat2x4 mat2x4
2 columns of 4 components matrix of floating-point numbers.
Definition: type_mat.hpp:395
glm::mediump_dmat3
tmat3x3< double, mediump > mediump_dmat3
3 columns of 3 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:570
glm::highp_dmat4x2
tmat4x2< double, highp > highp_dmat4x2
4 columns of 2 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:640
glm::lowp_mat4x2
tmat4x2< float, lowp > lowp_mat4x2
4 columns of 2 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:263
glm::lowp_mat4x4
tmat4x4< float, lowp > lowp_mat4x4
4 columns of 4 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:337
glm::mediump_dmat4x3
tmat4x3< double, mediump > mediump_dmat4x3
4 columns of 3 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:657
glm::mat2x3
highp_mat2x3 mat2x3
2 columns of 3 components matrix of floating-point numbers.
Definition: type_mat.hpp:390
glm::mat3x2
highp_mat3x2 mat3x2
3 columns of 2 components matrix of floating-point numbers.
Definition: type_mat.hpp:400
glm::highp_dmat2
tmat2x2< double, highp > highp_dmat2
2 columns of 2 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:466
glm::lowp_mat4x3
tmat4x3< float, lowp > lowp_mat4x3
4 columns of 3 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:289
glm::mediump_mat3
tmat3x3< float, mediump > mediump_mat3
3 columns of 3 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:197
glm::highp_mat3x3
tmat3x3< float, highp > highp_mat3x3
3 columns of 3 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:225
glm::highp_dmat3x4
tmat3x4< double, highp > highp_dmat3x4
3 columns of 4 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:617
glm::dmat2
highp_dmat2x2 dmat2
2 * 2 matrix of double-precision floating-point numbers.
Definition: type_mat.hpp:733
glm::mat3
mat3x3 mat3
3 columns of 3 components matrix of floating-point numbers.
Definition: type_mat.hpp:437
glm::mat2x2
highp_mat2x2 mat2x2
2 columns of 2 components matrix of floating-point numbers.
Definition: type_mat.hpp:385
glm::lowp_mat2x4
tmat2x4< float, lowp > lowp_mat2x4
2 columns of 4 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:138
glm::lowp_dmat3x3
tmat3x3< double, lowp > lowp_dmat3x3
3 columns of 3 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:582
glm::mediump_mat2x3
tmat2x3< float, mediump > mediump_mat2x3
2 columns of 3 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:119
glm::highp_mat2x3
tmat2x3< float, highp > highp_mat2x3
2 columns of 3 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:126
glm::mediump_dmat3x4
tmat3x4< double, mediump > mediump_dmat3x4
3 columns of 4 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:611
glm::lowp_mat3
tmat3x3< float, lowp > lowp_mat3
3 columns of 3 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:190
glm::lowp_dmat4x3
tmat4x3< double, lowp > lowp_dmat4x3
4 columns of 3 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:651
glm::lowp_dmat3x2
tmat3x2< double, lowp > lowp_dmat3x2
3 columns of 2 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:541
glm::mediump_dmat4
tmat4x4< double, mediump > mediump_dmat4
4 columns of 4 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:680
glm::lowp_dmat3
tmat3x3< float, lowp > lowp_dmat3
3 columns of 3 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:564
glm::mediump_mat3x4
tmat3x4< float, mediump > mediump_mat3x4
3 columns of 4 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:244
glm::mediump_mat2x2
tmat2x2< float, mediump > mediump_mat2x2
2 columns of 2 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:93
glm::highp_mat4
tmat4x4< float, highp > highp_mat4
4 columns of 4 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:330
glm::lowp_dmat2x4
tmat2x4< double, lowp > lowp_dmat2x4
2 columns of 4 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:518
glm::mat4x3
highp_mat4x3 mat4x3
4 columns of 3 components matrix of floating-point numbers.
Definition: type_mat.hpp:420
glm::mat4x4
highp_mat4x4 mat4x4
4 columns of 4 components matrix of floating-point numbers.
Definition: type_mat.hpp:425
glm::mat4x2
highp_mat4x2 mat4x2
4 columns of 2 components matrix of floating-point numbers.
Definition: type_mat.hpp:415
glm::highp_dmat3x2
tmat3x2< double, highp > highp_dmat3x2
3 columns of 2 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:553
glm::lowp_dmat3x4
tmat3x4< double, lowp > lowp_dmat3x4
3 columns of 4 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:605
glm::mediump_dmat4x4
tmat4x4< double, mediump > mediump_dmat4x4
4 columns of 4 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:698
glm::highp_mat2x4
tmat2x4< float, highp > highp_mat2x4
2 columns of 4 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:152
glm::mediump_mat3x3
tmat3x3< float, mediump > mediump_mat3x3
3 columns of 3 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:218
glm::dmat3x2
highp_dmat3x2 dmat3x2
3 * 2 matrix of double-precision floating-point numbers.
Definition: type_mat.hpp:763
glm::highp_dmat2x2
tmat2x2< double, highp > highp_dmat2x2
2 columns of 2 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:484
glm::dmat4
highp_dmat4x4 dmat4
4 * 4 matrix of double-precision floating-point numbers.
Definition: type_mat.hpp:743
glm::dmat4x4
highp_dmat4x4 dmat4x4
4 * 4 matrix of double-precision floating-point numbers.
Definition: type_mat.hpp:788
glm::mat3x3
highp_mat3x3 mat3x3
3 columns of 3 components matrix of floating-point numbers.
Definition: type_mat.hpp:405
glm
Definition: _noise.hpp:40
glm::dmat2x3
highp_dmat2x3 dmat2x3
2 * 3 matrix of double-precision floating-point numbers.
Definition: type_mat.hpp:753
glm::lowp_mat3x3
tmat3x3< float, lowp > lowp_mat3x3
3 columns of 3 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:211
glm::mediump_dmat2x4
tmat2x4< double, mediump > mediump_dmat2x4
2 columns of 4 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:524
glm::mediump_mat4x2
tmat4x2< float, mediump > mediump_mat4x2
4 columns of 2 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:270
glm::lowp_dmat2x3
tmat2x3< double, lowp > lowp_dmat2x3
2 columns of 3 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:495
glm::mediump_dmat3x3
tmat3x3< double, mediump > mediump_dmat3x3
3 columns of 3 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:588
glm::highp_dmat4x4
tmat4x4< double, highp > highp_dmat4x4
4 columns of 4 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:704
glm::lowp_mat4
tmat4x4< float, lowp > lowp_mat4
4 columns of 4 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:316
glm::dmat4x2
highp_dmat4x2 dmat4x2
4 * 2 matrix of double-precision floating-point numbers.
Definition: type_mat.hpp:778
glm::lowp_mat3x4
tmat3x4< float, lowp > lowp_mat3x4
3 columns of 4 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:237
glm::lowp_mat2x2
tmat2x2< float, lowp > lowp_mat2x2
2 columns of 2 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:86
glm::highp_mat4x4
tmat4x4< float, highp > highp_mat4x4
4 columns of 4 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:351
glm::highp_mat2
tmat2x2< float, highp > highp_mat2
2 columns of 2 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:79
glm::highp_mat2x2
tmat2x2< float, highp > highp_mat2x2
2 columns of 2 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:100
glm::dmat2x4
highp_dmat2x4 dmat2x4
2 * 4 matrix of double-precision floating-point numbers.
Definition: type_mat.hpp:758
glm::mediump_mat4
tmat4x4< float, mediump > mediump_mat4
4 columns of 4 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:323
glm::lowp_dmat4x2
tmat4x2< double, lowp > lowp_dmat4x2
4 columns of 2 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:628
glm::highp_mat3
tmat3x3< float, highp > highp_mat3
3 columns of 3 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:204
glm::mediump_dmat4x2
tmat4x2< double, mediump > mediump_dmat4x2
4 columns of 2 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:634
glm::mediump_dmat2x3
tmat2x3< double, mediump > mediump_dmat2x3
2 columns of 3 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:501
glm::highp_dmat2x3
tmat2x3< double, highp > highp_dmat2x3
2 columns of 3 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:507
glm::highp_dmat2x4
tmat2x4< double, highp > highp_dmat2x4
2 columns of 4 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:530
glm::dmat4x3
highp_dmat4x3 dmat4x3
4 * 3 matrix of double-precision floating-point numbers.
Definition: type_mat.hpp:783
glm::highp_dmat4
tmat4x4< double, highp > highp_dmat4
4 columns of 4 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:686
glm::mediump_mat4x3
tmat4x3< float, mediump > mediump_mat4x3
4 columns of 3 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:296
glm::highp_dmat4x3
tmat4x3< double, highp > highp_dmat4x3
4 columns of 3 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:663
glm::lowp_dmat2
tmat2x2< double, lowp > lowp_dmat2
2 columns of 2 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:454
glm::dmat3x3
highp_dmat3x3 dmat3x3
3 * 3 matrix of double-precision floating-point numbers.
Definition: type_mat.hpp:768
glm::mediump_dmat3x2
tmat3x2< double, mediump > mediump_dmat3x2
3 columns of 2 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:547
glm::highp_mat3x4
tmat3x4< float, highp > highp_mat3x4
3 columns of 4 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:251
glm::lowp_mat2
tmat2x2< float, lowp > lowp_mat2
2 columns of 2 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:65
glm::mediump_mat3x2
tmat3x2< float, mediump > mediump_mat3x2
3 columns of 2 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:171
glm::dmat2x2
highp_dmat2x2 dmat2x2
2 * 2 matrix of double-precision floating-point numbers.
Definition: type_mat.hpp:748
glm::mat4
mat4x4 mat4
4 columns of 4 components matrix of floating-point numbers.
Definition: type_mat.hpp:442
precision.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::lowp_dmat2x2
tmat2x2< double, lowp > lowp_dmat2x2
2 columns of 2 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:472
glm::highp_dmat3
tmat3x3< double, highp > highp_dmat3
3 columns of 3 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:576
glm::highp_mat4x2
tmat4x2< float, highp > highp_mat4x2
4 columns of 2 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:277
glm::highp_dmat3x3
tmat3x3< double, highp > highp_dmat3x3
3 columns of 3 components matrix of high precision floating-point numbers.
Definition: type_mat.hpp:594
glm::lowp_dmat4
tmat4x4< double, lowp > lowp_dmat4
4 columns of 4 components matrix of low precision floating-point numbers.
Definition: type_mat.hpp:674
glm::mediump_dmat2
tmat2x2< double, mediump > mediump_dmat2
2 columns of 2 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:460
glm::dmat3
highp_dmat3x3 dmat3
3 * 3 matrix of double-precision floating-point numbers.
Definition: type_mat.hpp:738
glm::mediump_mat4x4
tmat4x4< float, mediump > mediump_mat4x4
4 columns of 4 components matrix of medium precision floating-point numbers.
Definition: type_mat.hpp:344
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00121.html000066400000000000000000000103471356361734700216430ustar00rootroot00000000000000 0.9.7: type_mat2x2.hpp File Reference
type_mat2x2.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2005-01-27 / 2011-06-15
Author
Christophe Riccio

Definition in file type_mat2x2.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00121_source.html000066400000000000000000001047461356361734700232320ustar00rootroot00000000000000 0.9.7: type_mat2x2.hpp Source File
type_mat2x2.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "../fwd.hpp"
36 #include "type_vec2.hpp"
37 #include "type_mat.hpp"
38 #include <limits>
39 #include <cstddef>
40 
41 namespace glm
42 {
43  template <typename T, precision P = defaultp>
44  struct tmat2x2
45  {
46  typedef tvec2<T, P> col_type;
47  typedef tvec2<T, P> row_type;
48  typedef tmat2x2<T, P> type;
49  typedef tmat2x2<T, P> transpose_type;
50  typedef T value_type;
51 
52  template <typename U, precision Q>
53  friend tvec2<U, Q> operator/(tmat2x2<U, Q> const & m, tvec2<U, Q> const & v);
54  template <typename U, precision Q>
55  friend tvec2<U, Q> operator/(tvec2<U, Q> const & v, tmat2x2<U, Q> const & m);
56 
57 # ifdef GLM_META_PROG_HELPERS
58  static GLM_RELAXED_CONSTEXPR length_t components = 2;
59  static GLM_RELAXED_CONSTEXPR length_t cols = 2;
60  static GLM_RELAXED_CONSTEXPR length_t rows = 2;
61  static GLM_RELAXED_CONSTEXPR precision prec = P;
62 # endif//GLM_META_PROG_HELPERS
63 
64  private:
65  col_type value[2];
66 
67  public:
68  // -- Constructors --
69 
70  GLM_FUNC_DECL tmat2x2() GLM_DEFAULT_CTOR;
71  GLM_FUNC_DECL tmat2x2(tmat2x2<T, P> const & m) GLM_DEFAULT;
72  template <precision Q>
73  GLM_FUNC_DECL tmat2x2(tmat2x2<T, Q> const & m);
74 
75  GLM_FUNC_DECL explicit tmat2x2(ctor);
76  GLM_FUNC_DECL explicit tmat2x2(T const & x);
77  GLM_FUNC_DECL tmat2x2(
78  T const & x1, T const & y1,
79  T const & x2, T const & y2);
80  GLM_FUNC_DECL tmat2x2(
81  col_type const & v1,
82  col_type const & v2);
83 
84  // -- Conversions --
85 
86  template <typename U, typename V, typename M, typename N>
87  GLM_FUNC_DECL tmat2x2(
88  U const & x1, V const & y1,
89  M const & x2, N const & y2);
90 
91  template <typename U, typename V>
92  GLM_FUNC_DECL tmat2x2(
93  tvec2<U, P> const & v1,
94  tvec2<V, P> const & v2);
95 
96  // -- Matrix conversions --
97 
98  template <typename U, precision Q>
99  GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat2x2<U, Q> const & m);
100 
101  GLM_FUNC_DECL explicit tmat2x2(tmat3x3<T, P> const & x);
102  GLM_FUNC_DECL explicit tmat2x2(tmat4x4<T, P> const & x);
103  GLM_FUNC_DECL explicit tmat2x2(tmat2x3<T, P> const & x);
104  GLM_FUNC_DECL explicit tmat2x2(tmat3x2<T, P> const & x);
105  GLM_FUNC_DECL explicit tmat2x2(tmat2x4<T, P> const & x);
106  GLM_FUNC_DECL explicit tmat2x2(tmat4x2<T, P> const & x);
107  GLM_FUNC_DECL explicit tmat2x2(tmat3x4<T, P> const & x);
108  GLM_FUNC_DECL explicit tmat2x2(tmat4x3<T, P> const & x);
109 
110  // -- Accesses --
111 
112 # ifdef GLM_FORCE_SIZE_FUNC
113  typedef size_t size_type;
114  GLM_FUNC_DECL GLM_CONSTEXPR size_t size() const;
115 
116  GLM_FUNC_DECL col_type & operator[](size_type i);
117  GLM_FUNC_DECL col_type const & operator[](size_type i) const;
118 # else
119  typedef length_t length_type;
120  GLM_FUNC_DECL GLM_CONSTEXPR length_type length() const;
121 
122  GLM_FUNC_DECL col_type & operator[](length_type i);
123  GLM_FUNC_DECL col_type const & operator[](length_type i) const;
124 # endif//GLM_FORCE_SIZE_FUNC
125 
126  // -- Unary arithmetic operators --
127 
128  GLM_FUNC_DECL tmat2x2<T, P> & operator=(tmat2x2<T, P> const & v) GLM_DEFAULT;;
129 
130  template <typename U>
131  GLM_FUNC_DECL tmat2x2<T, P> & operator=(tmat2x2<U, P> const & m);
132  template <typename U>
133  GLM_FUNC_DECL tmat2x2<T, P> & operator+=(U s);
134  template <typename U>
135  GLM_FUNC_DECL tmat2x2<T, P> & operator+=(tmat2x2<U, P> const & m);
136  template <typename U>
137  GLM_FUNC_DECL tmat2x2<T, P> & operator-=(U s);
138  template <typename U>
139  GLM_FUNC_DECL tmat2x2<T, P> & operator-=(tmat2x2<U, P> const & m);
140  template <typename U>
141  GLM_FUNC_DECL tmat2x2<T, P> & operator*=(U s);
142  template <typename U>
143  GLM_FUNC_DECL tmat2x2<T, P> & operator*=(tmat2x2<U, P> const & m);
144  template <typename U>
145  GLM_FUNC_DECL tmat2x2<T, P> & operator/=(U s);
146  template <typename U>
147  GLM_FUNC_DECL tmat2x2<T, P> & operator/=(tmat2x2<U, P> const & m);
148 
149  // -- Increment and decrement operators --
150 
151  GLM_FUNC_DECL tmat2x2<T, P> & operator++ ();
152  GLM_FUNC_DECL tmat2x2<T, P> & operator-- ();
153  GLM_FUNC_DECL tmat2x2<T, P> operator++(int);
154  GLM_FUNC_DECL tmat2x2<T, P> operator--(int);
155  };
156 
157  // -- Unary operators --
158 
159  template <typename T, precision P>
160  GLM_FUNC_DECL tmat2x2<T, P> const operator-(tmat2x2<T, P> const & m);
161 
162  // -- Binary operators --
163 
164  template <typename T, precision P>
165  GLM_FUNC_DECL tmat2x2<T, P> operator+(tmat2x2<T, P> const & m, T const & s);
166 
167  template <typename T, precision P>
168  GLM_FUNC_DECL tmat2x2<T, P> operator+(T const & s, tmat2x2<T, P> const & m);
169 
170  template <typename T, precision P>
171  GLM_FUNC_DECL tmat2x2<T, P> operator+(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2);
172 
173  template <typename T, precision P>
174  GLM_FUNC_DECL tmat2x2<T, P> operator-(tmat2x2<T, P> const & m, T const & s);
175 
176  template <typename T, precision P>
177  GLM_FUNC_DECL tmat2x2<T, P> operator-(T const & s, tmat2x2<T, P> const & m);
178 
179  template <typename T, precision P>
180  GLM_FUNC_DECL tmat2x2<T, P> operator-(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2);
181 
182  template <typename T, precision P>
183  GLM_FUNC_DECL tmat2x2<T, P> operator*(tmat2x2<T, P> const & m, T const & s);
184 
185  template <typename T, precision P>
186  GLM_FUNC_DECL tmat2x2<T, P> operator*(T const & s, tmat2x2<T, P> const & m);
187 
188  template <typename T, precision P>
189  GLM_FUNC_DECL typename tmat2x2<T, P>::col_type operator*(tmat2x2<T, P> const & m, typename tmat2x2<T, P>::row_type const & v);
190 
191  template <typename T, precision P>
192  GLM_FUNC_DECL typename tmat2x2<T, P>::row_type operator*(typename tmat2x2<T, P>::col_type const & v, tmat2x2<T, P> const & m);
193 
194  template <typename T, precision P>
195  GLM_FUNC_DECL tmat2x2<T, P> operator*(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2);
196 
197  template <typename T, precision P>
198  GLM_FUNC_DECL tmat3x2<T, P> operator*(tmat2x2<T, P> const & m1, tmat3x2<T, P> const & m2);
199 
200  template <typename T, precision P>
201  GLM_FUNC_DECL tmat4x2<T, P> operator*(tmat2x2<T, P> const & m1, tmat4x2<T, P> const & m2);
202 
203  template <typename T, precision P>
204  GLM_FUNC_DECL tmat2x2<T, P> operator/(tmat2x2<T, P> const & m, T const & s);
205 
206  template <typename T, precision P>
207  GLM_FUNC_DECL tmat2x2<T, P> operator/(T const & s, tmat2x2<T, P> const & m);
208 
209  template <typename T, precision P>
210  GLM_FUNC_DECL typename tmat2x2<T, P>::col_type operator/(tmat2x2<T, P> const & m, typename tmat2x2<T, P>::row_type const & v);
211 
212  template <typename T, precision P>
213  GLM_FUNC_DECL typename tmat2x2<T, P>::row_type operator/(typename tmat2x2<T, P>::col_type const & v, tmat2x2<T, P> const & m);
214 
215  template <typename T, precision P>
216  GLM_FUNC_DECL tmat2x2<T, P> operator/(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2);
217 
218  // -- Boolean operators --
219 
220  template <typename T, precision P>
221  GLM_FUNC_DECL bool operator==(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2);
222 
223  template <typename T, precision P>
224  GLM_FUNC_DECL bool operator!=(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2);
225 } //namespace glm
226 
227 #ifndef GLM_EXTERNAL_TEMPLATE
228 #include "type_mat2x2.inl"
229 #endif
glm::length
GLM_FUNC_DECL T length(vecType< T, P > const &x)
Returns the length of x, i.e., sqrt(x * x).
glm
Definition: _noise.hpp:40
type_vec2.hpp
OpenGL Mathematics (glm.g-truc.net)
type_mat.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00122.html000066400000000000000000000103471356361734700216440ustar00rootroot00000000000000 0.9.7: type_mat2x3.hpp File Reference
type_mat2x3.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2006-10-01 / 2011-06-15
Author
Christophe Riccio

Definition in file type_mat2x3.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00122_source.html000066400000000000000000000744731356361734700232360ustar00rootroot00000000000000 0.9.7: type_mat2x3.hpp Source File
type_mat2x3.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "../fwd.hpp"
36 #include "type_vec2.hpp"
37 #include "type_vec3.hpp"
38 #include "type_mat.hpp"
39 #include <limits>
40 #include <cstddef>
41 
42 namespace glm
43 {
44  template <typename T, precision P = defaultp>
45  struct tmat2x3
46  {
47  typedef tvec3<T, P> col_type;
48  typedef tvec2<T, P> row_type;
49  typedef tmat2x3<T, P> type;
50  typedef tmat3x2<T, P> transpose_type;
51  typedef T value_type;
52 
53 # ifdef GLM_META_PROG_HELPERS
54  static GLM_RELAXED_CONSTEXPR length_t components = 2;
55  static GLM_RELAXED_CONSTEXPR length_t cols = 2;
56  static GLM_RELAXED_CONSTEXPR length_t rows = 3;
57  static GLM_RELAXED_CONSTEXPR precision prec = P;
58 # endif//GLM_META_PROG_HELPERS
59 
60  private:
61  col_type value[2];
62 
63  public:
64  // -- Constructors --
65 
66  GLM_FUNC_DECL tmat2x3() GLM_DEFAULT_CTOR;
67  GLM_FUNC_DECL tmat2x3(tmat2x3<T, P> const & m) GLM_DEFAULT;
68  template <precision Q>
69  GLM_FUNC_DECL tmat2x3(tmat2x3<T, Q> const & m);
70 
71  GLM_FUNC_DECL explicit tmat2x3(ctor);
72  GLM_FUNC_DECL explicit tmat2x3(T const & s);
73  GLM_FUNC_DECL tmat2x3(
74  T const & x0, T const & y0, T const & z0,
75  T const & x1, T const & y1, T const & z1);
76  GLM_FUNC_DECL tmat2x3(
77  col_type const & v0,
78  col_type const & v1);
79 
80  // -- Conversions --
81 
82  template <typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2>
83  GLM_FUNC_DECL tmat2x3(
84  X1 const & x1, Y1 const & y1, Z1 const & z1,
85  X2 const & x2, Y2 const & y2, Z2 const & z2);
86 
87  template <typename U, typename V>
88  GLM_FUNC_DECL tmat2x3(
89  tvec3<U, P> const & v1,
90  tvec3<V, P> const & v2);
91 
92  // -- Matrix conversions --
93 
94  template <typename U, precision Q>
95  GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat2x3<U, Q> const & m);
96 
97  GLM_FUNC_DECL explicit tmat2x3(tmat2x2<T, P> const & x);
98  GLM_FUNC_DECL explicit tmat2x3(tmat3x3<T, P> const & x);
99  GLM_FUNC_DECL explicit tmat2x3(tmat4x4<T, P> const & x);
100  GLM_FUNC_DECL explicit tmat2x3(tmat2x4<T, P> const & x);
101  GLM_FUNC_DECL explicit tmat2x3(tmat3x2<T, P> const & x);
102  GLM_FUNC_DECL explicit tmat2x3(tmat3x4<T, P> const & x);
103  GLM_FUNC_DECL explicit tmat2x3(tmat4x2<T, P> const & x);
104  GLM_FUNC_DECL explicit tmat2x3(tmat4x3<T, P> const & x);
105 
106  // -- Accesses --
107 
108 # ifdef GLM_FORCE_SIZE_FUNC
109  typedef size_t size_type;
110  GLM_FUNC_DECL GLM_CONSTEXPR size_t size() const;
111 
112  GLM_FUNC_DECL col_type & operator[](size_type i);
113  GLM_FUNC_DECL col_type const & operator[](size_type i) const;
114 # else
115  typedef length_t length_type;
116  GLM_FUNC_DECL GLM_CONSTEXPR length_type length() const;
117 
118  GLM_FUNC_DECL col_type & operator[](length_type i);
119  GLM_FUNC_DECL col_type const & operator[](length_type i) const;
120 # endif//GLM_FORCE_SIZE_FUNC
121 
122  // -- Unary arithmetic operators --
123 
124  GLM_FUNC_DECL tmat2x3<T, P> & operator=(tmat2x3<T, P> const & m) GLM_DEFAULT;
125 
126  template <typename U>
127  GLM_FUNC_DECL tmat2x3<T, P> & operator=(tmat2x3<U, P> const & m);
128  template <typename U>
129  GLM_FUNC_DECL tmat2x3<T, P> & operator+=(U s);
130  template <typename U>
131  GLM_FUNC_DECL tmat2x3<T, P> & operator+=(tmat2x3<U, P> const & m);
132  template <typename U>
133  GLM_FUNC_DECL tmat2x3<T, P> & operator-=(U s);
134  template <typename U>
135  GLM_FUNC_DECL tmat2x3<T, P> & operator-=(tmat2x3<U, P> const & m);
136  template <typename U>
137  GLM_FUNC_DECL tmat2x3<T, P> & operator*=(U s);
138  template <typename U>
139  GLM_FUNC_DECL tmat2x3<T, P> & operator/=(U s);
140 
141  // -- Increment and decrement operators --
142 
143  GLM_FUNC_DECL tmat2x3<T, P> & operator++ ();
144  GLM_FUNC_DECL tmat2x3<T, P> & operator-- ();
145  GLM_FUNC_DECL tmat2x3<T, P> operator++(int);
146  GLM_FUNC_DECL tmat2x3<T, P> operator--(int);
147  };
148 
149  // -- Unary operators --
150 
151  template <typename T, precision P>
152  GLM_FUNC_DECL tmat2x3<T, P> const operator-(tmat2x3<T, P> const & m);
153 
154  // -- Binary operators --
155 
156  template <typename T, precision P>
157  GLM_FUNC_DECL tmat2x3<T, P> operator+(tmat2x3<T, P> const & m, T const & s);
158 
159  template <typename T, precision P>
160  GLM_FUNC_DECL tmat2x3<T, P> operator+(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2);
161 
162  template <typename T, precision P>
163  GLM_FUNC_DECL tmat2x3<T, P> operator-(tmat2x3<T, P> const & m, T const & s);
164 
165  template <typename T, precision P>
166  GLM_FUNC_DECL tmat2x3<T, P> operator-(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2);
167 
168  template <typename T, precision P>
169  GLM_FUNC_DECL tmat2x3<T, P> operator*(tmat2x3<T, P> const & m, T const & s);
170 
171  template <typename T, precision P>
172  GLM_FUNC_DECL tmat2x3<T, P> operator*(T const & s, tmat2x3<T, P> const & m);
173 
174  template <typename T, precision P>
175  GLM_FUNC_DECL typename tmat2x3<T, P>::col_type operator*(tmat2x3<T, P> const & m, typename tmat2x3<T, P>::row_type const & v);
176 
177  template <typename T, precision P>
178  GLM_FUNC_DECL typename tmat2x3<T, P>::row_type operator*(typename tmat2x3<T, P>::col_type const & v, tmat2x3<T, P> const & m);
179 
180  template <typename T, precision P>
181  GLM_FUNC_DECL tmat2x3<T, P> operator*(tmat2x3<T, P> const & m1, tmat2x2<T, P> const & m2);
182 
183  template <typename T, precision P>
184  GLM_FUNC_DECL tmat3x3<T, P> operator*(tmat2x3<T, P> const & m1, tmat3x2<T, P> const & m2);
185 
186  template <typename T, precision P>
187  GLM_FUNC_DECL tmat4x3<T, P> operator*(tmat2x3<T, P> const & m1, tmat4x2<T, P> const & m2);
188 
189  template <typename T, precision P>
190  GLM_FUNC_DECL tmat2x3<T, P> operator/(tmat2x3<T, P> const & m, T const & s);
191 
192  template <typename T, precision P>
193  GLM_FUNC_DECL tmat2x3<T, P> operator/(T const & s, tmat2x3<T, P> const & m);
194 
195  // -- Boolean operators --
196 
197  template <typename T, precision P>
198  GLM_FUNC_DECL bool operator==(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2);
199 
200  template <typename T, precision P>
201  GLM_FUNC_DECL bool operator!=(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2);
202 }//namespace glm
203 
204 #ifndef GLM_EXTERNAL_TEMPLATE
205 #include "type_mat2x3.inl"
206 #endif
type_vec3.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::length
GLM_FUNC_DECL T length(vecType< T, P > const &x)
Returns the length of x, i.e., sqrt(x * x).
glm
Definition: _noise.hpp:40
type_vec2.hpp
OpenGL Mathematics (glm.g-truc.net)
type_mat.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00123.html000066400000000000000000000103471356361734700216450ustar00rootroot00000000000000 0.9.7: type_mat2x4.hpp File Reference
type_mat2x4.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2006-08-05 / 2011-06-15
Author
Christophe Riccio

Definition in file type_mat2x4.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00123_source.html000066400000000000000000000750461356361734700232340ustar00rootroot00000000000000 0.9.7: type_mat2x4.hpp Source File
type_mat2x4.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "../fwd.hpp"
36 #include "type_vec2.hpp"
37 #include "type_vec4.hpp"
38 #include "type_mat.hpp"
39 #include <limits>
40 #include <cstddef>
41 
42 namespace glm
43 {
44  template <typename T, precision P = defaultp>
45  struct tmat2x4
46  {
47  typedef tvec4<T, P> col_type;
48  typedef tvec2<T, P> row_type;
49  typedef tmat2x4<T, P> type;
50  typedef tmat4x2<T, P> transpose_type;
51  typedef T value_type;
52 
53 # ifdef GLM_META_PROG_HELPERS
54  static GLM_RELAXED_CONSTEXPR length_t components = 2;
55  static GLM_RELAXED_CONSTEXPR length_t cols = 2;
56  static GLM_RELAXED_CONSTEXPR length_t rows = 4;
57  static GLM_RELAXED_CONSTEXPR precision prec = P;
58 # endif//GLM_META_PROG_HELPERS
59 
60  private:
61  col_type value[2];
62 
63  public:
64  // -- Constructors --
65 
66  GLM_FUNC_DECL tmat2x4() GLM_DEFAULT_CTOR;
67  GLM_FUNC_DECL tmat2x4(tmat2x4<T, P> const & m) GLM_DEFAULT;
68  template <precision Q>
69  GLM_FUNC_DECL tmat2x4(tmat2x4<T, Q> const & m);
70 
71  GLM_FUNC_DECL explicit tmat2x4(ctor);
72  GLM_FUNC_DECL explicit tmat2x4(T const & s);
73  GLM_FUNC_DECL tmat2x4(
74  T const & x0, T const & y0, T const & z0, T const & w0,
75  T const & x1, T const & y1, T const & z1, T const & w1);
76  GLM_FUNC_DECL tmat2x4(
77  col_type const & v0,
78  col_type const & v1);
79 
80  // -- Conversions --
81 
82  template <
83  typename X1, typename Y1, typename Z1, typename W1,
84  typename X2, typename Y2, typename Z2, typename W2>
85  GLM_FUNC_DECL tmat2x4(
86  X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1,
87  X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2);
88 
89  template <typename U, typename V>
90  GLM_FUNC_DECL tmat2x4(
91  tvec4<U, P> const & v1,
92  tvec4<V, P> const & v2);
93 
94  // -- Matrix conversions --
95 
96  template <typename U, precision Q>
97  GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat2x4<U, Q> const & m);
98 
99  GLM_FUNC_DECL explicit tmat2x4(tmat2x2<T, P> const & x);
100  GLM_FUNC_DECL explicit tmat2x4(tmat3x3<T, P> const & x);
101  GLM_FUNC_DECL explicit tmat2x4(tmat4x4<T, P> const & x);
102  GLM_FUNC_DECL explicit tmat2x4(tmat2x3<T, P> const & x);
103  GLM_FUNC_DECL explicit tmat2x4(tmat3x2<T, P> const & x);
104  GLM_FUNC_DECL explicit tmat2x4(tmat3x4<T, P> const & x);
105  GLM_FUNC_DECL explicit tmat2x4(tmat4x2<T, P> const & x);
106  GLM_FUNC_DECL explicit tmat2x4(tmat4x3<T, P> const & x);
107 
108  // -- Accesses --
109 
110 # ifdef GLM_FORCE_SIZE_FUNC
111  typedef size_t size_type;
112  GLM_FUNC_DECL GLM_CONSTEXPR size_t size() const;
113 
114  GLM_FUNC_DECL col_type & operator[](size_type i);
115  GLM_FUNC_DECL col_type const & operator[](size_type i) const;
116 # else
117  typedef length_t length_type;
118  GLM_FUNC_DECL GLM_CONSTEXPR length_type length() const;
119 
120  GLM_FUNC_DECL col_type & operator[](length_type i);
121  GLM_FUNC_DECL col_type const & operator[](length_type i) const;
122 # endif//GLM_FORCE_SIZE_FUNC
123 
124  // -- Unary arithmetic operators --
125 
126  GLM_FUNC_DECL tmat2x4<T, P> & operator=(tmat2x4<T, P> const & m) GLM_DEFAULT;
127 
128  template <typename U>
129  GLM_FUNC_DECL tmat2x4<T, P> & operator=(tmat2x4<U, P> const & m);
130  template <typename U>
131  GLM_FUNC_DECL tmat2x4<T, P> & operator+=(U s);
132  template <typename U>
133  GLM_FUNC_DECL tmat2x4<T, P> & operator+=(tmat2x4<U, P> const & m);
134  template <typename U>
135  GLM_FUNC_DECL tmat2x4<T, P> & operator-=(U s);
136  template <typename U>
137  GLM_FUNC_DECL tmat2x4<T, P> & operator-=(tmat2x4<U, P> const & m);
138  template <typename U>
139  GLM_FUNC_DECL tmat2x4<T, P> & operator*=(U s);
140  template <typename U>
141  GLM_FUNC_DECL tmat2x4<T, P> & operator/=(U s);
142 
143  // -- Increment and decrement operators --
144 
145  GLM_FUNC_DECL tmat2x4<T, P> & operator++ ();
146  GLM_FUNC_DECL tmat2x4<T, P> & operator-- ();
147  GLM_FUNC_DECL tmat2x4<T, P> operator++(int);
148  GLM_FUNC_DECL tmat2x4<T, P> operator--(int);
149  };
150 
151  // -- Unary operators --
152 
153  template <typename T, precision P>
154  GLM_FUNC_DECL tmat2x4<T, P> const operator-(tmat2x4<T, P> const & m);
155 
156  // -- Binary operators --
157 
158  template <typename T, precision P>
159  GLM_FUNC_DECL tmat2x4<T, P> operator+(tmat2x4<T, P> const & m, T const & s);
160 
161  template <typename T, precision P>
162  GLM_FUNC_DECL tmat2x4<T, P> operator+(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2);
163 
164  template <typename T, precision P>
165  GLM_FUNC_DECL tmat2x4<T, P> operator-(tmat2x4<T, P> const & m, T const & s);
166 
167  template <typename T, precision P>
168  GLM_FUNC_DECL tmat2x4<T, P> operator-(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2);
169 
170  template <typename T, precision P>
171  GLM_FUNC_DECL tmat2x4<T, P> operator*(tmat2x4<T, P> const & m, T const & s);
172 
173  template <typename T, precision P>
174  GLM_FUNC_DECL tmat2x4<T, P> operator*(T const & s, tmat2x4<T, P> const & m);
175 
176  template <typename T, precision P>
177  GLM_FUNC_DECL typename tmat2x4<T, P>::col_type operator*(tmat2x4<T, P> const & m, typename tmat2x4<T, P>::row_type const & v);
178 
179  template <typename T, precision P>
180  GLM_FUNC_DECL typename tmat2x4<T, P>::row_type operator*(typename tmat2x4<T, P>::col_type const & v, tmat2x4<T, P> const & m);
181 
182  template <typename T, precision P>
183  GLM_FUNC_DECL tmat4x4<T, P> operator*(tmat2x4<T, P> const & m1, tmat4x2<T, P> const & m2);
184 
185  template <typename T, precision P>
186  GLM_FUNC_DECL tmat2x4<T, P> operator*(tmat2x4<T, P> const & m1, tmat2x2<T, P> const & m2);
187 
188  template <typename T, precision P>
189  GLM_FUNC_DECL tmat3x4<T, P> operator*(tmat2x4<T, P> const & m1, tmat3x2<T, P> const & m2);
190 
191  template <typename T, precision P>
192  GLM_FUNC_DECL tmat2x4<T, P> operator/(tmat2x4<T, P> const & m, T s);
193 
194  template <typename T, precision P>
195  GLM_FUNC_DECL tmat2x4<T, P> operator/(T s, tmat2x4<T, P> const & m);
196 
197  // -- Boolean operators --
198 
199  template <typename T, precision P>
200  GLM_FUNC_DECL bool operator==(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2);
201 
202  template <typename T, precision P>
203  GLM_FUNC_DECL bool operator!=(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2);
204 }//namespace glm
205 
206 #ifndef GLM_EXTERNAL_TEMPLATE
207 #include "type_mat2x4.inl"
208 #endif
glm::length
GLM_FUNC_DECL T length(vecType< T, P > const &x)
Returns the length of x, i.e., sqrt(x * x).
glm
Definition: _noise.hpp:40
type_vec2.hpp
OpenGL Mathematics (glm.g-truc.net)
type_mat.hpp
OpenGL Mathematics (glm.g-truc.net)
type_vec4.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00124.html000066400000000000000000000103471356361734700216460ustar00rootroot00000000000000 0.9.7: type_mat3x2.hpp File Reference
type_mat3x2.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2006-08-05 / 2011-06-15
Author
Christophe Riccio

Definition in file type_mat3x2.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00124_source.html000066400000000000000000000761741356361734700232400ustar00rootroot00000000000000 0.9.7: type_mat3x2.hpp Source File
type_mat3x2.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "../fwd.hpp"
36 #include "type_vec2.hpp"
37 #include "type_vec3.hpp"
38 #include "type_mat.hpp"
39 #include <limits>
40 #include <cstddef>
41 
42 namespace glm
43 {
44  template <typename T, precision P = defaultp>
45  struct tmat3x2
46  {
47  typedef tvec2<T, P> col_type;
48  typedef tvec3<T, P> row_type;
49  typedef tmat3x2<T, P> type;
50  typedef tmat2x3<T, P> transpose_type;
51  typedef T value_type;
52 
53 # ifdef GLM_META_PROG_HELPERS
54  static GLM_RELAXED_CONSTEXPR length_t components = 3;
55  static GLM_RELAXED_CONSTEXPR length_t cols = 3;
56  static GLM_RELAXED_CONSTEXPR length_t rows = 2;
57  static GLM_RELAXED_CONSTEXPR precision prec = P;
58 # endif//GLM_META_PROG_HELPERS
59 
60  private:
61  col_type value[3];
62 
63  public:
64  // -- Constructors --
65 
66  GLM_FUNC_DECL tmat3x2() GLM_DEFAULT_CTOR;
67  GLM_FUNC_DECL tmat3x2(tmat3x2<T, P> const & m) GLM_DEFAULT;
68  template <precision Q>
69  GLM_FUNC_DECL tmat3x2(tmat3x2<T, Q> const & m);
70 
71  GLM_FUNC_DECL explicit tmat3x2(ctor);
72  GLM_FUNC_DECL explicit tmat3x2(T const & s);
73  GLM_FUNC_DECL tmat3x2(
74  T const & x0, T const & y0,
75  T const & x1, T const & y1,
76  T const & x2, T const & y2);
77  GLM_FUNC_DECL tmat3x2(
78  col_type const & v0,
79  col_type const & v1,
80  col_type const & v2);
81 
82  // -- Conversions --
83 
84  template<
85  typename X1, typename Y1,
86  typename X2, typename Y2,
87  typename X3, typename Y3>
88  GLM_FUNC_DECL tmat3x2(
89  X1 const & x1, Y1 const & y1,
90  X2 const & x2, Y2 const & y2,
91  X3 const & x3, Y3 const & y3);
92 
93  template <typename V1, typename V2, typename V3>
94  GLM_FUNC_DECL tmat3x2(
95  tvec2<V1, P> const & v1,
96  tvec2<V2, P> const & v2,
97  tvec2<V3, P> const & v3);
98 
99  // -- Matrix conversions --
100 
101  template <typename U, precision Q>
102  GLM_FUNC_DECL GLM_EXPLICIT tmat3x2(tmat3x2<U, Q> const & m);
103 
104  GLM_FUNC_DECL explicit tmat3x2(tmat2x2<T, P> const & x);
105  GLM_FUNC_DECL explicit tmat3x2(tmat3x3<T, P> const & x);
106  GLM_FUNC_DECL explicit tmat3x2(tmat4x4<T, P> const & x);
107  GLM_FUNC_DECL explicit tmat3x2(tmat2x3<T, P> const & x);
108  GLM_FUNC_DECL explicit tmat3x2(tmat2x4<T, P> const & x);
109  GLM_FUNC_DECL explicit tmat3x2(tmat3x4<T, P> const & x);
110  GLM_FUNC_DECL explicit tmat3x2(tmat4x2<T, P> const & x);
111  GLM_FUNC_DECL explicit tmat3x2(tmat4x3<T, P> const & x);
112 
113  // -- Accesses --
114 
115 # ifdef GLM_FORCE_SIZE_FUNC
116  typedef size_t size_type;
117  GLM_FUNC_DECL GLM_CONSTEXPR size_t size() const;
118 
119  GLM_FUNC_DECL col_type & operator[](size_type i);
120  GLM_FUNC_DECL col_type const & operator[](size_type i) const;
121 # else
122  typedef length_t length_type;
123  GLM_FUNC_DECL GLM_CONSTEXPR length_type length() const;
124 
125  GLM_FUNC_DECL col_type & operator[](length_type i);
126  GLM_FUNC_DECL col_type const & operator[](length_type i) const;
127 # endif//GLM_FORCE_SIZE_FUNC
128 
129  // -- Unary arithmetic operators --
130 
131  GLM_FUNC_DECL tmat3x2<T, P> & operator=(tmat3x2<T, P> const & m) GLM_DEFAULT;
132 
133  template <typename U>
134  GLM_FUNC_DECL tmat3x2<T, P> & operator=(tmat3x2<U, P> const & m);
135  template <typename U>
136  GLM_FUNC_DECL tmat3x2<T, P> & operator+=(U s);
137  template <typename U>
138  GLM_FUNC_DECL tmat3x2<T, P> & operator+=(tmat3x2<U, P> const & m);
139  template <typename U>
140  GLM_FUNC_DECL tmat3x2<T, P> & operator-=(U s);
141  template <typename U>
142  GLM_FUNC_DECL tmat3x2<T, P> & operator-=(tmat3x2<U, P> const & m);
143  template <typename U>
144  GLM_FUNC_DECL tmat3x2<T, P> & operator*=(U s);
145  template <typename U>
146  GLM_FUNC_DECL tmat3x2<T, P> & operator/=(U s);
147 
148  // -- Increment and decrement operators --
149 
150  GLM_FUNC_DECL tmat3x2<T, P> & operator++ ();
151  GLM_FUNC_DECL tmat3x2<T, P> & operator-- ();
152  GLM_FUNC_DECL tmat3x2<T, P> operator++(int);
153  GLM_FUNC_DECL tmat3x2<T, P> operator--(int);
154  };
155 
156  // -- Unary operators --
157 
158  template <typename T, precision P>
159  GLM_FUNC_DECL tmat3x2<T, P> const operator-(tmat3x2<T, P> const & m);
160 
161  // -- Binary operators --
162 
163  template <typename T, precision P>
164  GLM_FUNC_DECL tmat3x2<T, P> operator+(tmat3x2<T, P> const & m, T const & s);
165 
166  template <typename T, precision P>
167  GLM_FUNC_DECL tmat3x2<T, P> operator+(tmat3x2<T, P> const & m1, tmat3x2<T, P> const & m2);
168 
169  template <typename T, precision P>
170  GLM_FUNC_DECL tmat3x2<T, P> operator-(tmat3x2<T, P> const & m, T const & s);
171 
172  template <typename T, precision P>
173  GLM_FUNC_DECL tmat3x2<T, P> operator-(tmat3x2<T, P> const & m1, tmat3x2<T, P> const & m2);
174 
175  template <typename T, precision P>
176  GLM_FUNC_DECL tmat3x2<T, P> operator*(tmat3x2<T, P> const & m, T const & s);
177 
178  template <typename T, precision P>
179  GLM_FUNC_DECL tmat3x2<T, P> operator*(T const & s, tmat3x2<T, P> const & m);
180 
181  template <typename T, precision P>
182  GLM_FUNC_DECL typename tmat3x2<T, P>::col_type operator*(tmat3x2<T, P> const & m, typename tmat3x2<T, P>::row_type const & v);
183 
184  template <typename T, precision P>
185  GLM_FUNC_DECL typename tmat3x2<T, P>::row_type operator*(typename tmat3x2<T, P>::col_type const & v, tmat3x2<T, P> const & m);
186 
187  template <typename T, precision P>
188  GLM_FUNC_DECL tmat2x2<T, P> operator*(tmat3x2<T, P> const & m1, tmat2x3<T, P> const & m2);
189 
190  template <typename T, precision P>
191  GLM_FUNC_DECL tmat3x2<T, P> operator*(tmat3x2<T, P> const & m1, tmat3x3<T, P> const & m2);
192 
193  template <typename T, precision P>
194  GLM_FUNC_DECL tmat4x2<T, P> operator*(tmat3x2<T, P> const & m1, tmat4x3<T, P> const & m2);
195 
196  template <typename T, precision P>
197  GLM_FUNC_DECL tmat3x2<T, P> operator/(tmat3x2<T, P> const & m, T const & s);
198 
199  template <typename T, precision P>
200  GLM_FUNC_DECL tmat3x2<T, P> operator/(T const & s, tmat3x2<T, P> const & m);
201 
202  // -- Boolean operators --
203 
204  template <typename T, precision P>
205  GLM_FUNC_DECL bool operator==(tmat3x2<T, P> const & m1, tmat3x2<T, P> const & m2);
206 
207  template <typename T, precision P>
208  GLM_FUNC_DECL bool operator!=(tmat3x2<T, P> const & m1, tmat3x2<T, P> const & m2);
209 }//namespace glm
210 
211 #ifndef GLM_EXTERNAL_TEMPLATE
212 #include "type_mat3x2.inl"
213 #endif
type_vec3.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::length
GLM_FUNC_DECL T length(vecType< T, P > const &x)
Returns the length of x, i.e., sqrt(x * x).
glm
Definition: _noise.hpp:40
type_vec2.hpp
OpenGL Mathematics (glm.g-truc.net)
type_mat.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00125.html000066400000000000000000000103471356361734700216470ustar00rootroot00000000000000 0.9.7: type_mat3x3.hpp File Reference
type_mat3x3.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2005-01-27 / 2011-06-15
Author
Christophe Riccio

Definition in file type_mat3x3.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00125_source.html000066400000000000000000001070451356361734700232310ustar00rootroot00000000000000 0.9.7: type_mat3x3.hpp Source File
type_mat3x3.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "../fwd.hpp"
36 #include "type_vec3.hpp"
37 #include "type_mat.hpp"
38 #include <limits>
39 #include <cstddef>
40 
41 namespace glm
42 {
43  template <typename T, precision P = defaultp>
44  struct tmat3x3
45  {
46  typedef tvec3<T, P> col_type;
47  typedef tvec3<T, P> row_type;
48  typedef tmat3x3<T, P> type;
49  typedef tmat3x3<T, P> transpose_type;
50  typedef T value_type;
51 
52 # ifdef GLM_META_PROG_HELPERS
53  static GLM_RELAXED_CONSTEXPR length_t components = 3;
54  static GLM_RELAXED_CONSTEXPR length_t cols = 3;
55  static GLM_RELAXED_CONSTEXPR length_t rows = 3;
56  static GLM_RELAXED_CONSTEXPR precision prec = P;
57 # endif//GLM_META_PROG_HELPERS
58 
59  template <typename U, precision Q>
60  friend tvec3<U, Q> operator/(tmat3x3<U, Q> const & m, tvec3<U, Q> const & v);
61  template <typename U, precision Q>
62  friend tvec3<U, Q> operator/(tvec3<U, Q> const & v, tmat3x3<U, Q> const & m);
63 
64  private:
65  col_type value[3];
66 
67  public:
68  // -- Constructors --
69 
70  GLM_FUNC_DECL tmat3x3() GLM_DEFAULT_CTOR;
71  GLM_FUNC_DECL tmat3x3(tmat3x3<T, P> const & m) GLM_DEFAULT;
72  template <precision Q>
73  GLM_FUNC_DECL tmat3x3(tmat3x3<T, Q> const & m);
74 
75  GLM_FUNC_DECL explicit tmat3x3(ctor);
76  GLM_FUNC_DECL explicit tmat3x3(T const & s);
77  GLM_FUNC_DECL tmat3x3(
78  T const & x0, T const & y0, T const & z0,
79  T const & x1, T const & y1, T const & z1,
80  T const & x2, T const & y2, T const & z2);
81  GLM_FUNC_DECL tmat3x3(
82  col_type const & v0,
83  col_type const & v1,
84  col_type const & v2);
85 
86  // -- Conversions --
87 
88  template<
89  typename X1, typename Y1, typename Z1,
90  typename X2, typename Y2, typename Z2,
91  typename X3, typename Y3, typename Z3>
92  GLM_FUNC_DECL tmat3x3(
93  X1 const & x1, Y1 const & y1, Z1 const & z1,
94  X2 const & x2, Y2 const & y2, Z2 const & z2,
95  X3 const & x3, Y3 const & y3, Z3 const & z3);
96 
97  template <typename V1, typename V2, typename V3>
98  GLM_FUNC_DECL tmat3x3(
99  tvec3<V1, P> const & v1,
100  tvec3<V2, P> const & v2,
101  tvec3<V3, P> const & v3);
102 
103  // -- Matrix conversions --
104 
105  template <typename U, precision Q>
106  GLM_FUNC_DECL GLM_EXPLICIT tmat3x3(tmat3x3<U, Q> const & m);
107 
108  GLM_FUNC_DECL explicit tmat3x3(tmat2x2<T, P> const & x);
109  GLM_FUNC_DECL explicit tmat3x3(tmat4x4<T, P> const & x);
110  GLM_FUNC_DECL explicit tmat3x3(tmat2x3<T, P> const & x);
111  GLM_FUNC_DECL explicit tmat3x3(tmat3x2<T, P> const & x);
112  GLM_FUNC_DECL explicit tmat3x3(tmat2x4<T, P> const & x);
113  GLM_FUNC_DECL explicit tmat3x3(tmat4x2<T, P> const & x);
114  GLM_FUNC_DECL explicit tmat3x3(tmat3x4<T, P> const & x);
115  GLM_FUNC_DECL explicit tmat3x3(tmat4x3<T, P> const & x);
116 
117  // -- Accesses --
118 
119 # ifdef GLM_FORCE_SIZE_FUNC
120  typedef size_t size_type;
121  GLM_FUNC_DECL GLM_CONSTEXPR size_t size() const;
122 
123  GLM_FUNC_DECL col_type & operator[](size_type i);
124  GLM_FUNC_DECL col_type const & operator[](size_type i) const;
125 # else
126  typedef length_t length_type;
127  GLM_FUNC_DECL GLM_CONSTEXPR length_type length() const;
128 
129  GLM_FUNC_DECL col_type & operator[](length_type i);
130  GLM_FUNC_DECL col_type const & operator[](length_type i) const;
131 # endif//GLM_FORCE_SIZE_FUNC
132 
133  // -- Unary arithmetic operators --
134 
135  GLM_FUNC_DECL tmat3x3<T, P> & operator=(tmat3x3<T, P> const & m) GLM_DEFAULT;
136 
137  template <typename U>
138  GLM_FUNC_DECL tmat3x3<T, P> & operator=(tmat3x3<U, P> const & m);
139  template <typename U>
140  GLM_FUNC_DECL tmat3x3<T, P> & operator+=(U s);
141  template <typename U>
142  GLM_FUNC_DECL tmat3x3<T, P> & operator+=(tmat3x3<U, P> const & m);
143  template <typename U>
144  GLM_FUNC_DECL tmat3x3<T, P> & operator-=(U s);
145  template <typename U>
146  GLM_FUNC_DECL tmat3x3<T, P> & operator-=(tmat3x3<U, P> const & m);
147  template <typename U>
148  GLM_FUNC_DECL tmat3x3<T, P> & operator*=(U s);
149  template <typename U>
150  GLM_FUNC_DECL tmat3x3<T, P> & operator*=(tmat3x3<U, P> const & m);
151  template <typename U>
152  GLM_FUNC_DECL tmat3x3<T, P> & operator/=(U s);
153  template <typename U>
154  GLM_FUNC_DECL tmat3x3<T, P> & operator/=(tmat3x3<U, P> const & m);
155 
156  // -- Increment and decrement operators --
157 
158  GLM_FUNC_DECL tmat3x3<T, P> & operator++();
159  GLM_FUNC_DECL tmat3x3<T, P> & operator--();
160  GLM_FUNC_DECL tmat3x3<T, P> operator++(int);
161  GLM_FUNC_DECL tmat3x3<T, P> operator--(int);
162  };
163 
164  // -- Unary operators --
165 
166  template <typename T, precision P>
167  GLM_FUNC_DECL tmat3x3<T, P> const operator-(tmat3x3<T, P> const & m);
168 
169  // -- Binary operators --
170 
171  template <typename T, precision P>
172  GLM_FUNC_DECL tmat3x3<T, P> operator+(tmat3x3<T, P> const & m, T const & s);
173 
174  template <typename T, precision P>
175  GLM_FUNC_DECL tmat3x3<T, P> operator+(T const & s, tmat3x3<T, P> const & m);
176 
177  template <typename T, precision P>
178  GLM_FUNC_DECL tmat3x3<T, P> operator+(tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m2);
179 
180  template <typename T, precision P>
181  GLM_FUNC_DECL tmat3x3<T, P> operator-(tmat3x3<T, P> const & m, T const & s);
182 
183  template <typename T, precision P>
184  GLM_FUNC_DECL tmat3x3<T, P> operator-(T const & s, tmat3x3<T, P> const & m);
185 
186  template <typename T, precision P>
187  GLM_FUNC_DECL tmat3x3<T, P> operator-(tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m2);
188 
189  template <typename T, precision P>
190  GLM_FUNC_DECL tmat3x3<T, P> operator*(tmat3x3<T, P> const & m, T const & s);
191 
192  template <typename T, precision P>
193  GLM_FUNC_DECL tmat3x3<T, P> operator*(T const & s, tmat3x3<T, P> const & m);
194 
195  template <typename T, precision P>
196  GLM_FUNC_DECL typename tmat3x3<T, P>::col_type operator*(tmat3x3<T, P> const & m, typename tmat3x3<T, P>::row_type const & v);
197 
198  template <typename T, precision P>
199  GLM_FUNC_DECL typename tmat3x3<T, P>::row_type operator*(typename tmat3x3<T, P>::col_type const & v, tmat3x3<T, P> const & m);
200 
201  template <typename T, precision P>
202  GLM_FUNC_DECL tmat3x3<T, P> operator*(tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m2);
203 
204  template <typename T, precision P>
205  GLM_FUNC_DECL tmat2x3<T, P> operator*(tmat3x3<T, P> const & m1, tmat2x3<T, P> const & m2);
206 
207  template <typename T, precision P>
208  GLM_FUNC_DECL tmat4x3<T, P> operator*(tmat3x3<T, P> const & m1, tmat4x3<T, P> const & m2);
209 
210  template <typename T, precision P>
211  GLM_FUNC_DECL tmat3x3<T, P> operator/(tmat3x3<T, P> const & m, T const & s);
212 
213  template <typename T, precision P>
214  GLM_FUNC_DECL tmat3x3<T, P> operator/(T const & s, tmat3x3<T, P> const & m);
215 
216  template <typename T, precision P>
217  GLM_FUNC_DECL typename tmat3x3<T, P>::col_type operator/(tmat3x3<T, P> const & m, typename tmat3x3<T, P>::row_type const & v);
218 
219  template <typename T, precision P>
220  GLM_FUNC_DECL typename tmat3x3<T, P>::row_type operator/(typename tmat3x3<T, P>::col_type const & v, tmat3x3<T, P> const & m);
221 
222  template <typename T, precision P>
223  GLM_FUNC_DECL tmat3x3<T, P> operator/(tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m2);
224 
225  // -- Boolean operators --
226 
227  template <typename T, precision P>
228  GLM_FUNC_DECL bool operator==(tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m2);
229 
230  template <typename T, precision P>
231  GLM_FUNC_DECL bool operator!=(tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m2);
232 }//namespace glm
233 
234 #ifndef GLM_EXTERNAL_TEMPLATE
235 #include "type_mat3x3.inl"
236 #endif
type_vec3.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::length
GLM_FUNC_DECL T length(vecType< T, P > const &x)
Returns the length of x, i.e., sqrt(x * x).
glm
Definition: _noise.hpp:40
type_mat.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00126.html000066400000000000000000000103471356361734700216500ustar00rootroot00000000000000 0.9.7: type_mat3x4.hpp File Reference
type_mat3x4.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2006-08-05 / 2011-06-15
Author
Christophe Riccio

Definition in file type_mat3x4.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00126_source.html000066400000000000000000000766461356361734700232460ustar00rootroot00000000000000 0.9.7: type_mat3x4.hpp Source File
type_mat3x4.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "../fwd.hpp"
36 #include "type_vec3.hpp"
37 #include "type_vec4.hpp"
38 #include "type_mat.hpp"
39 #include <limits>
40 #include <cstddef>
41 
42 namespace glm
43 {
44  template <typename T, precision P = defaultp>
45  struct tmat3x4
46  {
47  typedef tvec4<T, P> col_type;
48  typedef tvec3<T, P> row_type;
49  typedef tmat3x4<T, P> type;
50  typedef tmat4x3<T, P> transpose_type;
51  typedef T value_type;
52 
53 # ifdef GLM_META_PROG_HELPERS
54  static GLM_RELAXED_CONSTEXPR length_t components = 3;
55  static GLM_RELAXED_CONSTEXPR length_t cols = 3;
56  static GLM_RELAXED_CONSTEXPR length_t rows = 4;
57  static GLM_RELAXED_CONSTEXPR precision prec = P;
58 # endif//GLM_META_PROG_HELPERS
59 
60  private:
61  col_type value[3];
62 
63  public:
64  // -- Constructors --
65 
66  GLM_FUNC_DECL tmat3x4() GLM_DEFAULT_CTOR;
67  GLM_FUNC_DECL tmat3x4(tmat3x4<T, P> const & m) GLM_DEFAULT;
68  template <precision Q>
69  GLM_FUNC_DECL tmat3x4(tmat3x4<T, Q> const & m);
70 
71  GLM_FUNC_DECL explicit tmat3x4(ctor);
72  GLM_FUNC_DECL explicit tmat3x4(T const & s);
73  GLM_FUNC_DECL tmat3x4(
74  T const & x0, T const & y0, T const & z0, T const & w0,
75  T const & x1, T const & y1, T const & z1, T const & w1,
76  T const & x2, T const & y2, T const & z2, T const & w2);
77  GLM_FUNC_DECL tmat3x4(
78  col_type const & v0,
79  col_type const & v1,
80  col_type const & v2);
81 
82  // -- Conversions --
83 
84  template<
85  typename X1, typename Y1, typename Z1, typename W1,
86  typename X2, typename Y2, typename Z2, typename W2,
87  typename X3, typename Y3, typename Z3, typename W3>
88  GLM_FUNC_DECL tmat3x4(
89  X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1,
90  X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2,
91  X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3);
92 
93  template <typename V1, typename V2, typename V3>
94  GLM_FUNC_DECL tmat3x4(
95  tvec4<V1, P> const & v1,
96  tvec4<V2, P> const & v2,
97  tvec4<V3, P> const & v3);
98 
99  // -- Matrix conversions --
100 
101  template <typename U, precision Q>
102  GLM_FUNC_DECL GLM_EXPLICIT tmat3x4(tmat3x4<U, Q> const & m);
103 
104  GLM_FUNC_DECL explicit tmat3x4(tmat2x2<T, P> const & x);
105  GLM_FUNC_DECL explicit tmat3x4(tmat3x3<T, P> const & x);
106  GLM_FUNC_DECL explicit tmat3x4(tmat4x4<T, P> const & x);
107  GLM_FUNC_DECL explicit tmat3x4(tmat2x3<T, P> const & x);
108  GLM_FUNC_DECL explicit tmat3x4(tmat3x2<T, P> const & x);
109  GLM_FUNC_DECL explicit tmat3x4(tmat2x4<T, P> const & x);
110  GLM_FUNC_DECL explicit tmat3x4(tmat4x2<T, P> const & x);
111  GLM_FUNC_DECL explicit tmat3x4(tmat4x3<T, P> const & x);
112 
113  // -- Accesses --
114 
115 # ifdef GLM_FORCE_SIZE_FUNC
116  typedef size_t size_type;
117  GLM_FUNC_DECL GLM_CONSTEXPR size_t size() const;
118 
119  GLM_FUNC_DECL col_type & operator[](size_type i);
120  GLM_FUNC_DECL col_type const & operator[](size_type i) const;
121 # else
122  typedef length_t length_type;
123  GLM_FUNC_DECL GLM_CONSTEXPR length_type length() const;
124 
125  GLM_FUNC_DECL col_type & operator[](length_type i);
126  GLM_FUNC_DECL col_type const & operator[](length_type i) const;
127 # endif//GLM_FORCE_SIZE_FUNC
128 
129  // -- Unary arithmetic operators --
130 
131  GLM_FUNC_DECL tmat3x4<T, P> & operator=(tmat3x4<T, P> const & m) GLM_DEFAULT;
132 
133  template <typename U>
134  GLM_FUNC_DECL tmat3x4<T, P> & operator=(tmat3x4<U, P> const & m);
135  template <typename U>
136  GLM_FUNC_DECL tmat3x4<T, P> & operator+=(U s);
137  template <typename U>
138  GLM_FUNC_DECL tmat3x4<T, P> & operator+=(tmat3x4<U, P> const & m);
139  template <typename U>
140  GLM_FUNC_DECL tmat3x4<T, P> & operator-=(U s);
141  template <typename U>
142  GLM_FUNC_DECL tmat3x4<T, P> & operator-=(tmat3x4<U, P> const & m);
143  template <typename U>
144  GLM_FUNC_DECL tmat3x4<T, P> & operator*=(U s);
145  template <typename U>
146  GLM_FUNC_DECL tmat3x4<T, P> & operator/=(U s);
147 
148  // -- Increment and decrement operators --
149 
150  GLM_FUNC_DECL tmat3x4<T, P> & operator++();
151  GLM_FUNC_DECL tmat3x4<T, P> & operator--();
152  GLM_FUNC_DECL tmat3x4<T, P> operator++(int);
153  GLM_FUNC_DECL tmat3x4<T, P> operator--(int);
154  };
155 
156  // -- Unary operators --
157 
158  template <typename T, precision P>
159  GLM_FUNC_DECL tmat3x4<T, P> const operator-(tmat3x4<T, P> const & m);
160 
161  // -- Binary operators --
162 
163  template <typename T, precision P>
164  GLM_FUNC_DECL tmat3x4<T, P> operator+(tmat3x4<T, P> const & m, T const & s);
165 
166  template <typename T, precision P>
167  GLM_FUNC_DECL tmat3x4<T, P> operator+(tmat3x4<T, P> const & m1, tmat3x4<T, P> const & m2);
168 
169  template <typename T, precision P>
170  GLM_FUNC_DECL tmat3x4<T, P> operator-(tmat3x4<T, P> const & m, T const & s);
171 
172  template <typename T, precision P>
173  GLM_FUNC_DECL tmat3x4<T, P> operator-(tmat3x4<T, P> const & m1, tmat3x4<T, P> const & m2);
174 
175  template <typename T, precision P>
176  GLM_FUNC_DECL tmat3x4<T, P> operator*(tmat3x4<T, P> const & m, T const & s);
177 
178  template <typename T, precision P>
179  GLM_FUNC_DECL tmat3x4<T, P> operator*(T const & s, tmat3x4<T, P> const & m);
180 
181  template <typename T, precision P>
182  GLM_FUNC_DECL typename tmat3x4<T, P>::col_type operator*(tmat3x4<T, P> const & m, typename tmat3x4<T, P>::row_type const & v);
183 
184  template <typename T, precision P>
185  GLM_FUNC_DECL typename tmat3x4<T, P>::row_type operator*(typename tmat3x4<T, P>::col_type const & v, tmat3x4<T, P> const & m);
186 
187  template <typename T, precision P>
188  GLM_FUNC_DECL tmat4x4<T, P> operator*(tmat3x4<T, P> const & m1, tmat4x3<T, P> const & m2);
189 
190  template <typename T, precision P>
191  GLM_FUNC_DECL tmat2x4<T, P> operator*(tmat3x4<T, P> const & m1, tmat2x3<T, P> const & m2);
192 
193  template <typename T, precision P>
194  GLM_FUNC_DECL tmat3x4<T, P> operator*(tmat3x4<T, P> const & m1, tmat3x3<T, P> const & m2);
195 
196  template <typename T, precision P>
197  GLM_FUNC_DECL tmat3x4<T, P> operator/(tmat3x4<T, P> const & m, T const & s);
198 
199  template <typename T, precision P>
200  GLM_FUNC_DECL tmat3x4<T, P> operator/(T const & s, tmat3x4<T, P> const & m);
201 
202  // -- Boolean operators --
203 
204  template <typename T, precision P>
205  GLM_FUNC_DECL bool operator==(tmat3x4<T, P> const & m1, tmat3x4<T, P> const & m2);
206 
207  template <typename T, precision P>
208  GLM_FUNC_DECL bool operator!=(tmat3x4<T, P> const & m1, tmat3x4<T, P> const & m2);
209 }//namespace glm
210 
211 #ifndef GLM_EXTERNAL_TEMPLATE
212 #include "type_mat3x4.inl"
213 #endif
type_vec3.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::length
GLM_FUNC_DECL T length(vecType< T, P > const &x)
Returns the length of x, i.e., sqrt(x * x).
glm
Definition: _noise.hpp:40
type_mat.hpp
OpenGL Mathematics (glm.g-truc.net)
type_vec4.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00127.html000066400000000000000000000103471356361734700216510ustar00rootroot00000000000000 0.9.7: type_mat4x2.hpp File Reference
type_mat4x2.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2006-10-01 / 2011-06-15
Author
Christophe Riccio

Definition in file type_mat4x2.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00127_source.html000066400000000000000000000775061356361734700232430ustar00rootroot00000000000000 0.9.7: type_mat4x2.hpp Source File
type_mat4x2.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "../fwd.hpp"
36 #include "type_vec2.hpp"
37 #include "type_vec4.hpp"
38 #include "type_mat.hpp"
39 #include <limits>
40 #include <cstddef>
41 
42 namespace glm
43 {
44  template <typename T, precision P = defaultp>
45  struct tmat4x2
46  {
47  typedef tvec2<T, P> col_type;
48  typedef tvec4<T, P> row_type;
49  typedef tmat4x2<T, P> type;
50  typedef tmat2x4<T, P> transpose_type;
51  typedef T value_type;
52 
53 # ifdef GLM_META_PROG_HELPERS
54  static GLM_RELAXED_CONSTEXPR length_t components = 4;
55  static GLM_RELAXED_CONSTEXPR length_t cols = 4;
56  static GLM_RELAXED_CONSTEXPR length_t rows = 2;
57  static GLM_RELAXED_CONSTEXPR precision prec = P;
58 # endif//GLM_META_PROG_HELPERS
59 
60  private:
61  col_type value[4];
62 
63  public:
64  // -- Constructors --
65 
66  GLM_FUNC_DECL tmat4x2() GLM_DEFAULT_CTOR;
67  GLM_FUNC_DECL tmat4x2(tmat4x2<T, P> const & m) GLM_DEFAULT;
68  template <precision Q>
69  GLM_FUNC_DECL tmat4x2(tmat4x2<T, Q> const & m);
70 
71  GLM_FUNC_DECL explicit tmat4x2(ctor);
72  GLM_FUNC_DECL explicit tmat4x2(T const & x);
73  GLM_FUNC_DECL tmat4x2(
74  T const & x0, T const & y0,
75  T const & x1, T const & y1,
76  T const & x2, T const & y2,
77  T const & x3, T const & y3);
78  GLM_FUNC_DECL tmat4x2(
79  col_type const & v0,
80  col_type const & v1,
81  col_type const & v2,
82  col_type const & v3);
83 
84  // -- Conversions --
85 
86  template <
87  typename X1, typename Y1,
88  typename X2, typename Y2,
89  typename X3, typename Y3,
90  typename X4, typename Y4>
91  GLM_FUNC_DECL tmat4x2(
92  X1 const & x1, Y1 const & y1,
93  X2 const & x2, Y2 const & y2,
94  X3 const & x3, Y3 const & y3,
95  X4 const & x4, Y4 const & y4);
96 
97  template <typename V1, typename V2, typename V3, typename V4>
98  GLM_FUNC_DECL tmat4x2(
99  tvec2<V1, P> const & v1,
100  tvec2<V2, P> const & v2,
101  tvec2<V3, P> const & v3,
102  tvec2<V4, P> const & v4);
103 
104  // -- Matrix conversions --
105 
106  template <typename U, precision Q>
107  GLM_FUNC_DECL GLM_EXPLICIT tmat4x2(tmat4x2<U, Q> const & m);
108 
109  GLM_FUNC_DECL explicit tmat4x2(tmat2x2<T, P> const & x);
110  GLM_FUNC_DECL explicit tmat4x2(tmat3x3<T, P> const & x);
111  GLM_FUNC_DECL explicit tmat4x2(tmat4x4<T, P> const & x);
112  GLM_FUNC_DECL explicit tmat4x2(tmat2x3<T, P> const & x);
113  GLM_FUNC_DECL explicit tmat4x2(tmat3x2<T, P> const & x);
114  GLM_FUNC_DECL explicit tmat4x2(tmat2x4<T, P> const & x);
115  GLM_FUNC_DECL explicit tmat4x2(tmat4x3<T, P> const & x);
116  GLM_FUNC_DECL explicit tmat4x2(tmat3x4<T, P> const & x);
117 
118  // -- Accesses --
119 
120 # ifdef GLM_FORCE_SIZE_FUNC
121  typedef size_t size_type;
122  GLM_FUNC_DECL GLM_CONSTEXPR size_t size() const;
123 
124  GLM_FUNC_DECL col_type & operator[](size_type i);
125  GLM_FUNC_DECL col_type const & operator[](size_type i) const;
126 # else
127  typedef length_t length_type;
128  GLM_FUNC_DECL GLM_CONSTEXPR length_type length() const;
129 
130  GLM_FUNC_DECL col_type & operator[](length_type i);
131  GLM_FUNC_DECL col_type const & operator[](length_type i) const;
132 # endif//GLM_FORCE_SIZE_FUNC
133 
134  // -- Unary arithmetic operators --
135 
136  GLM_FUNC_DECL tmat4x2<T, P> & operator=(tmat4x2<T, P> const & m) GLM_DEFAULT;
137 
138  template <typename U>
139  GLM_FUNC_DECL tmat4x2<T, P> & operator=(tmat4x2<U, P> const & m);
140  template <typename U>
141  GLM_FUNC_DECL tmat4x2<T, P> & operator+=(U s);
142  template <typename U>
143  GLM_FUNC_DECL tmat4x2<T, P> & operator+=(tmat4x2<U, P> const & m);
144  template <typename U>
145  GLM_FUNC_DECL tmat4x2<T, P> & operator-=(U s);
146  template <typename U>
147  GLM_FUNC_DECL tmat4x2<T, P> & operator-=(tmat4x2<U, P> const & m);
148  template <typename U>
149  GLM_FUNC_DECL tmat4x2<T, P> & operator*=(U s);
150  template <typename U>
151  GLM_FUNC_DECL tmat4x2<T, P> & operator/=(U s);
152 
153  // -- Increment and decrement operators --
154 
155  GLM_FUNC_DECL tmat4x2<T, P> & operator++ ();
156  GLM_FUNC_DECL tmat4x2<T, P> & operator-- ();
157  GLM_FUNC_DECL tmat4x2<T, P> operator++(int);
158  GLM_FUNC_DECL tmat4x2<T, P> operator--(int);
159  };
160 
161  // -- Unary operators --
162 
163  template <typename T, precision P>
164  GLM_FUNC_DECL tmat4x2<T, P> const operator-(tmat4x2<T, P> const & m);
165 
166  // -- Binary operators --
167 
168  template <typename T, precision P>
169  GLM_FUNC_DECL tmat4x2<T, P> operator+(tmat4x2<T, P> const & m, T const & s);
170 
171  template <typename T, precision P>
172  GLM_FUNC_DECL tmat4x2<T, P> operator+(tmat4x2<T, P> const & m1, tmat4x2<T, P> const & m2);
173 
174  template <typename T, precision P>
175  GLM_FUNC_DECL tmat4x2<T, P> operator-(tmat4x2<T, P> const & m, T const & s);
176 
177  template <typename T, precision P>
178  GLM_FUNC_DECL tmat4x2<T, P> operator-(tmat4x2<T, P> const & m1, tmat4x2<T, P> const & m2);
179 
180  template <typename T, precision P>
181  GLM_FUNC_DECL tmat4x2<T, P> operator*(tmat4x2<T, P> const & m, T const & s);
182 
183  template <typename T, precision P>
184  GLM_FUNC_DECL tmat4x2<T, P> operator*(T const & s, tmat4x2<T, P> const & m);
185 
186  template <typename T, precision P>
187  GLM_FUNC_DECL typename tmat4x2<T, P>::col_type operator*(tmat4x2<T, P> const & m, typename tmat4x2<T, P>::row_type const & v);
188 
189  template <typename T, precision P>
190  GLM_FUNC_DECL typename tmat4x2<T, P>::row_type operator*(typename tmat4x2<T, P>::col_type const & v, tmat4x2<T, P> const & m);
191 
192  template <typename T, precision P>
193  GLM_FUNC_DECL tmat3x2<T, P> operator*(tmat4x2<T, P> const & m1, tmat3x4<T, P> const & m2);
194 
195  template <typename T, precision P>
196  GLM_FUNC_DECL tmat4x2<T, P> operator*(tmat4x2<T, P> const & m1, tmat4x4<T, P> const & m2);
197 
198  template <typename T, precision P>
199  GLM_FUNC_DECL tmat2x3<T, P> operator*(tmat4x3<T, P> const & m1, tmat2x4<T, P> const & m2);
200 
201  template <typename T, precision P>
202  GLM_FUNC_DECL tmat4x2<T, P> operator/(tmat4x2<T, P> const & m, T const & s);
203 
204  template <typename T, precision P>
205  GLM_FUNC_DECL tmat4x2<T, P> operator/(T const & s, tmat4x2<T, P> const & m);
206 
207  // -- Boolean operators --
208 
209  template <typename T, precision P>
210  GLM_FUNC_DECL bool operator==(tmat4x2<T, P> const & m1, tmat4x2<T, P> const & m2);
211 
212  template <typename T, precision P>
213  GLM_FUNC_DECL bool operator!=(tmat4x2<T, P> const & m1, tmat4x2<T, P> const & m2);
214 }//namespace glm
215 
216 #ifndef GLM_EXTERNAL_TEMPLATE
217 #include "type_mat4x2.inl"
218 #endif
glm::length
GLM_FUNC_DECL T length(vecType< T, P > const &x)
Returns the length of x, i.e., sqrt(x * x).
glm
Definition: _noise.hpp:40
type_vec2.hpp
OpenGL Mathematics (glm.g-truc.net)
type_mat.hpp
OpenGL Mathematics (glm.g-truc.net)
type_vec4.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00128.html000066400000000000000000000103471356361734700216520ustar00rootroot00000000000000 0.9.7: type_mat4x3.hpp File Reference
type_mat4x3.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2006-08-04 / 2011-06-15
Author
Christophe Riccio

Definition in file type_mat4x3.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00128_source.html000066400000000000000000001000441356361734700232240ustar00rootroot00000000000000 0.9.7: type_mat4x3.hpp Source File
type_mat4x3.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "../fwd.hpp"
36 #include "type_vec3.hpp"
37 #include "type_vec4.hpp"
38 #include "type_mat.hpp"
39 #include <limits>
40 #include <cstddef>
41 
42 namespace glm
43 {
44  template <typename T, precision P = defaultp>
45  struct tmat4x3
46  {
47  typedef tvec3<T, P> col_type;
48  typedef tvec4<T, P> row_type;
49  typedef tmat4x3<T, P> type;
50  typedef tmat3x4<T, P> transpose_type;
51  typedef T value_type;
52 
53 # ifdef GLM_META_PROG_HELPERS
54  static GLM_RELAXED_CONSTEXPR length_t components = 4;
55  static GLM_RELAXED_CONSTEXPR length_t cols = 4;
56  static GLM_RELAXED_CONSTEXPR length_t rows = 3;
57  static GLM_RELAXED_CONSTEXPR precision prec = P;
58 # endif//GLM_META_PROG_HELPERS
59 
60  private:
61  col_type value[4];
62 
63  public:
64  // -- Constructors --
65 
66  GLM_FUNC_DECL tmat4x3() GLM_DEFAULT_CTOR;
67  GLM_FUNC_DECL tmat4x3(tmat4x3<T, P> const & m) GLM_DEFAULT;
68  template <precision Q>
69  GLM_FUNC_DECL tmat4x3(tmat4x3<T, Q> const & m);
70 
71  GLM_FUNC_DECL explicit tmat4x3(ctor);
72  GLM_FUNC_DECL explicit tmat4x3(T const & x);
73  GLM_FUNC_DECL tmat4x3(
74  T const & x0, T const & y0, T const & z0,
75  T const & x1, T const & y1, T const & z1,
76  T const & x2, T const & y2, T const & z2,
77  T const & x3, T const & y3, T const & z3);
78  GLM_FUNC_DECL tmat4x3(
79  col_type const & v0,
80  col_type const & v1,
81  col_type const & v2,
82  col_type const & v3);
83 
84  // -- Conversions --
85 
86  template <
87  typename X1, typename Y1, typename Z1,
88  typename X2, typename Y2, typename Z2,
89  typename X3, typename Y3, typename Z3,
90  typename X4, typename Y4, typename Z4>
91  GLM_FUNC_DECL tmat4x3(
92  X1 const & x1, Y1 const & y1, Z1 const & z1,
93  X2 const & x2, Y2 const & y2, Z2 const & z2,
94  X3 const & x3, Y3 const & y3, Z3 const & z3,
95  X4 const & x4, Y4 const & y4, Z4 const & z4);
96 
97  template <typename V1, typename V2, typename V3, typename V4>
98  GLM_FUNC_DECL tmat4x3(
99  tvec3<V1, P> const & v1,
100  tvec3<V2, P> const & v2,
101  tvec3<V3, P> const & v3,
102  tvec3<V4, P> const & v4);
103 
104  // -- Matrix conversions --
105 
106  template <typename U, precision Q>
107  GLM_FUNC_DECL GLM_EXPLICIT tmat4x3(tmat4x3<U, Q> const & m);
108 
109  GLM_FUNC_DECL explicit tmat4x3(tmat2x2<T, P> const & x);
110  GLM_FUNC_DECL explicit tmat4x3(tmat3x3<T, P> const & x);
111  GLM_FUNC_DECL explicit tmat4x3(tmat4x4<T, P> const & x);
112  GLM_FUNC_DECL explicit tmat4x3(tmat2x3<T, P> const & x);
113  GLM_FUNC_DECL explicit tmat4x3(tmat3x2<T, P> const & x);
114  GLM_FUNC_DECL explicit tmat4x3(tmat2x4<T, P> const & x);
115  GLM_FUNC_DECL explicit tmat4x3(tmat4x2<T, P> const & x);
116  GLM_FUNC_DECL explicit tmat4x3(tmat3x4<T, P> const & x);
117 
118  // -- Accesses --
119 
120 # ifdef GLM_FORCE_SIZE_FUNC
121  typedef size_t size_type;
122  GLM_FUNC_DECL GLM_CONSTEXPR size_t size() const;
123 
124  GLM_FUNC_DECL col_type & operator[](size_type i);
125  GLM_FUNC_DECL col_type const & operator[](size_type i) const;
126 # else
127  typedef length_t length_type;
128  GLM_FUNC_DECL GLM_CONSTEXPR length_type length() const;
129 
130  GLM_FUNC_DECL col_type & operator[](length_type i);
131  GLM_FUNC_DECL col_type const & operator[](length_type i) const;
132 # endif//GLM_FORCE_SIZE_FUNC
133 
134  // -- Unary arithmetic operators --
135 
136  GLM_FUNC_DECL tmat4x3<T, P> & operator=(tmat4x3<T, P> const & m) GLM_DEFAULT;
137 
138  template <typename U>
139  GLM_FUNC_DECL tmat4x3<T, P> & operator=(tmat4x3<U, P> const & m);
140  template <typename U>
141  GLM_FUNC_DECL tmat4x3<T, P> & operator+=(U s);
142  template <typename U>
143  GLM_FUNC_DECL tmat4x3<T, P> & operator+=(tmat4x3<U, P> const & m);
144  template <typename U>
145  GLM_FUNC_DECL tmat4x3<T, P> & operator-=(U s);
146  template <typename U>
147  GLM_FUNC_DECL tmat4x3<T, P> & operator-=(tmat4x3<U, P> const & m);
148  template <typename U>
149  GLM_FUNC_DECL tmat4x3<T, P> & operator*=(U s);
150  template <typename U>
151  GLM_FUNC_DECL tmat4x3<T, P> & operator/=(U s);
152 
153  // -- Increment and decrement operators --
154 
155  GLM_FUNC_DECL tmat4x3<T, P> & operator++();
156  GLM_FUNC_DECL tmat4x3<T, P> & operator--();
157  GLM_FUNC_DECL tmat4x3<T, P> operator++(int);
158  GLM_FUNC_DECL tmat4x3<T, P> operator--(int);
159  };
160 
161  // -- Unary operators --
162 
163  template <typename T, precision P>
164  GLM_FUNC_DECL tmat4x3<T, P> const operator-(tmat4x3<T, P> const & m);
165 
166  // -- Binary operators --
167 
168  template <typename T, precision P>
169  GLM_FUNC_DECL tmat4x3<T, P> operator+(tmat4x3<T, P> const & m, T const & s);
170 
171  template <typename T, precision P>
172  GLM_FUNC_DECL tmat4x3<T, P> operator+(tmat4x3<T, P> const & m1, tmat4x3<T, P> const & m2);
173 
174  template <typename T, precision P>
175  GLM_FUNC_DECL tmat4x3<T, P> operator-(tmat4x3<T, P> const & m, T const & s);
176 
177  template <typename T, precision P>
178  GLM_FUNC_DECL tmat4x3<T, P> operator-(tmat4x3<T, P> const & m1, tmat4x3<T, P> const & m2);
179 
180  template <typename T, precision P>
181  GLM_FUNC_DECL tmat4x3<T, P> operator*(tmat4x3<T, P> const & m, T const & s);
182 
183  template <typename T, precision P>
184  GLM_FUNC_DECL tmat4x3<T, P> operator*(T const & s, tmat4x3<T, P> const & m);
185 
186  template <typename T, precision P>
187  GLM_FUNC_DECL typename tmat4x3<T, P>::col_type operator*(tmat4x3<T, P> const & m, typename tmat4x3<T, P>::row_type const & v);
188 
189  template <typename T, precision P>
190  GLM_FUNC_DECL typename tmat4x3<T, P>::row_type operator*(typename tmat4x3<T, P>::col_type const & v, tmat4x3<T, P> const & m);
191 
192  template <typename T, precision P>
193  GLM_FUNC_DECL tmat2x3<T, P> operator*(tmat4x3<T, P> const & m1, tmat2x4<T, P> const & m2);
194 
195  template <typename T, precision P>
196  GLM_FUNC_DECL tmat3x3<T, P> operator*(tmat4x3<T, P> const & m1, tmat3x4<T, P> const & m2);
197 
198  template <typename T, precision P>
199  GLM_FUNC_DECL tmat4x3<T, P> operator*(tmat4x3<T, P> const & m1, tmat4x4<T, P> const & m2);
200 
201  template <typename T, precision P>
202  GLM_FUNC_DECL tmat4x3<T, P> operator/(tmat4x3<T, P> const & m, T const & s);
203 
204  template <typename T, precision P>
205  GLM_FUNC_DECL tmat4x3<T, P> operator/(T const & s, tmat4x3<T, P> const & m);
206 
207  // -- Boolean operators --
208 
209  template <typename T, precision P>
210  GLM_FUNC_DECL bool operator==(tmat4x3<T, P> const & m1, tmat4x3<T, P> const & m2);
211 
212  template <typename T, precision P>
213  GLM_FUNC_DECL bool operator!=(tmat4x3<T, P> const & m1, tmat4x3<T, P> const & m2);
214 }//namespace glm
215 
216 #ifndef GLM_EXTERNAL_TEMPLATE
217 #include "type_mat4x3.inl"
218 #endif //GLM_EXTERNAL_TEMPLATE
type_vec3.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::length
GLM_FUNC_DECL T length(vecType< T, P > const &x)
Returns the length of x, i.e., sqrt(x * x).
glm
Definition: _noise.hpp:40
type_mat.hpp
OpenGL Mathematics (glm.g-truc.net)
type_vec4.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00129.html000066400000000000000000000103471356361734700216530ustar00rootroot00000000000000 0.9.7: type_mat4x4.hpp File Reference
type_mat4x4.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2005-01-27 / 2011-06-15
Author
Christophe Riccio

Definition in file type_mat4x4.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00129_source.html000066400000000000000000001107351356361734700232350ustar00rootroot00000000000000 0.9.7: type_mat4x4.hpp Source File
type_mat4x4.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "../fwd.hpp"
36 #include "type_vec4.hpp"
37 #include "type_mat.hpp"
38 #include <limits>
39 #include <cstddef>
40 
41 namespace glm
42 {
43  template <typename T, precision P = defaultp>
44  struct tmat4x4
45  {
46  typedef tvec4<T, P> col_type;
47  typedef tvec4<T, P> row_type;
48  typedef tmat4x4<T, P> type;
49  typedef tmat4x4<T, P> transpose_type;
50  typedef T value_type;
51 
52 # ifdef GLM_META_PROG_HELPERS
53  static GLM_RELAXED_CONSTEXPR length_t components = 4;
54  static GLM_RELAXED_CONSTEXPR length_t cols = 4;
55  static GLM_RELAXED_CONSTEXPR length_t rows = 4;
56  static GLM_RELAXED_CONSTEXPR precision prec = P;
57 # endif//GLM_META_PROG_HELPERS
58 
59  template <typename U, precision Q>
60  friend tvec4<U, Q> operator/(tmat4x4<U, Q> const & m, tvec4<U, Q> const & v);
61  template <typename U, precision Q>
62  friend tvec4<U, Q> operator/(tvec4<U, Q> const & v, tmat4x4<U, Q> const & m);
63 
64  private:
65  col_type value[4];
66 
67  public:
68  // -- Constructors --
69 
70  GLM_FUNC_DECL tmat4x4() GLM_DEFAULT_CTOR;
71  GLM_FUNC_DECL tmat4x4(tmat4x4<T, P> const & m) GLM_DEFAULT;
72  template <precision Q>
73  GLM_FUNC_DECL tmat4x4(tmat4x4<T, Q> const & m);
74 
75  GLM_FUNC_DECL explicit tmat4x4(ctor);
76  GLM_FUNC_DECL explicit tmat4x4(T const & x);
77  GLM_FUNC_DECL tmat4x4(
78  T const & x0, T const & y0, T const & z0, T const & w0,
79  T const & x1, T const & y1, T const & z1, T const & w1,
80  T const & x2, T const & y2, T const & z2, T const & w2,
81  T const & x3, T const & y3, T const & z3, T const & w3);
82  GLM_FUNC_DECL tmat4x4(
83  col_type const & v0,
84  col_type const & v1,
85  col_type const & v2,
86  col_type const & v3);
87 
88  // -- Conversions --
89 
90  template <
91  typename X1, typename Y1, typename Z1, typename W1,
92  typename X2, typename Y2, typename Z2, typename W2,
93  typename X3, typename Y3, typename Z3, typename W3,
94  typename X4, typename Y4, typename Z4, typename W4>
95  GLM_FUNC_DECL tmat4x4(
96  X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1,
97  X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2,
98  X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3,
99  X4 const & x4, Y4 const & y4, Z4 const & z4, W4 const & w4);
100 
101  template <typename V1, typename V2, typename V3, typename V4>
102  GLM_FUNC_DECL tmat4x4(
103  tvec4<V1, P> const & v1,
104  tvec4<V2, P> const & v2,
105  tvec4<V3, P> const & v3,
106  tvec4<V4, P> const & v4);
107 
108  // -- Matrix conversions --
109 
110  template <typename U, precision Q>
111  GLM_FUNC_DECL GLM_EXPLICIT tmat4x4(tmat4x4<U, Q> const & m);
112 
113  GLM_FUNC_DECL explicit tmat4x4(tmat2x2<T, P> const & x);
114  GLM_FUNC_DECL explicit tmat4x4(tmat3x3<T, P> const & x);
115  GLM_FUNC_DECL explicit tmat4x4(tmat2x3<T, P> const & x);
116  GLM_FUNC_DECL explicit tmat4x4(tmat3x2<T, P> const & x);
117  GLM_FUNC_DECL explicit tmat4x4(tmat2x4<T, P> const & x);
118  GLM_FUNC_DECL explicit tmat4x4(tmat4x2<T, P> const & x);
119  GLM_FUNC_DECL explicit tmat4x4(tmat3x4<T, P> const & x);
120  GLM_FUNC_DECL explicit tmat4x4(tmat4x3<T, P> const & x);
121 
122  // -- Accesses --
123 
124 # ifdef GLM_FORCE_SIZE_FUNC
125  typedef size_t size_type;
126  GLM_FUNC_DECL GLM_CONSTEXPR size_t size() const;
127 
128  GLM_FUNC_DECL col_type & operator[](size_type i);
129  GLM_FUNC_DECL col_type const & operator[](size_type i) const;
130 # else
131  typedef length_t length_type;
132  GLM_FUNC_DECL GLM_CONSTEXPR length_type length() const;
133 
134  GLM_FUNC_DECL col_type & operator[](length_type i);
135  GLM_FUNC_DECL col_type const & operator[](length_type i) const;
136 # endif//GLM_FORCE_SIZE_FUNC
137 
138  // -- Unary arithmetic operators --
139 
140  GLM_FUNC_DECL tmat4x4<T, P> & operator=(tmat4x4<T, P> const & m) GLM_DEFAULT;
141 
142  template <typename U>
143  GLM_FUNC_DECL tmat4x4<T, P> & operator=(tmat4x4<U, P> const & m);
144  template <typename U>
145  GLM_FUNC_DECL tmat4x4<T, P> & operator+=(U s);
146  template <typename U>
147  GLM_FUNC_DECL tmat4x4<T, P> & operator+=(tmat4x4<U, P> const & m);
148  template <typename U>
149  GLM_FUNC_DECL tmat4x4<T, P> & operator-=(U s);
150  template <typename U>
151  GLM_FUNC_DECL tmat4x4<T, P> & operator-=(tmat4x4<U, P> const & m);
152  template <typename U>
153  GLM_FUNC_DECL tmat4x4<T, P> & operator*=(U s);
154  template <typename U>
155  GLM_FUNC_DECL tmat4x4<T, P> & operator*=(tmat4x4<U, P> const & m);
156  template <typename U>
157  GLM_FUNC_DECL tmat4x4<T, P> & operator/=(U s);
158  template <typename U>
159  GLM_FUNC_DECL tmat4x4<T, P> & operator/=(tmat4x4<U, P> const & m);
160 
161  // -- Increment and decrement operators --
162 
163  GLM_FUNC_DECL tmat4x4<T, P> & operator++();
164  GLM_FUNC_DECL tmat4x4<T, P> & operator--();
165  GLM_FUNC_DECL tmat4x4<T, P> operator++(int);
166  GLM_FUNC_DECL tmat4x4<T, P> operator--(int);
167  };
168 
169  // -- Unary operators --
170 
171  template <typename T, precision P>
172  GLM_FUNC_DECL tmat4x4<T, P> const operator-(tmat4x4<T, P> const & m);
173 
174  // -- Binary operators --
175 
176  template <typename T, precision P>
177  GLM_FUNC_DECL tmat4x4<T, P> operator+(tmat4x4<T, P> const & m, T const & s);
178 
179  template <typename T, precision P>
180  GLM_FUNC_DECL tmat4x4<T, P> operator+(T const & s, tmat4x4<T, P> const & m);
181 
182  template <typename T, precision P>
183  GLM_FUNC_DECL tmat4x4<T, P> operator+(tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m2);
184 
185  template <typename T, precision P>
186  GLM_FUNC_DECL tmat4x4<T, P> operator-(tmat4x4<T, P> const & m, T const & s);
187 
188  template <typename T, precision P>
189  GLM_FUNC_DECL tmat4x4<T, P> operator-(T const & s, tmat4x4<T, P> const & m);
190 
191  template <typename T, precision P>
192  GLM_FUNC_DECL tmat4x4<T, P> operator-(tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m2);
193 
194  template <typename T, precision P>
195  GLM_FUNC_DECL tmat4x4<T, P> operator*(tmat4x4<T, P> const & m, T const & s);
196 
197  template <typename T, precision P>
198  GLM_FUNC_DECL tmat4x4<T, P> operator*(T const & s, tmat4x4<T, P> const & m);
199 
200  template <typename T, precision P>
201  GLM_FUNC_DECL typename tmat4x4<T, P>::col_type operator*(tmat4x4<T, P> const & m, typename tmat4x4<T, P>::row_type const & v);
202 
203  template <typename T, precision P>
204  GLM_FUNC_DECL typename tmat4x4<T, P>::row_type operator*(typename tmat4x4<T, P>::col_type const & v, tmat4x4<T, P> const & m);
205 
206  template <typename T, precision P>
207  GLM_FUNC_DECL tmat2x4<T, P> operator*(tmat4x4<T, P> const & m1, tmat2x4<T, P> const & m2);
208 
209  template <typename T, precision P>
210  GLM_FUNC_DECL tmat3x4<T, P> operator*(tmat4x4<T, P> const & m1, tmat3x4<T, P> const & m2);
211 
212  template <typename T, precision P>
213  GLM_FUNC_DECL tmat4x4<T, P> operator*(tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m2);
214 
215  template <typename T, precision P>
216  GLM_FUNC_DECL tmat4x4<T, P> operator/(tmat4x4<T, P> const & m, T const & s);
217 
218  template <typename T, precision P>
219  GLM_FUNC_DECL tmat4x4<T, P> operator/(T const & s, tmat4x4<T, P> const & m);
220 
221  template <typename T, precision P>
222  GLM_FUNC_DECL typename tmat4x4<T, P>::col_type operator/(tmat4x4<T, P> const & m, typename tmat4x4<T, P>::row_type const & v);
223 
224  template <typename T, precision P>
225  GLM_FUNC_DECL typename tmat4x4<T, P>::row_type operator/(typename tmat4x4<T, P>::col_type & v, tmat4x4<T, P> const & m);
226 
227  template <typename T, precision P>
228  GLM_FUNC_DECL tmat4x4<T, P> operator/(tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m2);
229 
230  // -- Boolean operators --
231 
232  template <typename T, precision P>
233  GLM_FUNC_DECL bool operator==(tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m2);
234 
235  template <typename T, precision P>
236  GLM_FUNC_DECL bool operator!=(tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m2);
237 }//namespace glm
238 
239 #ifndef GLM_EXTERNAL_TEMPLATE
240 #include "type_mat4x4.inl"
241 #endif//GLM_EXTERNAL_TEMPLATE
glm::length
GLM_FUNC_DECL T length(vecType< T, P > const &x)
Returns the length of x, i.e., sqrt(x * x).
glm
Definition: _noise.hpp:40
type_mat.hpp
OpenGL Mathematics (glm.g-truc.net)
type_vec4.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00130.html000066400000000000000000000112401356361734700216340ustar00rootroot00000000000000 0.9.7: type_precision.hpp File Reference
type_precision.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTC_type_precision

Date
2009-06-04 / 2011-12-07
Author
Christophe Riccio
See also
GLM Core (dependence)
gtc_half_float (dependence)
GLM_GTC_quaternion (dependence)

Definition in file type_precision.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00130_source.html000066400000000000000000004235321356361734700232270ustar00rootroot00000000000000 0.9.7: type_precision.hpp Source File
type_precision.hpp
Go to the documentation of this file.
1 
47 #pragma once
48 
49 // Dependency:
50 #include "../gtc/quaternion.hpp"
51 #include "../gtc/vec1.hpp"
52 #include "../vec2.hpp"
53 #include "../vec3.hpp"
54 #include "../vec4.hpp"
55 #include "../mat2x2.hpp"
56 #include "../mat2x3.hpp"
57 #include "../mat2x4.hpp"
58 #include "../mat3x2.hpp"
59 #include "../mat3x3.hpp"
60 #include "../mat3x4.hpp"
61 #include "../mat4x2.hpp"
62 #include "../mat4x3.hpp"
63 #include "../mat4x4.hpp"
64 
65 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
66 # pragma message("GLM: GLM_GTC_type_precision extension included")
67 #endif
68 
69 namespace glm
70 {
72  // Signed int vector types
73 
76 
79  typedef detail::int8 lowp_int8;
80 
83  typedef detail::int16 lowp_int16;
84 
87  typedef detail::int32 lowp_int32;
88 
91  typedef detail::int64 lowp_int64;
92 
95  typedef detail::int8 lowp_int8_t;
96 
99  typedef detail::int16 lowp_int16_t;
100 
103  typedef detail::int32 lowp_int32_t;
104 
107  typedef detail::int64 lowp_int64_t;
108 
111  typedef detail::int8 lowp_i8;
112 
115  typedef detail::int16 lowp_i16;
116 
119  typedef detail::int32 lowp_i32;
120 
123  typedef detail::int64 lowp_i64;
124 
127  typedef detail::int8 mediump_int8;
128 
131  typedef detail::int16 mediump_int16;
132 
135  typedef detail::int32 mediump_int32;
136 
139  typedef detail::int64 mediump_int64;
140 
143  typedef detail::int8 mediump_int8_t;
144 
147  typedef detail::int16 mediump_int16_t;
148 
151  typedef detail::int32 mediump_int32_t;
152 
155  typedef detail::int64 mediump_int64_t;
156 
159  typedef detail::int8 mediump_i8;
160 
163  typedef detail::int16 mediump_i16;
164 
167  typedef detail::int32 mediump_i32;
168 
171  typedef detail::int64 mediump_i64;
172 
175  typedef detail::int8 highp_int8;
176 
179  typedef detail::int16 highp_int16;
180 
183  typedef detail::int32 highp_int32;
184 
187  typedef detail::int64 highp_int64;
188 
191  typedef detail::int8 highp_int8_t;
192 
195  typedef detail::int16 highp_int16_t;
196 
199  typedef detail::int32 highp_int32_t;
200 
203  typedef detail::int64 highp_int64_t;
204 
207  typedef detail::int8 highp_i8;
208 
211  typedef detail::int16 highp_i16;
212 
215  typedef detail::int32 highp_i32;
216 
219  typedef detail::int64 highp_i64;
220 
221 
224  typedef detail::int8 int8;
225 
228  typedef detail::int16 int16;
229 
232  typedef detail::int32 int32;
233 
236  typedef detail::int64 int64;
237 
238 #if GLM_HAS_EXTENDED_INTEGER_TYPE
239  using std::int8_t;
240  using std::int16_t;
241  using std::int32_t;
242  using std::int64_t;
243 #else
244  typedef detail::int8 int8_t;
247 
250  typedef detail::int16 int16_t;
251 
254  typedef detail::int32 int32_t;
255 
258  typedef detail::int64 int64_t;
259 #endif
260 
263  typedef detail::int8 i8;
264 
267  typedef detail::int16 i16;
268 
271  typedef detail::int32 i32;
272 
275  typedef detail::int64 i64;
276 
277 
280  typedef tvec1<i8, defaultp> i8vec1;
281 
284  typedef tvec2<i8, defaultp> i8vec2;
285 
288  typedef tvec3<i8, defaultp> i8vec3;
289 
292  typedef tvec4<i8, defaultp> i8vec4;
293 
294 
297  typedef tvec1<i16, defaultp> i16vec1;
298 
301  typedef tvec2<i16, defaultp> i16vec2;
302 
305  typedef tvec3<i16, defaultp> i16vec3;
306 
309  typedef tvec4<i16, defaultp> i16vec4;
310 
311 
314  typedef tvec1<i32, defaultp> i32vec1;
315 
318  typedef tvec2<i32, defaultp> i32vec2;
319 
322  typedef tvec3<i32, defaultp> i32vec3;
323 
326  typedef tvec4<i32, defaultp> i32vec4;
327 
328 
331  typedef tvec1<i64, defaultp> i64vec1;
332 
335  typedef tvec2<i64, defaultp> i64vec2;
336 
339  typedef tvec3<i64, defaultp> i64vec3;
340 
343  typedef tvec4<i64, defaultp> i64vec4;
344 
345 
347  // Unsigned int vector types
348 
351  typedef detail::uint8 lowp_uint8;
352 
355  typedef detail::uint16 lowp_uint16;
356 
359  typedef detail::uint32 lowp_uint32;
360 
363  typedef detail::uint64 lowp_uint64;
364 
367  typedef detail::uint8 lowp_uint8_t;
368 
371  typedef detail::uint16 lowp_uint16_t;
372 
375  typedef detail::uint32 lowp_uint32_t;
376 
379  typedef detail::uint64 lowp_uint64_t;
380 
383  typedef detail::uint8 lowp_u8;
384 
387  typedef detail::uint16 lowp_u16;
388 
391  typedef detail::uint32 lowp_u32;
392 
395  typedef detail::uint64 lowp_u64;
396 
399  typedef detail::uint8 mediump_uint8;
400 
403  typedef detail::uint16 mediump_uint16;
404 
407  typedef detail::uint32 mediump_uint32;
408 
411  typedef detail::uint64 mediump_uint64;
412 
415  typedef detail::uint8 mediump_uint8_t;
416 
419  typedef detail::uint16 mediump_uint16_t;
420 
423  typedef detail::uint32 mediump_uint32_t;
424 
427  typedef detail::uint64 mediump_uint64_t;
428 
431  typedef detail::uint8 mediump_u8;
432 
435  typedef detail::uint16 mediump_u16;
436 
439  typedef detail::uint32 mediump_u32;
440 
443  typedef detail::uint64 mediump_u64;
444 
447  typedef detail::uint8 highp_uint8;
448 
451  typedef detail::uint16 highp_uint16;
452 
455  typedef detail::uint32 highp_uint32;
456 
459  typedef detail::uint64 highp_uint64;
460 
463  typedef detail::uint8 highp_uint8_t;
464 
467  typedef detail::uint16 highp_uint16_t;
468 
471  typedef detail::uint32 highp_uint32_t;
472 
475  typedef detail::uint64 highp_uint64_t;
476 
479  typedef detail::uint8 highp_u8;
480 
483  typedef detail::uint16 highp_u16;
484 
487  typedef detail::uint32 highp_u32;
488 
491  typedef detail::uint64 highp_u64;
492 
495  typedef detail::uint8 uint8;
496 
499  typedef detail::uint16 uint16;
500 
503  typedef detail::uint32 uint32;
504 
507  typedef detail::uint64 uint64;
508 
509 #if GLM_HAS_EXTENDED_INTEGER_TYPE
510  using std::uint8_t;
511  using std::uint16_t;
512  using std::uint32_t;
513  using std::uint64_t;
514 #else
515  typedef detail::uint8 uint8_t;
518 
521  typedef detail::uint16 uint16_t;
522 
525  typedef detail::uint32 uint32_t;
526 
529  typedef detail::uint64 uint64_t;
530 #endif
531 
534  typedef detail::uint8 u8;
535 
538  typedef detail::uint16 u16;
539 
542  typedef detail::uint32 u32;
543 
546  typedef detail::uint64 u64;
547 
548 
549 
552  typedef tvec1<u8, defaultp> u8vec1;
553 
556  typedef tvec2<u8, defaultp> u8vec2;
557 
560  typedef tvec3<u8, defaultp> u8vec3;
561 
564  typedef tvec4<u8, defaultp> u8vec4;
565 
566 
569  typedef tvec1<u16, defaultp> u16vec1;
570 
573  typedef tvec2<u16, defaultp> u16vec2;
574 
577  typedef tvec3<u16, defaultp> u16vec3;
578 
581  typedef tvec4<u16, defaultp> u16vec4;
582 
583 
586  typedef tvec1<u32, defaultp> u32vec1;
587 
590  typedef tvec2<u32, defaultp> u32vec2;
591 
594  typedef tvec3<u32, defaultp> u32vec3;
595 
598  typedef tvec4<u32, defaultp> u32vec4;
599 
600 
603  typedef tvec1<u64, defaultp> u64vec1;
604 
607  typedef tvec2<u64, defaultp> u64vec2;
608 
611  typedef tvec3<u64, defaultp> u64vec3;
612 
615  typedef tvec4<u64, defaultp> u64vec4;
616 
617 
619  // Float vector types
620 
623  typedef detail::float32 float32;
624 
627  typedef detail::float64 float64;
628 
629 
632  typedef detail::float32 float32_t;
633 
636  typedef detail::float64 float64_t;
637 
638 
641  typedef float32 f32;
642 
645  typedef float64 f64;
646 
647 
650  typedef tvec1<float, defaultp> fvec1;
651 
654  typedef tvec2<float, defaultp> fvec2;
655 
658  typedef tvec3<float, defaultp> fvec3;
659 
662  typedef tvec4<float, defaultp> fvec4;
663 
664 
667  typedef tvec1<f32, defaultp> f32vec1;
668 
671  typedef tvec2<f32, defaultp> f32vec2;
672 
675  typedef tvec3<f32, defaultp> f32vec3;
676 
679  typedef tvec4<f32, defaultp> f32vec4;
680 
681 
684  typedef tvec1<f64, defaultp> f64vec1;
685 
688  typedef tvec2<f64, defaultp> f64vec2;
689 
692  typedef tvec3<f64, defaultp> f64vec3;
693 
696  typedef tvec4<f64, defaultp> f64vec4;
697 
698 
700  // Float matrix types
701 
704  //typedef detail::tmat1x1<f32> fmat1;
705 
708  typedef tmat2x2<f32, defaultp> fmat2;
709 
712  typedef tmat3x3<f32, defaultp> fmat3;
713 
716  typedef tmat4x4<f32, defaultp> fmat4;
717 
718 
721  //typedef f32 fmat1x1;
722 
725  typedef tmat2x2<f32, defaultp> fmat2x2;
726 
729  typedef tmat2x3<f32, defaultp> fmat2x3;
730 
733  typedef tmat2x4<f32, defaultp> fmat2x4;
734 
737  typedef tmat3x2<f32, defaultp> fmat3x2;
738 
741  typedef tmat3x3<f32, defaultp> fmat3x3;
742 
745  typedef tmat3x4<f32, defaultp> fmat3x4;
746 
749  typedef tmat4x2<f32, defaultp> fmat4x2;
750 
753  typedef tmat4x3<f32, defaultp> fmat4x3;
754 
757  typedef tmat4x4<f32, defaultp> fmat4x4;
758 
759 
762  //typedef detail::tmat1x1<f32, defaultp> f32mat1;
763 
766  typedef tmat2x2<f32, defaultp> f32mat2;
767 
770  typedef tmat3x3<f32, defaultp> f32mat3;
771 
774  typedef tmat4x4<f32, defaultp> f32mat4;
775 
776 
779  //typedef f32 f32mat1x1;
780 
783  typedef tmat2x2<f32, defaultp> f32mat2x2;
784 
787  typedef tmat2x3<f32, defaultp> f32mat2x3;
788 
791  typedef tmat2x4<f32, defaultp> f32mat2x4;
792 
795  typedef tmat3x2<f32, defaultp> f32mat3x2;
796 
799  typedef tmat3x3<f32, defaultp> f32mat3x3;
800 
803  typedef tmat3x4<f32, defaultp> f32mat3x4;
804 
807  typedef tmat4x2<f32, defaultp> f32mat4x2;
808 
811  typedef tmat4x3<f32, defaultp> f32mat4x3;
812 
815  typedef tmat4x4<f32, defaultp> f32mat4x4;
816 
817 
820  //typedef detail::tmat1x1<f64, defaultp> f64mat1;
821 
824  typedef tmat2x2<f64, defaultp> f64mat2;
825 
828  typedef tmat3x3<f64, defaultp> f64mat3;
829 
832  typedef tmat4x4<f64, defaultp> f64mat4;
833 
834 
837  //typedef f64 f64mat1x1;
838 
841  typedef tmat2x2<f64, defaultp> f64mat2x2;
842 
845  typedef tmat2x3<f64, defaultp> f64mat2x3;
846 
849  typedef tmat2x4<f64, defaultp> f64mat2x4;
850 
853  typedef tmat3x2<f64, defaultp> f64mat3x2;
854 
857  typedef tmat3x3<f64, defaultp> f64mat3x3;
858 
861  typedef tmat3x4<f64, defaultp> f64mat3x4;
862 
865  typedef tmat4x2<f64, defaultp> f64mat4x2;
866 
869  typedef tmat4x3<f64, defaultp> f64mat4x3;
870 
873  typedef tmat4x4<f64, defaultp> f64mat4x4;
874 
875 
877  // Quaternion types
878 
881  typedef tquat<f32, defaultp> f32quat;
882 
885  typedef tquat<f64, defaultp> f64quat;
886 
888 }//namespace glm
889 
890 #include "type_precision.inl"
glm::int8_t
detail::int8 int8_t
8 bit signed integer type.
Definition: fwd.hpp:297
glm::lowp_uint32
detail::uint32 lowp_uint32
Low precision 32 bit unsigned integer type.
Definition: fwd.hpp:740
glm::lowp_int64_t
detail::int64 lowp_int64_t
Low precision 64 bit signed integer type.
Definition: fwd.hpp:157
glm::lowp_int16
detail::int16 lowp_int16
Low precision 16 bit signed integer type.
Definition: fwd.hpp:133
glm::u16vec1
highp_u16vec1 u16vec1
Default precision 16 bit unsigned integer scalar type.
Definition: fwd.hpp:1082
glm::u32
detail::uint32 u32
32 bit unsigned integer type.
Definition: fwd.hpp:931
glm::lowp_uint16
detail::uint16 lowp_uint16
Low precision 16 bit unsigned integer type.
Definition: fwd.hpp:736
glm::fvec3
highp_f32vec3 fvec3
Default single-precision floating-point vector of 3 components.
Definition: fwd.hpp:2364
glm::fmat3x3
highp_f32mat3x3 fmat3x3
Default single-precision floating-point 3x3 matrix.
Definition: fwd.hpp:2388
glm::i64vec4
highp_i64vec4 i64vec4
Default precision 64 bit signed integer vector of 4 components type.
Definition: fwd.hpp:723
glm::f32mat3
f32mat3x3 f32mat3
Default single-precision floating-point 3x3 matrix.
Definition: fwd.hpp:2482
glm::mediump_u8
detail::uint8 mediump_u8
Medium precision 8 bit unsigned integer type.
Definition: fwd.hpp:816
glm::highp_i64
detail::int64 highp_i64
High precision 64 bit signed integer type.
Definition: fwd.hpp:269
glm::u32vec2
highp_u32vec2 u32vec2
Default precision 32 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:1165
glm::u8vec4
highp_u8vec4 u8vec4
Default precision 8 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:1014
glm::highp_int64_t
detail::int64 highp_int64_t
High precision 64 bit signed integer type.
Definition: fwd.hpp:253
glm::i64vec2
highp_i64vec2 i64vec2
Default precision 64 bit signed integer vector of 2 components type.
Definition: fwd.hpp:715
glm::int32_t
detail::int32 int32_t
32 bit signed integer type.
Definition: fwd.hpp:305
glm::i16vec4
highp_i16vec4 i16vec4
Default precision 16 bit signed integer vector of 4 components type.
Definition: fwd.hpp:485
glm::mediump_i32
detail::int32 mediump_i32
Medium precision 32 bit signed integer type.
Definition: fwd.hpp:217
glm::lowp_int8
detail::int8 lowp_int8
Low precision 8 bit signed integer type.
Definition: fwd.hpp:129
glm::u64
detail::uint64 u64
64 bit unsigned integer type.
Definition: fwd.hpp:935
glm::lowp_u8
detail::uint8 lowp_u8
Low precision 8 bit unsigned integer type.
Definition: fwd.hpp:766
glm::i8
detail::int8 i8
8 bit signed integer type.
Definition: fwd.hpp:314
glm::mediump_uint8
detail::uint8 mediump_uint8
Medium precision 8 bit unsigned integer type.
Definition: fwd.hpp:784
glm::f64mat4
f64mat4x4 f64mat4
Default double-precision floating-point 4x4 matrix.
Definition: fwd.hpp:2592
glm::lowp_uint32_t
detail::uint32 lowp_uint32_t
Low precision 32 bit unsigned integer type.
Definition: fwd.hpp:757
glm::mediump_i64
detail::int64 mediump_i64
Medium precision 64 bit signed integer type.
Definition: fwd.hpp:221
glm::i64vec3
highp_i64vec3 i64vec3
Default precision 64 bit signed integer vector of 3 components type.
Definition: fwd.hpp:719
glm::highp_i32
detail::int32 highp_i32
High precision 32 bit signed integer type.
Definition: fwd.hpp:265
glm::lowp_u32
detail::uint32 lowp_u32
Low precision 32 bit unsigned integer type.
Definition: fwd.hpp:774
glm::highp_i16
detail::int16 highp_i16
High precision 16 bit signed integer type.
Definition: fwd.hpp:261
glm::highp_i8
detail::int8 highp_i8
High precision 8 bit signed integer type.
Definition: fwd.hpp:257
glm::u32vec3
highp_u32vec3 u32vec3
Default precision 32 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:1169
glm::fmat4
fmat4x4 fmat4
Default single-precision floating-point 4x4 matrix.
Definition: fwd.hpp:2416
glm::mediump_u32
detail::uint32 mediump_u32
Medium precision 32 bit unsigned integer type.
Definition: fwd.hpp:824
glm::fvec2
highp_f32vec2 fvec2
Default single-precision floating-point vector of 2 components.
Definition: fwd.hpp:2360
glm::mediump_int8
detail::int8 mediump_int8
Medium precision 8 bit signed integer type.
Definition: fwd.hpp:177
glm::highp_u32
detail::uint32 highp_u32
Medium precision 32 bit unsigned integer type.
Definition: fwd.hpp:874
glm::mediump_uint64_t
detail::uint64 mediump_uint64_t
Medium precision 64 bit unsigned integer type.
Definition: fwd.hpp:812
glm::i32vec1
highp_i32vec1 i32vec1
Default precision 32 bit signed integer scalar type.
Definition: fwd.hpp:552
glm::highp_u8
detail::uint8 highp_u8
Medium precision 8 bit unsigned integer type.
Definition: fwd.hpp:866
glm::u16vec3
highp_u16vec3 u16vec3
Default precision 16 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:1090
glm::i16vec2
highp_i16vec2 i16vec2
Default precision 16 bit signed integer vector of 2 components type.
Definition: fwd.hpp:477
glm::f32mat2
f32mat2x2 f32mat2
Default single-precision floating-point 2x2 matrix.
Definition: fwd.hpp:2478
glm::i32vec4
highp_i32vec4 i32vec4
Default precision 32 bit signed integer vector of 4 components type.
Definition: fwd.hpp:564
glm::lowp_int64
detail::int64 lowp_int64
Low precision 64 bit signed integer type.
Definition: fwd.hpp:141
glm::f32mat2x4
highp_f32mat2x4 f32mat2x4
Default single-precision floating-point 2x4 matrix.
Definition: fwd.hpp:2450
glm::f32mat3x2
highp_f32mat3x2 f32mat3x2
Default single-precision floating-point 3x2 matrix.
Definition: fwd.hpp:2454
glm::f64vec4
highp_f64vec4 f64vec4
Default double-precision floating-point vector of 4 components.
Definition: fwd.hpp:2544
glm::f64mat2
f64mat2x2 f64mat2
Default double-precision floating-point 2x2 matrix.
Definition: fwd.hpp:2584
glm::lowp_i32
detail::int32 lowp_i32
Low precision 32 bit signed integer type.
Definition: fwd.hpp:169
glm::mediump_uint64
detail::uint64 mediump_uint64
Medium precision 64 bit unsigned integer type.
Definition: fwd.hpp:796
glm::f32vec2
highp_f32vec2 f32vec2
Default single-precision floating-point vector of 2 components.
Definition: fwd.hpp:2430
glm::u16
detail::uint16 u16
16 bit unsigned integer type.
Definition: fwd.hpp:927
glm::f64
highp_float64_t f64
Default 64 bit double-precision floating-point scalar.
Definition: fwd.hpp:1538
glm::f64mat3
f64mat3x3 f64mat3
Default double-precision floating-point 3x3 matrix.
Definition: fwd.hpp:2588
glm::f64vec1
highp_f64vec1 f64vec1
Default double-precision floating-point vector of 1 components.
Definition: fwd.hpp:2532
glm::fvec4
highp_f32vec4 fvec4
Default single-precision floating-point vector of 4 components.
Definition: fwd.hpp:2368
glm::mediump_i8
detail::int8 mediump_i8
Medium precision 8 bit signed integer type.
Definition: fwd.hpp:209
glm::f32mat4x4
highp_f32mat4x4 f32mat4x4
Default single-precision floating-point 4x4 matrix.
Definition: fwd.hpp:2474
glm::f64mat2x2
highp_f64mat2x2 f64mat2x2
Default double-precision floating-point 2x2 matrix.
Definition: fwd.hpp:2548
glm::float64_t
highp_float64_t float64_t
Default 64 bit double-precision floating-point scalar.
Definition: fwd.hpp:1530
glm::u8vec1
highp_u8vec1 u8vec1
Default precision 8 bit unsigned integer scalar type.
Definition: fwd.hpp:1002
glm::fmat4x2
highp_f32mat4x2 fmat4x2
Default single-precision floating-point 4x2 matrix.
Definition: fwd.hpp:2396
glm::u8vec2
highp_u8vec2 u8vec2
Default precision 8 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:1006
glm::u64vec1
highp_u64vec1 u64vec1
Default precision 64 bit unsigned integer scalar type.
Definition: fwd.hpp:1320
glm::highp_uint8
detail::uint8 highp_uint8
Medium precision 8 bit unsigned integer type.
Definition: fwd.hpp:834
glm::mediump_u16
detail::uint16 mediump_u16
Medium precision 16 bit unsigned integer type.
Definition: fwd.hpp:820
glm::f64mat3x3
highp_f64mat3x3 f64mat3x3
Default double-precision floating-point 3x3 matrix.
Definition: fwd.hpp:2564
glm::mediump_uint32
detail::uint32 mediump_uint32
Medium precision 32 bit unsigned integer type.
Definition: fwd.hpp:792
glm::f32mat4x2
highp_f32mat4x2 f32mat4x2
Default single-precision floating-point 4x2 matrix.
Definition: fwd.hpp:2466
glm::highp_int16
detail::int16 highp_int16
High precision 16 bit signed integer type.
Definition: fwd.hpp:229
glm::highp_int32
detail::int32 highp_int32
High precision 32 bit signed integer type.
Definition: fwd.hpp:233
glm::mediump_int8_t
detail::int8 mediump_int8_t
Medium precision 8 bit signed integer type.
Definition: fwd.hpp:193
glm::f32quat
highp_f32quat f32quat
Default single-precision floating-point quaternion.
Definition: fwd.hpp:2490
glm::i8vec4
highp_i8vec4 i8vec4
Default precision 8 bit signed integer vector of 4 components type.
Definition: fwd.hpp:405
glm::highp_int8
detail::int8 highp_int8
High precision 8 bit signed integer type.
Definition: fwd.hpp:225
glm::f64mat2x4
highp_f64mat2x4 f64mat2x4
Default double-precision floating-point 2x4 matrix.
Definition: fwd.hpp:2556
glm::u16vec4
highp_u16vec4 u16vec4
Default precision 16 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:1094
glm::u64vec2
highp_u64vec2 u64vec2
Default precision 64 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:1324
glm::highp_uint64_t
detail::uint64 highp_uint64_t
Medium precision 64 bit unsigned integer type.
Definition: fwd.hpp:862
glm::f32
highp_float32_t f32
Default 32 bit single-precision floating-point scalar.
Definition: fwd.hpp:1534
glm::lowp_i8
detail::int8 lowp_i8
Low precision 8 bit signed integer type.
Definition: fwd.hpp:161
glm::f32vec1
highp_f32vec1 f32vec1
Default single-precision floating-point vector of 1 components.
Definition: fwd.hpp:2426
glm::uint32_t
detail::uint32 uint32_t
32 bit unsigned integer type.
Definition: fwd.hpp:914
glm::u8
detail::uint8 u8
8 bit unsigned integer type.
Definition: fwd.hpp:923
glm::lowp_u16
detail::uint16 lowp_u16
Low precision 16 bit unsigned integer type.
Definition: fwd.hpp:770
glm::fmat2x4
highp_f32mat2x4 fmat2x4
Default single-precision floating-point 2x4 matrix.
Definition: fwd.hpp:2380
glm::fvec1
highp_f32vec1 fvec1
Default single-precision floating-point vector of 1 components.
Definition: fwd.hpp:2356
glm::lowp_i16
detail::int16 lowp_i16
Low precision 16 bit signed integer type.
Definition: fwd.hpp:165
glm::lowp_uint8_t
detail::uint8 lowp_uint8_t
Low precision 8 bit unsigned integer type.
Definition: fwd.hpp:749
glm::i32vec2
highp_i32vec2 i32vec2
Default precision 32 bit signed integer vector of 2 components type.
Definition: fwd.hpp:556
glm
Definition: _noise.hpp:40
glm::mediump_uint16
detail::uint16 mediump_uint16
Medium precision 16 bit unsigned integer type.
Definition: fwd.hpp:788
glm::f64quat
highp_f64quat f64quat
Default double-precision floating-point quaternion.
Definition: fwd.hpp:2596
glm::highp_int8_t
detail::int8 highp_int8_t
High precision 8 bit signed integer type.
Definition: fwd.hpp:241
glm::highp_uint8_t
detail::uint8 highp_uint8_t
Medium precision 8 bit unsigned integer type.
Definition: fwd.hpp:850
glm::i8vec1
highp_i8vec1 i8vec1
Default precision 8 bit signed integer scalar type.
Definition: fwd.hpp:393
glm::i16vec1
highp_i16vec1 i16vec1
Default precision 16 bit signed integer scalar type.
Definition: fwd.hpp:473
glm::mediump_int64_t
detail::int64 mediump_int64_t
Medium precision 64 bit signed integer type.
Definition: fwd.hpp:205
glm::fmat2x2
highp_f32mat2x2 fmat2x2
Default single-precision floating-point 2x2 matrix.
Definition: fwd.hpp:2372
glm::lowp_int8_t
detail::int8 lowp_int8_t
Low precision 8 bit signed integer type.
Definition: fwd.hpp:145
glm::highp_uint16
detail::uint16 highp_uint16
Medium precision 16 bit unsigned integer type.
Definition: fwd.hpp:838
glm::lowp_uint64
detail::uint64 lowp_uint64
Low precision 64 bit unsigned integer type.
Definition: fwd.hpp:744
glm::fmat2x3
highp_f32mat2x3 fmat2x3
Default single-precision floating-point 2x3 matrix.
Definition: fwd.hpp:2376
glm::float32_t
highp_float32_t float32_t
Default 32 bit single-precision floating-point scalar.
Definition: fwd.hpp:1526
glm::i8vec3
highp_i8vec3 i8vec3
Default precision 8 bit signed integer vector of 3 components type.
Definition: fwd.hpp:401
glm::fmat3x2
highp_f32mat3x2 fmat3x2
Default single-precision floating-point 3x2 matrix.
Definition: fwd.hpp:2384
glm::mediump_i16
detail::int16 mediump_i16
Medium precision 16 bit signed integer type.
Definition: fwd.hpp:213
glm::mediump_uint16_t
detail::uint16 mediump_uint16_t
Medium precision 16 bit unsigned integer type.
Definition: fwd.hpp:804
glm::u32vec4
highp_u32vec4 u32vec4
Default precision 32 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:1173
glm::f64mat3x4
highp_f64mat3x4 f64mat3x4
Default double-precision floating-point 3x4 matrix.
Definition: fwd.hpp:2568
glm::lowp_uint16_t
detail::uint16 lowp_uint16_t
Low precision 16 bit unsigned integer type.
Definition: fwd.hpp:753
glm::mediump_int16
detail::int16 mediump_int16
Medium precision 16 bit signed integer type.
Definition: fwd.hpp:181
glm::fmat3x4
highp_f32mat3x4 fmat3x4
Default single-precision floating-point 3x4 matrix.
Definition: fwd.hpp:2392
glm::fmat4x3
highp_f32mat4x3 fmat4x3
Default single-precision floating-point 4x3 matrix.
Definition: fwd.hpp:2400
glm::u8vec3
highp_u8vec3 u8vec3
Default precision 8 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:1010
glm::f64vec3
highp_f64vec3 f64vec3
Default double-precision floating-point vector of 3 components.
Definition: fwd.hpp:2540
glm::u64vec4
highp_u64vec4 u64vec4
Default precision 64 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:1332
glm::mediump_int16_t
detail::int16 mediump_int16_t
Medium precision 16 bit signed integer type.
Definition: fwd.hpp:197
glm::lowp_int16_t
detail::int16 lowp_int16_t
Low precision 16 bit signed integer type.
Definition: fwd.hpp:149
glm::f64mat4x3
highp_f64mat4x3 f64mat4x3
Default double-precision floating-point 4x3 matrix.
Definition: fwd.hpp:2576
glm::mediump_uint32_t
detail::uint32 mediump_uint32_t
Medium precision 32 bit unsigned integer type.
Definition: fwd.hpp:808
glm::mediump_int32_t
detail::int32 mediump_int32_t
Medium precision 32 bit signed integer type.
Definition: fwd.hpp:201
glm::uint8_t
detail::uint8 uint8_t
8 bit unsigned integer type.
Definition: fwd.hpp:906
glm::f64mat3x2
highp_f64mat3x2 f64mat3x2
Default double-precision floating-point 3x2 matrix.
Definition: fwd.hpp:2560
glm::f32mat2x2
highp_f32mat2x2 f32mat2x2
Default single-precision floating-point 2x2 matrix.
Definition: fwd.hpp:2442
glm::f32mat3x3
highp_f32mat3x3 f32mat3x3
Default single-precision floating-point 3x3 matrix.
Definition: fwd.hpp:2458
glm::highp_uint16_t
detail::uint16 highp_uint16_t
Medium precision 16 bit unsigned integer type.
Definition: fwd.hpp:854
glm::i8vec2
highp_i8vec2 i8vec2
Default precision 8 bit signed integer vector of 2 components type.
Definition: fwd.hpp:397
glm::highp_int16_t
detail::int16 highp_int16_t
High precision 16 bit signed integer type.
Definition: fwd.hpp:245
glm::lowp_int32
detail::int32 lowp_int32
Low precision 32 bit signed integer type.
Definition: fwd.hpp:137
glm::highp_u64
detail::uint64 highp_u64
Medium precision 64 bit unsigned integer type.
Definition: fwd.hpp:878
glm::f64mat4x2
highp_f64mat4x2 f64mat4x2
Default double-precision floating-point 4x2 matrix.
Definition: fwd.hpp:2572
glm::mediump_int32
detail::int32 mediump_int32
Medium precision 32 bit signed integer type.
Definition: fwd.hpp:185
glm::int64_t
detail::int64 int64_t
64 bit signed integer type.
Definition: fwd.hpp:309
glm::f32mat4
f32mat4x4 f32mat4
Default single-precision floating-point 4x4 matrix.
Definition: fwd.hpp:2486
glm::lowp_u64
detail::uint64 lowp_u64
Low precision 64 bit unsigned integer type.
Definition: fwd.hpp:778
glm::mediump_u64
detail::uint64 mediump_u64
Medium precision 64 bit unsigned integer type.
Definition: fwd.hpp:828
glm::lowp_uint64_t
detail::uint64 lowp_uint64_t
Low precision 64 bit unsigned integer type.
Definition: fwd.hpp:761
glm::highp_uint32_t
detail::uint32 highp_uint32_t
Medium precision 32 bit unsigned integer type.
Definition: fwd.hpp:858
glm::i16vec3
highp_i16vec3 i16vec3
Default precision 16 bit signed integer vector of 3 components type.
Definition: fwd.hpp:481
glm::fmat4x4
highp_f32mat4x4 fmat4x4
Default single-precision floating-point 4x4 matrix.
Definition: fwd.hpp:2404
glm::highp_int32_t
detail::int32 highp_int32_t
32 bit signed integer type.
Definition: fwd.hpp:249
glm::uint16_t
detail::uint16 uint16_t
16 bit unsigned integer type.
Definition: fwd.hpp:910
glm::f32vec3
highp_f32vec3 f32vec3
Default single-precision floating-point vector of 3 components.
Definition: fwd.hpp:2434
glm::f64mat4x4
highp_f64mat4x4 f64mat4x4
Default double-precision floating-point 4x4 matrix.
Definition: fwd.hpp:2580
glm::f64mat2x3
highp_f64mat2x3 f64mat2x3
Default double-precision floating-point 2x3 matrix.
Definition: fwd.hpp:2552
glm::highp_uint32
detail::uint32 highp_uint32
Medium precision 32 bit unsigned integer type.
Definition: fwd.hpp:842
glm::highp_u16
detail::uint16 highp_u16
Medium precision 16 bit unsigned integer type.
Definition: fwd.hpp:870
glm::f32mat2x3
highp_f32mat2x3 f32mat2x3
Default single-precision floating-point 2x3 matrix.
Definition: fwd.hpp:2446
glm::fmat2
fmat2x2 fmat2
Default single-precision floating-point 2x2 matrix.
Definition: fwd.hpp:2408
glm::mediump_uint8_t
detail::uint8 mediump_uint8_t
Medium precision 8 bit unsigned integer type.
Definition: fwd.hpp:800
glm::i32
detail::int32 i32
32 bit signed integer type.
Definition: fwd.hpp:322
glm::f32vec4
highp_f32vec4 f32vec4
Default single-precision floating-point vector of 4 components.
Definition: fwd.hpp:2438
glm::i32vec3
highp_i32vec3 i32vec3
Default precision 32 bit signed integer vector of 3 components type.
Definition: fwd.hpp:560
glm::u16vec2
highp_u16vec2 u16vec2
Default precision 16 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:1086
glm::lowp_uint8
detail::uint8 lowp_uint8
Low precision 8 bit unsigned integer type.
Definition: fwd.hpp:732
glm::i64vec1
highp_i64vec1 i64vec1
Default precision 64 bit signed integer scalar type.
Definition: fwd.hpp:711
glm::i16
detail::int16 i16
16 bit signed integer type.
Definition: fwd.hpp:318
glm::f32mat3x4
highp_f32mat3x4 f32mat3x4
Default single-precision floating-point 3x4 matrix.
Definition: fwd.hpp:2462
glm::uint64_t
detail::uint64 uint64_t
64 bit unsigned integer type.
Definition: fwd.hpp:918
glm::highp_int64
detail::int64 highp_int64
High precision 64 bit signed integer type.
Definition: fwd.hpp:237
glm::u32vec1
highp_u32vec1 u32vec1
Default precision 32 bit unsigned integer scalar type.
Definition: fwd.hpp:1161
glm::int16_t
detail::int16 int16_t
16 bit signed integer type.
Definition: fwd.hpp:301
glm::f32mat4x3
highp_f32mat4x3 f32mat4x3
Default single-precision floating-point 4x3 matrix.
Definition: fwd.hpp:2470
glm::fmat3
fmat3x3 fmat3
Default single-precision floating-point 3x3 matrix.
Definition: fwd.hpp:2412
glm::mediump_int64
detail::int64 mediump_int64
Medium precision 64 bit signed integer type.
Definition: fwd.hpp:189
glm::lowp_int32_t
detail::int32 lowp_int32_t
Low precision 32 bit signed integer type.
Definition: fwd.hpp:153
glm::f64vec2
highp_f64vec2 f64vec2
Default double-precision floating-point vector of 2 components.
Definition: fwd.hpp:2536
glm::highp_uint64
detail::uint64 highp_uint64
Medium precision 64 bit unsigned integer type.
Definition: fwd.hpp:846
glm::i64
detail::int64 i64
64 bit signed integer type.
Definition: fwd.hpp:326
glm::u64vec3
highp_u64vec3 u64vec3
Default precision 64 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:1328
glm::lowp_i64
detail::int64 lowp_i64
Low precision 64 bit signed integer type.
Definition: fwd.hpp:173
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00131.html000066400000000000000000000344361356361734700216510ustar00rootroot00000000000000 0.9.7: type_ptr.hpp File Reference
Functions
type_ptr.hpp File Reference

Go to the source code of this file.

Functions

template<typename T >
GLM_FUNC_DECL tmat2x2< T, defaultp > make_mat2 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tmat2x2< T, defaultp > make_mat2x2 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tmat2x3< T, defaultp > make_mat2x3 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tmat2x4< T, defaultp > make_mat2x4 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tmat3x3< T, defaultp > make_mat3 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tmat3x2< T, defaultp > make_mat3x2 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tmat3x3< T, defaultp > make_mat3x3 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tmat3x4< T, defaultp > make_mat3x4 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > make_mat4 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tmat4x2< T, defaultp > make_mat4x2 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tmat4x3< T, defaultp > make_mat4x3 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > make_mat4x4 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tquat< T, defaultp > make_quat (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tvec2< T, defaultp > make_vec2 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tvec3< T, defaultp > make_vec3 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tvec4< T, defaultp > make_vec4 (T const *const ptr)
 
template<typename genType >
GLM_FUNC_DECL genType::value_type const * value_ptr (genType const &vec)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTC_type_ptr

Date
2009-05-06 / 2011-06-05
Author
Christophe Riccio
See also
GLM Core (dependence)
gtc_half_float (dependence)
GLM_GTC_quaternion (dependence)

Definition in file type_ptr.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00131_source.html000066400000000000000000000531031356361734700232210ustar00rootroot00000000000000 0.9.7: type_ptr.hpp Source File
type_ptr.hpp
Go to the documentation of this file.
1 
63 #pragma once
64 
65 // Dependency:
66 #include "../gtc/quaternion.hpp"
67 #include "../vec2.hpp"
68 #include "../vec3.hpp"
69 #include "../vec4.hpp"
70 #include "../mat2x2.hpp"
71 #include "../mat2x3.hpp"
72 #include "../mat2x4.hpp"
73 #include "../mat3x2.hpp"
74 #include "../mat3x3.hpp"
75 #include "../mat3x4.hpp"
76 #include "../mat4x2.hpp"
77 #include "../mat4x3.hpp"
78 #include "../mat4x4.hpp"
79 #include <cstring>
80 
81 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
82 # pragma message("GLM: GLM_GTC_type_ptr extension included")
83 #endif
84 
85 namespace glm
86 {
89 
92  template<typename genType>
93  GLM_FUNC_DECL typename genType::value_type const * value_ptr(genType const & vec);
94 
97  template<typename T>
98  GLM_FUNC_DECL tvec2<T, defaultp> make_vec2(T const * const ptr);
99 
102  template<typename T>
103  GLM_FUNC_DECL tvec3<T, defaultp> make_vec3(T const * const ptr);
104 
107  template<typename T>
108  GLM_FUNC_DECL tvec4<T, defaultp> make_vec4(T const * const ptr);
109 
112  template<typename T>
113  GLM_FUNC_DECL tmat2x2<T, defaultp> make_mat2x2(T const * const ptr);
114 
117  template<typename T>
118  GLM_FUNC_DECL tmat2x3<T, defaultp> make_mat2x3(T const * const ptr);
119 
122  template<typename T>
123  GLM_FUNC_DECL tmat2x4<T, defaultp> make_mat2x4(T const * const ptr);
124 
127  template<typename T>
128  GLM_FUNC_DECL tmat3x2<T, defaultp> make_mat3x2(T const * const ptr);
129 
132  template<typename T>
133  GLM_FUNC_DECL tmat3x3<T, defaultp> make_mat3x3(T const * const ptr);
134 
137  template<typename T>
138  GLM_FUNC_DECL tmat3x4<T, defaultp> make_mat3x4(T const * const ptr);
139 
142  template<typename T>
143  GLM_FUNC_DECL tmat4x2<T, defaultp> make_mat4x2(T const * const ptr);
144 
147  template<typename T>
148  GLM_FUNC_DECL tmat4x3<T, defaultp> make_mat4x3(T const * const ptr);
149 
152  template<typename T>
153  GLM_FUNC_DECL tmat4x4<T, defaultp> make_mat4x4(T const * const ptr);
154 
157  template<typename T>
158  GLM_FUNC_DECL tmat2x2<T, defaultp> make_mat2(T const * const ptr);
159 
162  template<typename T>
163  GLM_FUNC_DECL tmat3x3<T, defaultp> make_mat3(T const * const ptr);
164 
167  template<typename T>
168  GLM_FUNC_DECL tmat4x4<T, defaultp> make_mat4(T const * const ptr);
169 
172  template<typename T>
173  GLM_FUNC_DECL tquat<T, defaultp> make_quat(T const * const ptr);
174 
176 }//namespace glm
177 
178 #include "type_ptr.inl"
glm::make_mat2x4
GLM_FUNC_DECL tmat2x4< T, defaultp > make_mat2x4(T const *const ptr)
Build a matrix from a pointer.
glm::make_mat2x2
GLM_FUNC_DECL tmat2x2< T, defaultp > make_mat2x2(T const *const ptr)
Build a matrix from a pointer.
glm::make_quat
GLM_FUNC_DECL tquat< T, defaultp > make_quat(T const *const ptr)
Build a quaternion from a pointer.
glm::make_mat4x3
GLM_FUNC_DECL tmat4x3< T, defaultp > make_mat4x3(T const *const ptr)
Build a matrix from a pointer.
glm::make_mat3x3
GLM_FUNC_DECL tmat3x3< T, defaultp > make_mat3x3(T const *const ptr)
Build a matrix from a pointer.
glm::make_vec2
GLM_FUNC_DECL tvec2< T, defaultp > make_vec2(T const *const ptr)
Build a vector from a pointer.
glm::make_mat3x4
GLM_FUNC_DECL tmat3x4< T, defaultp > make_mat3x4(T const *const ptr)
Build a matrix from a pointer.
glm::make_mat2x3
GLM_FUNC_DECL tmat2x3< T, defaultp > make_mat2x3(T const *const ptr)
Build a matrix from a pointer.
glm::make_mat4x2
GLM_FUNC_DECL tmat4x2< T, defaultp > make_mat4x2(T const *const ptr)
Build a matrix from a pointer.
glm::make_vec3
GLM_FUNC_DECL tvec3< T, defaultp > make_vec3(T const *const ptr)
Build a vector from a pointer.
glm
Definition: _noise.hpp:40
glm::make_mat2
GLM_FUNC_DECL tmat2x2< T, defaultp > make_mat2(T const *const ptr)
Build a matrix from a pointer.
glm::make_vec4
GLM_FUNC_DECL tvec4< T, defaultp > make_vec4(T const *const ptr)
Build a vector from a pointer.
glm::make_mat4
GLM_FUNC_DECL tmat4x4< T, defaultp > make_mat4(T const *const ptr)
Build a matrix from a pointer.
glm::make_mat4x4
GLM_FUNC_DECL tmat4x4< T, defaultp > make_mat4x4(T const *const ptr)
Build a matrix from a pointer.
glm::make_mat3x2
GLM_FUNC_DECL tmat3x2< T, defaultp > make_mat3x2(T const *const ptr)
Build a matrix from a pointer.
glm::make_mat3
GLM_FUNC_DECL tmat3x3< T, defaultp > make_mat3(T const *const ptr)
Build a matrix from a pointer.
glm::value_ptr
GLM_FUNC_DECL genType::value_type const * value_ptr(genType const &vec)
Return the constant address to the data of the input parameter.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00132.html000066400000000000000000000666601356361734700216560ustar00rootroot00000000000000 0.9.7: type_vec.hpp File Reference
Typedefs
type_vec.hpp File Reference

Go to the source code of this file.

Typedefs

typedef highp_bvec2 bvec2
 
typedef highp_bvec3 bvec3
 
typedef highp_bvec4 bvec4
 
typedef highp_dvec2 dvec2
 
typedef highp_dvec3 dvec3
 
typedef highp_dvec4 dvec4
 
typedef tvec2< bool, highp > highp_bvec2
 
typedef tvec3< bool, highp > highp_bvec3
 
typedef tvec4< bool, highp > highp_bvec4
 
typedef tvec2< double, highp > highp_dvec2
 
typedef tvec3< double, highp > highp_dvec3
 
typedef tvec4< double, highp > highp_dvec4
 
typedef tvec2< int, highp > highp_ivec2
 
typedef tvec3< int, highp > highp_ivec3
 
typedef tvec4< int, highp > highp_ivec4
 
typedef tvec2< uint, highp > highp_uvec2
 
typedef tvec3< uint, highp > highp_uvec3
 
typedef tvec4< uint, highp > highp_uvec4
 
typedef tvec2< float, highp > highp_vec2
 
typedef tvec3< float, highp > highp_vec3
 
typedef tvec4< float, highp > highp_vec4
 
typedef highp_ivec2 ivec2
 
typedef highp_ivec3 ivec3
 
typedef highp_ivec4 ivec4
 
typedef tvec2< bool, lowp > lowp_bvec2
 
typedef tvec3< bool, lowp > lowp_bvec3
 
typedef tvec4< bool, lowp > lowp_bvec4
 
typedef tvec2< double, lowp > lowp_dvec2
 
typedef tvec3< double, lowp > lowp_dvec3
 
typedef tvec4< double, lowp > lowp_dvec4
 
typedef tvec2< int, lowp > lowp_ivec2
 
typedef tvec3< int, lowp > lowp_ivec3
 
typedef tvec4< int, lowp > lowp_ivec4
 
typedef tvec2< uint, lowp > lowp_uvec2
 
typedef tvec3< uint, lowp > lowp_uvec3
 
typedef tvec4< uint, lowp > lowp_uvec4
 
typedef tvec2< float, lowp > lowp_vec2
 
typedef tvec3< float, lowp > lowp_vec3
 
typedef tvec4< float, lowp > lowp_vec4
 
typedef tvec2< bool, mediump > mediump_bvec2
 
typedef tvec3< bool, mediump > mediump_bvec3
 
typedef tvec4< bool, mediump > mediump_bvec4
 
typedef tvec2< double, mediump > mediump_dvec2
 
typedef tvec3< double, mediump > mediump_dvec3
 
typedef tvec4< double, mediump > mediump_dvec4
 
typedef tvec2< int, mediump > mediump_ivec2
 
typedef tvec3< int, mediump > mediump_ivec3
 
typedef tvec4< int, mediump > mediump_ivec4
 
typedef tvec2< uint, mediump > mediump_uvec2
 
typedef tvec3< uint, mediump > mediump_uvec3
 
typedef tvec4< uint, mediump > mediump_uvec4
 
typedef tvec2< float, mediump > mediump_vec2
 
typedef tvec3< float, mediump > mediump_vec3
 
typedef tvec4< float, mediump > mediump_vec4
 
typedef highp_uvec2 uvec2
 
typedef highp_uvec3 uvec3
 
typedef highp_uvec4 uvec4
 
typedef highp_vec2 vec2
 
typedef highp_vec3 vec3
 
typedef highp_vec4 vec4
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2010-01-26 / 2014-10-05
Author
Christophe Riccio

Definition in file type_vec.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00132_source.html000066400000000000000000002076711356361734700232350ustar00rootroot00000000000000 0.9.7: type_vec.hpp Source File
type_vec.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "precision.hpp"
36 #include "type_int.hpp"
37 
38 namespace glm
39 {
40  template <typename T, precision P> struct tvec1;
41  template <typename T, precision P> struct tvec2;
42  template <typename T, precision P> struct tvec3;
43  template <typename T, precision P> struct tvec4;
44 
45  typedef tvec1<float, highp> highp_vec1_t;
46  typedef tvec1<float, mediump> mediump_vec1_t;
47  typedef tvec1<float, lowp> lowp_vec1_t;
48  typedef tvec1<double, highp> highp_dvec1_t;
49  typedef tvec1<double, mediump> mediump_dvec1_t;
50  typedef tvec1<double, lowp> lowp_dvec1_t;
51  typedef tvec1<int, highp> highp_ivec1_t;
52  typedef tvec1<int, mediump> mediump_ivec1_t;
53  typedef tvec1<int, lowp> lowp_ivec1_t;
54  typedef tvec1<uint, highp> highp_uvec1_t;
55  typedef tvec1<uint, mediump> mediump_uvec1_t;
56  typedef tvec1<uint, lowp> lowp_uvec1_t;
57  typedef tvec1<bool, highp> highp_bvec1_t;
58  typedef tvec1<bool, mediump> mediump_bvec1_t;
59  typedef tvec1<bool, lowp> lowp_bvec1_t;
60 
63 
69  typedef tvec2<float, highp> highp_vec2;
70 
76  typedef tvec2<float, mediump> mediump_vec2;
77 
83  typedef tvec2<float, lowp> lowp_vec2;
84 
90  typedef tvec2<double, highp> highp_dvec2;
91 
97  typedef tvec2<double, mediump> mediump_dvec2;
98 
104  typedef tvec2<double, lowp> lowp_dvec2;
105 
111  typedef tvec2<int, highp> highp_ivec2;
112 
118  typedef tvec2<int, mediump> mediump_ivec2;
119 
125  typedef tvec2<int, lowp> lowp_ivec2;
126 
132  typedef tvec2<uint, highp> highp_uvec2;
133 
139  typedef tvec2<uint, mediump> mediump_uvec2;
140 
146  typedef tvec2<uint, lowp> lowp_uvec2;
147 
153  typedef tvec2<bool, highp> highp_bvec2;
154 
160  typedef tvec2<bool, mediump> mediump_bvec2;
161 
167  typedef tvec2<bool, lowp> lowp_bvec2;
168 
170 
173 
179  typedef tvec3<float, highp> highp_vec3;
180 
186  typedef tvec3<float, mediump> mediump_vec3;
187 
193  typedef tvec3<float, lowp> lowp_vec3;
194 
200  typedef tvec3<double, highp> highp_dvec3;
201 
207  typedef tvec3<double, mediump> mediump_dvec3;
208 
214  typedef tvec3<double, lowp> lowp_dvec3;
215 
221  typedef tvec3<int, highp> highp_ivec3;
222 
228  typedef tvec3<int, mediump> mediump_ivec3;
229 
235  typedef tvec3<int, lowp> lowp_ivec3;
236 
242  typedef tvec3<uint, highp> highp_uvec3;
243 
249  typedef tvec3<uint, mediump> mediump_uvec3;
250 
256  typedef tvec3<uint, lowp> lowp_uvec3;
257 
262  typedef tvec3<bool, highp> highp_bvec3;
263 
268  typedef tvec3<bool, mediump> mediump_bvec3;
269 
274  typedef tvec3<bool, lowp> lowp_bvec3;
275 
277 
280 
285  typedef tvec4<float, highp> highp_vec4;
286 
291  typedef tvec4<float, mediump> mediump_vec4;
292 
297  typedef tvec4<float, lowp> lowp_vec4;
298 
303  typedef tvec4<double, highp> highp_dvec4;
304 
309  typedef tvec4<double, mediump> mediump_dvec4;
310 
315  typedef tvec4<double, lowp> lowp_dvec4;
316 
321  typedef tvec4<int, highp> highp_ivec4;
322 
327  typedef tvec4<int, mediump> mediump_ivec4;
328 
333  typedef tvec4<int, lowp> lowp_ivec4;
334 
339  typedef tvec4<uint, highp> highp_uvec4;
340 
345  typedef tvec4<uint, mediump> mediump_uvec4;
346 
351  typedef tvec4<uint, lowp> lowp_uvec4;
352 
357  typedef tvec4<bool, highp> highp_bvec4;
358 
363  typedef tvec4<bool, mediump> mediump_bvec4;
364 
369  typedef tvec4<bool, lowp> lowp_bvec4;
370 
372 
375 
376  // -- Default float definition --
377 
378 #if(defined(GLM_PRECISION_LOWP_FLOAT))
379  typedef lowp_vec2 vec2;
380  typedef lowp_vec3 vec3;
381  typedef lowp_vec4 vec4;
382 #elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
383  typedef mediump_vec2 vec2;
384  typedef mediump_vec3 vec3;
385  typedef mediump_vec4 vec4;
386 #else //defined(GLM_PRECISION_HIGHP_FLOAT)
387  typedef highp_vec2 vec2;
391 
395  typedef highp_vec3 vec3;
396 
400  typedef highp_vec4 vec4;
401 #endif//GLM_PRECISION
402 
403  // -- Default double definition --
404 
405 #if(defined(GLM_PRECISION_LOWP_DOUBLE))
406  typedef lowp_dvec2 dvec2;
407  typedef lowp_dvec3 dvec3;
408  typedef lowp_dvec4 dvec4;
409 #elif(defined(GLM_PRECISION_MEDIUMP_DOUBLE))
410  typedef mediump_dvec2 dvec2;
411  typedef mediump_dvec3 dvec3;
412  typedef mediump_dvec4 dvec4;
413 #else //defined(GLM_PRECISION_HIGHP_DOUBLE)
414  typedef highp_dvec2 dvec2;
418 
422  typedef highp_dvec3 dvec3;
423 
427  typedef highp_dvec4 dvec4;
428 #endif//GLM_PRECISION
429 
430  // -- Signed integer definition --
431 
432 #if(defined(GLM_PRECISION_LOWP_INT))
433  typedef lowp_ivec2 ivec2;
434  typedef lowp_ivec3 ivec3;
435  typedef lowp_ivec4 ivec4;
436 #elif(defined(GLM_PRECISION_MEDIUMP_INT))
437  typedef mediump_ivec2 ivec2;
438  typedef mediump_ivec3 ivec3;
439  typedef mediump_ivec4 ivec4;
440 #else //defined(GLM_PRECISION_HIGHP_INT)
441  typedef highp_ivec2 ivec2;
445 
449  typedef highp_ivec3 ivec3;
450 
454  typedef highp_ivec4 ivec4;
455 #endif//GLM_PRECISION
456 
457  // -- Unsigned integer definition --
458 
459 #if(defined(GLM_PRECISION_LOWP_UINT))
460  typedef lowp_uvec2 uvec2;
461  typedef lowp_uvec3 uvec3;
462  typedef lowp_uvec4 uvec4;
463 #elif(defined(GLM_PRECISION_MEDIUMP_UINT))
464  typedef mediump_uvec2 uvec2;
465  typedef mediump_uvec3 uvec3;
466  typedef mediump_uvec4 uvec4;
467 #else //defined(GLM_PRECISION_HIGHP_UINT)
468  typedef highp_uvec2 uvec2;
472 
476  typedef highp_uvec3 uvec3;
477 
481  typedef highp_uvec4 uvec4;
482 #endif//GLM_PRECISION
483 
484  // -- Boolean definition --
485 
486 #if(defined(GLM_PRECISION_LOWP_BOOL))
487  typedef lowp_bvec2 bvec2;
488  typedef lowp_bvec3 bvec3;
489  typedef lowp_bvec4 bvec4;
490 #elif(defined(GLM_PRECISION_MEDIUMP_BOOL))
491  typedef mediump_bvec2 bvec2;
492  typedef mediump_bvec3 bvec3;
493  typedef mediump_bvec4 bvec4;
494 #else //defined(GLM_PRECISION_HIGHP_BOOL)
495  typedef highp_bvec2 bvec2;
499 
503  typedef highp_bvec3 bvec3;
504 
508  typedef highp_bvec4 bvec4;
509 #endif//GLM_PRECISION
510 
512 }//namespace glm
glm::highp_vec2
tvec2< float, highp > highp_vec2
2 components vector of high single-precision floating-point numbers.
Definition: type_vec.hpp:69
glm::ivec3
highp_ivec3 ivec3
3 components vector of signed integer numbers.
Definition: type_vec.hpp:449
glm::mediump_vec3
tvec3< float, mediump > mediump_vec3
3 components vector of medium single-precision floating-point numbers.
Definition: type_vec.hpp:186
glm::dvec2
highp_dvec2 dvec2
2 components vector of double-precision floating-point numbers.
Definition: type_vec.hpp:417
glm::lowp_ivec2
tvec2< int, lowp > lowp_ivec2
2 components vector of low precision signed integer numbers.
Definition: type_vec.hpp:125
glm::uvec3
highp_uvec3 uvec3
3 components vector of unsigned integer numbers.
Definition: type_vec.hpp:476
glm::highp_dvec3
tvec3< double, highp > highp_dvec3
3 components vector of high double-precision floating-point numbers.
Definition: type_vec.hpp:200
glm::mediump_vec2
tvec2< float, mediump > mediump_vec2
2 components vector of medium single-precision floating-point numbers.
Definition: type_vec.hpp:76
glm::mediump_dvec4
tvec4< double, mediump > mediump_dvec4
4 components vector of medium double-precision floating-point numbers.
Definition: type_vec.hpp:309
glm::highp_vec3
tvec3< float, highp > highp_vec3
3 components vector of high single-precision floating-point numbers.
Definition: type_vec.hpp:179
glm::uvec4
highp_uvec4 uvec4
4 components vector of unsigned integer numbers.
Definition: type_vec.hpp:481
glm::dvec4
highp_dvec4 dvec4
4 components vector of double-precision floating-point numbers.
Definition: type_vec.hpp:427
glm::highp_vec4
tvec4< float, highp > highp_vec4
4 components vector of high single-precision floating-point numbers.
Definition: type_vec.hpp:285
glm::mediump_vec4
tvec4< float, mediump > mediump_vec4
4 components vector of medium single-precision floating-point numbers.
Definition: type_vec.hpp:291
glm::highp_uvec4
tvec4< uint, highp > highp_uvec4
4 components vector of high precision unsigned integer numbers.
Definition: type_vec.hpp:339
glm::highp_bvec4
tvec4< bool, highp > highp_bvec4
4 components vector of high precision bool numbers.
Definition: type_vec.hpp:357
glm::highp_ivec3
tvec3< int, highp > highp_ivec3
3 components vector of high precision signed integer numbers.
Definition: type_vec.hpp:221
glm::vec2
highp_vec2 vec2
2 components vector of floating-point numbers.
Definition: type_vec.hpp:390
glm::lowp_bvec4
tvec4< bool, lowp > lowp_bvec4
4 components vector of low precision bool numbers.
Definition: type_vec.hpp:369
glm::mediump_uvec4
tvec4< uint, mediump > mediump_uvec4
4 components vector of medium precision unsigned integer numbers.
Definition: type_vec.hpp:345
glm::uvec2
highp_uvec2 uvec2
2 components vector of unsigned integer numbers.
Definition: type_vec.hpp:471
glm::lowp_dvec2
tvec2< double, lowp > lowp_dvec2
2 components vector of low double-precision floating-point numbers.
Definition: type_vec.hpp:104
glm::mediump_ivec3
tvec3< int, mediump > mediump_ivec3
3 components vector of medium precision signed integer numbers.
Definition: type_vec.hpp:228
glm::lowp_bvec2
tvec2< bool, lowp > lowp_bvec2
2 components vector of low precision bool numbers.
Definition: type_vec.hpp:167
glm::mediump_ivec4
tvec4< int, mediump > mediump_ivec4
4 components vector of medium precision signed integer numbers.
Definition: type_vec.hpp:327
glm::mediump_uvec2
tvec2< uint, mediump > mediump_uvec2
2 components vector of medium precision unsigned integer numbers.
Definition: type_vec.hpp:139
glm::bvec2
highp_bvec2 bvec2
2 components vector of boolean.
Definition: type_vec.hpp:498
glm::mediump_bvec4
tvec4< bool, mediump > mediump_bvec4
4 components vector of medium precision bool numbers.
Definition: type_vec.hpp:363
glm::lowp_ivec4
tvec4< int, lowp > lowp_ivec4
4 components vector of low precision signed integer numbers.
Definition: type_vec.hpp:333
glm::mediump_bvec3
tvec3< bool, mediump > mediump_bvec3
3 components vector of medium precision bool numbers.
Definition: type_vec.hpp:268
glm::mediump_dvec3
tvec3< double, mediump > mediump_dvec3
3 components vector of medium double-precision floating-point numbers.
Definition: type_vec.hpp:207
glm::mediump_dvec2
tvec2< double, mediump > mediump_dvec2
2 components vector of medium double-precision floating-point numbers.
Definition: type_vec.hpp:97
glm
Definition: _noise.hpp:40
glm::ivec4
highp_ivec4 ivec4
4 components vector of signed integer numbers.
Definition: type_vec.hpp:454
glm::bvec4
highp_bvec4 bvec4
4 components vector of boolean.
Definition: type_vec.hpp:508
glm::mediump_bvec2
tvec2< bool, mediump > mediump_bvec2
2 components vector of medium precision bool numbers.
Definition: type_vec.hpp:160
glm::highp_ivec2
tvec2< int, highp > highp_ivec2
2 components vector of high precision signed integer numbers.
Definition: type_vec.hpp:111
glm::lowp_bvec3
tvec3< bool, lowp > lowp_bvec3
3 components vector of low precision bool numbers.
Definition: type_vec.hpp:274
glm::lowp_dvec4
tvec4< double, lowp > lowp_dvec4
4 components vector of low double-precision floating-point numbers.
Definition: type_vec.hpp:315
glm::highp_bvec2
tvec2< bool, highp > highp_bvec2
2 components vector of high precision bool numbers.
Definition: type_vec.hpp:153
glm::bvec3
highp_bvec3 bvec3
3 components vector of boolean.
Definition: type_vec.hpp:503
glm::lowp_dvec3
tvec3< double, lowp > lowp_dvec3
3 components vector of low double-precision floating-point numbers.
Definition: type_vec.hpp:214
glm::highp_dvec4
tvec4< double, highp > highp_dvec4
4 components vector of high double-precision floating-point numbers.
Definition: type_vec.hpp:303
glm::vec4
highp_vec4 vec4
4 components vector of floating-point numbers.
Definition: type_vec.hpp:400
glm::lowp_uvec4
tvec4< uint, lowp > lowp_uvec4
4 components vector of low precision unsigned integer numbers.
Definition: type_vec.hpp:351
glm::lowp_ivec3
tvec3< int, lowp > lowp_ivec3
3 components vector of low precision signed integer numbers.
Definition: type_vec.hpp:235
glm::lowp_uvec2
tvec2< uint, lowp > lowp_uvec2
2 components vector of low precision unsigned integer numbers.
Definition: type_vec.hpp:146
glm::mediump_uvec3
tvec3< uint, mediump > mediump_uvec3
3 components vector of medium precision unsigned integer numbers.
Definition: type_vec.hpp:249
glm::lowp_vec2
tvec2< float, lowp > lowp_vec2
2 components vector of low single-precision floating-point numbers.
Definition: type_vec.hpp:83
glm::lowp_uvec3
tvec3< uint, lowp > lowp_uvec3
3 components vector of low precision unsigned integer numbers.
Definition: type_vec.hpp:256
glm::vec3
highp_vec3 vec3
3 components vector of floating-point numbers.
Definition: type_vec.hpp:395
glm::dvec3
highp_dvec3 dvec3
3 components vector of double-precision floating-point numbers.
Definition: type_vec.hpp:422
glm::highp_uvec3
tvec3< uint, highp > highp_uvec3
3 components vector of high precision unsigned integer numbers.
Definition: type_vec.hpp:242
glm::highp_bvec3
tvec3< bool, highp > highp_bvec3
3 components vector of high precision bool numbers.
Definition: type_vec.hpp:262
glm::lowp_vec3
tvec3< float, lowp > lowp_vec3
3 components vector of low single-precision floating-point numbers.
Definition: type_vec.hpp:193
glm::ivec2
highp_ivec2 ivec2
2 components vector of signed integer numbers.
Definition: type_vec.hpp:444
glm::highp_uvec2
tvec2< uint, highp > highp_uvec2
2 components vector of high precision unsigned integer numbers.
Definition: type_vec.hpp:132
glm::mediump_ivec2
tvec2< int, mediump > mediump_ivec2
2 components vector of medium precision signed integer numbers.
Definition: type_vec.hpp:118
precision.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::highp_ivec4
tvec4< int, highp > highp_ivec4
4 components vector of high precision signed integer numbers.
Definition: type_vec.hpp:321
glm::lowp_vec4
tvec4< float, lowp > lowp_vec4
4 components vector of low single-precision floating-point numbers.
Definition: type_vec.hpp:297
type_int.hpp
OpenGL Mathematics (glm.g-truc.net)
glm::highp_dvec2
tvec2< double, highp > highp_dvec2
2 components vector of high double-precision floating-point numbers.
Definition: type_vec.hpp:90
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00133.html000066400000000000000000000103411356361734700216400ustar00rootroot00000000000000 0.9.7: type_vec1.hpp File Reference
type_vec1.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2008-08-25 / 2011-06-15
Author
Christophe Riccio

Definition in file type_vec1.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00133_source.html000066400000000000000000001377201356361734700232330ustar00rootroot00000000000000 0.9.7: type_vec1.hpp Source File
type_vec1.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "../fwd.hpp"
36 #include "type_vec.hpp"
37 #ifdef GLM_SWIZZLE
38 # if GLM_HAS_ANONYMOUS_UNION
39 # include "_swizzle.hpp"
40 # else
41 # include "_swizzle_func.hpp"
42 # endif
43 #endif //GLM_SWIZZLE
44 #include <cstddef>
45 
46 namespace glm
47 {
48  template <typename T, precision P = defaultp>
49  struct tvec1
50  {
51  // -- Implementation detail --
52 
53  typedef tvec1<T, P> type;
54  typedef tvec1<bool, P> bool_type;
55  typedef T value_type;
56 
57 # ifdef GLM_META_PROG_HELPERS
58  static GLM_RELAXED_CONSTEXPR length_t components = 1;
59  static GLM_RELAXED_CONSTEXPR precision prec = P;
60 # endif//GLM_META_PROG_HELPERS
61 
62  // -- Data --
63 
64 # if GLM_HAS_ANONYMOUS_UNION
65  union
66  {
67  T x;
68  T r;
69  T s;
70 /*
71 # ifdef GLM_SWIZZLE
72  _GLM_SWIZZLE1_2_MEMBERS(T, P, tvec2, x)
73  _GLM_SWIZZLE1_2_MEMBERS(T, P, tvec2, r)
74  _GLM_SWIZZLE1_2_MEMBERS(T, P, tvec2, s)
75  _GLM_SWIZZLE1_3_MEMBERS(T, P, tvec3, x)
76  _GLM_SWIZZLE1_3_MEMBERS(T, P, tvec3, r)
77  _GLM_SWIZZLE1_3_MEMBERS(T, P, tvec3, s)
78  _GLM_SWIZZLE1_4_MEMBERS(T, P, tvec4, x)
79  _GLM_SWIZZLE1_4_MEMBERS(T, P, tvec4, r)
80  _GLM_SWIZZLE1_4_MEMBERS(T, P, tvec4, s)
81 # endif//GLM_SWIZZLE*/
82  };
83 # else
84  union {T x, r, s;};
85 /*
86 # ifdef GLM_SWIZZLE
87  GLM_SWIZZLE_GEN_VEC_FROM_VEC1(T, P, tvec2, tvec2, tvec3, tvec4)
88 # endif//GLM_SWIZZLE*/
89 # endif
90 
91  // -- Component accesses --
92 
93 # ifdef GLM_FORCE_SIZE_FUNC
94  typedef size_t size_type;
96  GLM_FUNC_DECL GLM_CONSTEXPR size_type size() const;
97 
98  GLM_FUNC_DECL T & operator[](size_type i);
99  GLM_FUNC_DECL T const & operator[](size_type i) const;
100 # else
101  typedef length_t length_type;
103  GLM_FUNC_DECL GLM_CONSTEXPR length_type length() const;
104 
105  GLM_FUNC_DECL T & operator[](length_type i);
106  GLM_FUNC_DECL T const & operator[](length_type i) const;
107 # endif//GLM_FORCE_SIZE_FUNC
108 
109  // -- Implicit basic constructors --
110 
111  GLM_FUNC_DECL tvec1() GLM_DEFAULT_CTOR;
112  GLM_FUNC_DECL tvec1(tvec1<T, P> const & v) GLM_DEFAULT;
113  template <precision Q>
114  GLM_FUNC_DECL tvec1(tvec1<T, Q> const & v);
115 
116  // -- Explicit basic constructors --
117 
118  GLM_FUNC_DECL explicit tvec1(ctor);
119  GLM_FUNC_DECL explicit tvec1(T const & s);
120 
121  // -- Conversion vector constructors --
122 
124  template <typename U, precision Q>
125  GLM_FUNC_DECL explicit tvec1(tvec2<U, Q> const & v);
127  template <typename U, precision Q>
128  GLM_FUNC_DECL explicit tvec1(tvec3<U, Q> const & v);
130  template <typename U, precision Q>
131  GLM_FUNC_DECL explicit tvec1(tvec4<U, Q> const & v);
132 
134  template <typename U, precision Q>
135  GLM_FUNC_DECL GLM_EXPLICIT tvec1(tvec1<U, Q> const & v);
136 
137  // -- Swizzle constructors --
138 
139 # if(GLM_HAS_ANONYMOUS_UNION && defined(GLM_SWIZZLE))
140  template <int E0>
141  GLM_FUNC_DECL tvec1(detail::_swizzle<1, T, P, tvec1<T, P>, E0, -1,-2,-3> const & that)
142  {
143  *this = that();
144  }
145 # endif//(GLM_HAS_ANONYMOUS_UNION && defined(GLM_SWIZZLE))
146 
147  // -- Unary arithmetic operators --
148 
149  GLM_FUNC_DECL tvec1<T, P> & operator=(tvec1<T, P> const & v) GLM_DEFAULT;
150 
151  template <typename U>
152  GLM_FUNC_DECL tvec1<T, P> & operator=(tvec1<U, P> const & v);
153  template <typename U>
154  GLM_FUNC_DECL tvec1<T, P> & operator+=(U const & s);
155  template <typename U>
156  GLM_FUNC_DECL tvec1<T, P> & operator+=(tvec1<U, P> const & v);
157  template <typename U>
158  GLM_FUNC_DECL tvec1<T, P> & operator-=(U const & s);
159  template <typename U>
160  GLM_FUNC_DECL tvec1<T, P> & operator-=(tvec1<U, P> const & v);
161  template <typename U>
162  GLM_FUNC_DECL tvec1<T, P> & operator*=(U const & s);
163  template <typename U>
164  GLM_FUNC_DECL tvec1<T, P> & operator*=(tvec1<U, P> const & v);
165  template <typename U>
166  GLM_FUNC_DECL tvec1<T, P> & operator/=(U const & s);
167  template <typename U>
168  GLM_FUNC_DECL tvec1<T, P> & operator/=(tvec1<U, P> const & v);
169 
170  // -- Increment and decrement operators --
171 
172  GLM_FUNC_DECL tvec1<T, P> & operator++();
173  GLM_FUNC_DECL tvec1<T, P> & operator--();
174  GLM_FUNC_DECL tvec1<T, P> operator++(int);
175  GLM_FUNC_DECL tvec1<T, P> operator--(int);
176 
177  // -- Unary bit operators --
178 
179  template <typename U>
180  GLM_FUNC_DECL tvec1<T, P> & operator%=(U const & s);
181  template <typename U>
182  GLM_FUNC_DECL tvec1<T, P> & operator%=(tvec1<U, P> const & v);
183  template <typename U>
184  GLM_FUNC_DECL tvec1<T, P> & operator&=(U const & s);
185  template <typename U>
186  GLM_FUNC_DECL tvec1<T, P> & operator&=(tvec1<U, P> const & v);
187  template <typename U>
188  GLM_FUNC_DECL tvec1<T, P> & operator|=(U const & s);
189  template <typename U>
190  GLM_FUNC_DECL tvec1<T, P> & operator|=(tvec1<U, P> const & v);
191  template <typename U>
192  GLM_FUNC_DECL tvec1<T, P> & operator^=(U const & s);
193  template <typename U>
194  GLM_FUNC_DECL tvec1<T, P> & operator^=(tvec1<U, P> const & v);
195  template <typename U>
196  GLM_FUNC_DECL tvec1<T, P> & operator<<=(U const & s);
197  template <typename U>
198  GLM_FUNC_DECL tvec1<T, P> & operator<<=(tvec1<U, P> const & v);
199  template <typename U>
200  GLM_FUNC_DECL tvec1<T, P> & operator>>=(U const & s);
201  template <typename U>
202  GLM_FUNC_DECL tvec1<T, P> & operator>>=(tvec1<U, P> const & v);
203  };
204 
205  // -- Unary operators --
206 
207  template <typename T, precision P>
208  GLM_FUNC_DECL tvec1<T, P> operator-(tvec1<T, P> const & v);
209 
210  // -- Binary operators --
211 
212  template <typename T, precision P>
213  GLM_FUNC_DECL tvec1<T, P> operator+(tvec1<T, P> const & v, T const & s);
214 
215  template <typename T, precision P>
216  GLM_FUNC_DECL tvec1<T, P> operator+(T const & s, tvec1<T, P> const & v);
217 
218  template <typename T, precision P>
219  GLM_FUNC_DECL tvec1<T, P> operator+(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
220 
221  template <typename T, precision P>
222  GLM_FUNC_DECL tvec1<T, P> operator-(tvec1<T, P> const & v, T const & s);
223 
224  template <typename T, precision P>
225  GLM_FUNC_DECL tvec1<T, P> operator-(T const & s, tvec1<T, P> const & v);
226 
227  template <typename T, precision P>
228  GLM_FUNC_DECL tvec1<T, P> operator- (tvec1<T, P> const & v1, tvec1<T, P> const & v2);
229 
230  template <typename T, precision P>
231  GLM_FUNC_DECL tvec1<T, P> operator*(tvec1<T, P> const & v, T const & s);
232 
233  template <typename T, precision P>
234  GLM_FUNC_DECL tvec1<T, P> operator*(T const & s, tvec1<T, P> const & v);
235 
236  template <typename T, precision P>
237  GLM_FUNC_DECL tvec1<T, P> operator*(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
238 
239  template <typename T, precision P>
240  GLM_FUNC_DECL tvec1<T, P> operator/(tvec1<T, P> const & v, T const & s);
241 
242  template <typename T, precision P>
243  GLM_FUNC_DECL tvec1<T, P> operator/(T const & s, tvec1<T, P> const & v);
244 
245  template <typename T, precision P>
246  GLM_FUNC_DECL tvec1<T, P> operator/(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
247 
248  template <typename T, precision P>
249  GLM_FUNC_DECL tvec1<T, P> operator%(tvec1<T, P> const & v, T const & s);
250 
251  template <typename T, precision P>
252  GLM_FUNC_DECL tvec1<T, P> operator%(T const & s, tvec1<T, P> const & v);
253 
254  template <typename T, precision P>
255  GLM_FUNC_DECL tvec1<T, P> operator%(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
256 
257  template <typename T, precision P>
258  GLM_FUNC_DECL tvec1<T, P> operator&(tvec1<T, P> const & v, T const & s);
259 
260  template <typename T, precision P>
261  GLM_FUNC_DECL tvec1<T, P> operator&(T const & s, tvec1<T, P> const & v);
262 
263  template <typename T, precision P>
264  GLM_FUNC_DECL tvec1<T, P> operator&(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
265 
266  template <typename T, precision P>
267  GLM_FUNC_DECL tvec1<T, P> operator|(tvec1<T, P> const & v, T const & s);
268 
269  template <typename T, precision P>
270  GLM_FUNC_DECL tvec1<T, P> operator|(T const & s, tvec1<T, P> const & v);
271 
272  template <typename T, precision P>
273  GLM_FUNC_DECL tvec1<T, P> operator|(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
274 
275  template <typename T, precision P>
276  GLM_FUNC_DECL tvec1<T, P> operator^(tvec1<T, P> const & v, T const & s);
277 
278  template <typename T, precision P>
279  GLM_FUNC_DECL tvec1<T, P> operator^(T const & s, tvec1<T, P> const & v);
280 
281  template <typename T, precision P>
282  GLM_FUNC_DECL tvec1<T, P> operator^(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
283 
284  template <typename T, precision P>
285  GLM_FUNC_DECL tvec1<T, P> operator<<(tvec1<T, P> const & v, T const & s);
286 
287  template <typename T, precision P>
288  GLM_FUNC_DECL tvec1<T, P> operator<<(T const & s, tvec1<T, P> const & v);
289 
290  template <typename T, precision P>
291  GLM_FUNC_DECL tvec1<T, P> operator<<(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
292 
293  template <typename T, precision P>
294  GLM_FUNC_DECL tvec1<T, P> operator>>(tvec1<T, P> const & v, T const & s);
295 
296  template <typename T, precision P>
297  GLM_FUNC_DECL tvec1<T, P> operator>>(T const & s, tvec1<T, P> const & v);
298 
299  template <typename T, precision P>
300  GLM_FUNC_DECL tvec1<T, P> operator>>(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
301 
302  template <typename T, precision P>
303  GLM_FUNC_DECL tvec1<T, P> operator~(tvec1<T, P> const & v);
304 
305  // -- Boolean operators --
306 
307  template <typename T, precision P>
308  GLM_FUNC_DECL bool operator==(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
309 
310  template <typename T, precision P>
311  GLM_FUNC_DECL bool operator!=(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
312 }//namespace glm
313 
314 #ifndef GLM_EXTERNAL_TEMPLATE
315 #include "type_vec1.inl"
316 #endif//GLM_EXTERNAL_TEMPLATE
glm::length
GLM_FUNC_DECL T length(vecType< T, P > const &x)
Returns the length of x, i.e., sqrt(x * x).
glm
Definition: _noise.hpp:40
_swizzle_func.hpp
OpenGL Mathematics (glm.g-truc.net)
type_vec.hpp
OpenGL Mathematics (glm.g-truc.net)
_swizzle.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00134.html000066400000000000000000000103411356361734700216410ustar00rootroot00000000000000 0.9.7: type_vec2.hpp File Reference
type_vec2.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2008-08-18 / 2013-08-27
Author
Christophe Riccio

Definition in file type_vec2.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00134_source.html000066400000000000000000001761471356361734700232420ustar00rootroot00000000000000 0.9.7: type_vec2.hpp Source File
type_vec2.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "type_vec.hpp"
36 #ifdef GLM_SWIZZLE
37 # if GLM_HAS_ANONYMOUS_UNION
38 # include "_swizzle.hpp"
39 # else
40 # include "_swizzle_func.hpp"
41 # endif
42 #endif //GLM_SWIZZLE
43 #include <cstddef>
44 
45 namespace glm
46 {
47  template <typename T, precision P = defaultp>
48  struct tvec2
49  {
50  // -- Implementation detail --
51 
52  typedef tvec2<T, P> type;
53  typedef tvec2<bool, P> bool_type;
54  typedef T value_type;
55 
56 # ifdef GLM_META_PROG_HELPERS
57  static GLM_RELAXED_CONSTEXPR length_t components = 2;
58  static GLM_RELAXED_CONSTEXPR precision prec = P;
59 # endif//GLM_META_PROG_HELPERS
60 
61  // -- Data --
62 
63 # if GLM_HAS_ANONYMOUS_UNION
64  union
65  {
66  struct{ T x, y; };
67  struct{ T r, g; };
68  struct{ T s, t; };
69 
70 # ifdef GLM_SWIZZLE
71  _GLM_SWIZZLE2_2_MEMBERS(T, P, tvec2, x, y)
72  _GLM_SWIZZLE2_2_MEMBERS(T, P, tvec2, r, g)
73  _GLM_SWIZZLE2_2_MEMBERS(T, P, tvec2, s, t)
74  _GLM_SWIZZLE2_3_MEMBERS(T, P, tvec3, x, y)
75  _GLM_SWIZZLE2_3_MEMBERS(T, P, tvec3, r, g)
76  _GLM_SWIZZLE2_3_MEMBERS(T, P, tvec3, s, t)
77  _GLM_SWIZZLE2_4_MEMBERS(T, P, tvec4, x, y)
78  _GLM_SWIZZLE2_4_MEMBERS(T, P, tvec4, r, g)
79  _GLM_SWIZZLE2_4_MEMBERS(T, P, tvec4, s, t)
80 # endif//GLM_SWIZZLE
81  };
82 # else
83  union {T x, r, s;};
84  union {T y, g, t;};
85 
86 # ifdef GLM_SWIZZLE
87  GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, P, tvec2, tvec2, tvec3, tvec4)
88 # endif//GLM_SWIZZLE
89 # endif
90 
91  // -- Component accesses --
92 
93 # ifdef GLM_FORCE_SIZE_FUNC
94  typedef size_t size_type;
96  GLM_FUNC_DECL GLM_CONSTEXPR size_type size() const;
97 
98  GLM_FUNC_DECL T & operator[](size_type i);
99  GLM_FUNC_DECL T const & operator[](size_type i) const;
100 # else
101  typedef length_t length_type;
103  GLM_FUNC_DECL GLM_CONSTEXPR length_type length() const;
104 
105  GLM_FUNC_DECL T & operator[](length_type i);
106  GLM_FUNC_DECL T const & operator[](length_type i) const;
107 # endif//GLM_FORCE_SIZE_FUNC
108 
109  // -- Implicit basic constructors --
110 
111  GLM_FUNC_DECL tvec2() GLM_DEFAULT_CTOR;
112  GLM_FUNC_DECL tvec2(tvec2<T, P> const & v) GLM_DEFAULT;
113  template <precision Q>
114  GLM_FUNC_DECL tvec2(tvec2<T, Q> const & v);
115 
116  // -- Explicit basic constructors --
117 
118  GLM_FUNC_DECL explicit tvec2(ctor);
119  GLM_FUNC_DECL explicit tvec2(T const & s);
120  GLM_FUNC_DECL tvec2(T const & s1, T const & s2);
121 
122  // -- Conversion constructors --
123 
125  template <typename A, typename B>
126  GLM_FUNC_DECL tvec2(A const & x, B const & y);
127  template <typename A, typename B>
128  GLM_FUNC_DECL tvec2(tvec1<A, P> const & v1, tvec1<B, P> const & v2);
129 
130  // -- Conversion vector constructors --
131 
133  template <typename U, precision Q>
134  GLM_FUNC_DECL explicit tvec2(tvec3<U, Q> const & v);
136  template <typename U, precision Q>
137  GLM_FUNC_DECL explicit tvec2(tvec4<U, Q> const & v);
138 
140  template <typename U, precision Q>
141  GLM_FUNC_DECL GLM_EXPLICIT tvec2(tvec2<U, Q> const & v);
142 
143  // -- Swizzle constructors --
144 
145 # if GLM_HAS_ANONYMOUS_UNION && defined(GLM_SWIZZLE)
146  template <int E0, int E1>
147  GLM_FUNC_DECL tvec2(detail::_swizzle<2, T, P, tvec2<T, P>, E0, E1,-1,-2> const & that)
148  {
149  *this = that();
150  }
151 # endif// GLM_HAS_ANONYMOUS_UNION && defined(GLM_SWIZZLE)
152 
153  // -- Unary arithmetic operators --
154 
155  GLM_FUNC_DECL tvec2<T, P>& operator=(tvec2<T, P> const & v) GLM_DEFAULT;
156 
157  template <typename U>
158  GLM_FUNC_DECL tvec2<T, P>& operator=(tvec2<U, P> const & v);
159  template <typename U>
160  GLM_FUNC_DECL tvec2<T, P>& operator+=(U s);
161  template <typename U>
162  GLM_FUNC_DECL tvec2<T, P>& operator+=(tvec1<U, P> const & v);
163  template <typename U>
164  GLM_FUNC_DECL tvec2<T, P>& operator+=(tvec2<U, P> const & v);
165  template <typename U>
166  GLM_FUNC_DECL tvec2<T, P>& operator-=(U s);
167  template <typename U>
168  GLM_FUNC_DECL tvec2<T, P>& operator-=(tvec1<U, P> const & v);
169  template <typename U>
170  GLM_FUNC_DECL tvec2<T, P>& operator-=(tvec2<U, P> const & v);
171  template <typename U>
172  GLM_FUNC_DECL tvec2<T, P>& operator*=(U s);
173  template <typename U>
174  GLM_FUNC_DECL tvec2<T, P>& operator*=(tvec1<U, P> const & v);
175  template <typename U>
176  GLM_FUNC_DECL tvec2<T, P>& operator*=(tvec2<U, P> const & v);
177  template <typename U>
178  GLM_FUNC_DECL tvec2<T, P>& operator/=(U s);
179  template <typename U>
180  GLM_FUNC_DECL tvec2<T, P>& operator/=(tvec1<U, P> const & v);
181  template <typename U>
182  GLM_FUNC_DECL tvec2<T, P>& operator/=(tvec2<U, P> const & v);
183 
184  // -- Increment and decrement operators --
185 
186  GLM_FUNC_DECL tvec2<T, P> & operator++();
187  GLM_FUNC_DECL tvec2<T, P> & operator--();
188  GLM_FUNC_DECL tvec2<T, P> operator++(int);
189  GLM_FUNC_DECL tvec2<T, P> operator--(int);
190 
191  // -- Unary bit operators --
192 
193  template <typename U>
194  GLM_FUNC_DECL tvec2<T, P> & operator%=(U s);
195  template <typename U>
196  GLM_FUNC_DECL tvec2<T, P> & operator%=(tvec1<U, P> const & v);
197  template <typename U>
198  GLM_FUNC_DECL tvec2<T, P> & operator%=(tvec2<U, P> const & v);
199  template <typename U>
200  GLM_FUNC_DECL tvec2<T, P> & operator&=(U s);
201  template <typename U>
202  GLM_FUNC_DECL tvec2<T, P> & operator&=(tvec1<U, P> const & v);
203  template <typename U>
204  GLM_FUNC_DECL tvec2<T, P> & operator&=(tvec2<U, P> const & v);
205  template <typename U>
206  GLM_FUNC_DECL tvec2<T, P> & operator|=(U s);
207  template <typename U>
208  GLM_FUNC_DECL tvec2<T, P> & operator|=(tvec1<U, P> const & v);
209  template <typename U>
210  GLM_FUNC_DECL tvec2<T, P> & operator|=(tvec2<U, P> const & v);
211  template <typename U>
212  GLM_FUNC_DECL tvec2<T, P> & operator^=(U s);
213  template <typename U>
214  GLM_FUNC_DECL tvec2<T, P> & operator^=(tvec1<U, P> const & v);
215  template <typename U>
216  GLM_FUNC_DECL tvec2<T, P> & operator^=(tvec2<U, P> const & v);
217  template <typename U>
218  GLM_FUNC_DECL tvec2<T, P> & operator<<=(U s);
219  template <typename U>
220  GLM_FUNC_DECL tvec2<T, P> & operator<<=(tvec1<U, P> const & v);
221  template <typename U>
222  GLM_FUNC_DECL tvec2<T, P> & operator<<=(tvec2<U, P> const & v);
223  template <typename U>
224  GLM_FUNC_DECL tvec2<T, P> & operator>>=(U s);
225  template <typename U>
226  GLM_FUNC_DECL tvec2<T, P> & operator>>=(tvec1<U, P> const & v);
227  template <typename U>
228  GLM_FUNC_DECL tvec2<T, P> & operator>>=(tvec2<U, P> const & v);
229  };
230 
231  // -- Unary operators --
232 
233  template <typename T, precision P>
234  GLM_FUNC_DECL tvec2<T, P> operator-(tvec2<T, P> const & v);
235 
236  // -- Binary operators --
237 
238  template <typename T, precision P>
239  GLM_FUNC_DECL tvec2<T, P> operator+(tvec2<T, P> const & v, T const & s);
240 
241  template <typename T, precision P>
242  GLM_FUNC_DECL tvec2<T, P> operator+(tvec2<T, P> const & v1, tvec1<T, P> const & v2);
243 
244  template <typename T, precision P>
245  GLM_FUNC_DECL tvec2<T, P> operator+(T const & s, tvec2<T, P> const & v);
246 
247  template <typename T, precision P>
248  GLM_FUNC_DECL tvec2<T, P> operator+(tvec1<T, P> const & v1, tvec2<T, P> const & v2);
249 
250  template <typename T, precision P>
251  GLM_FUNC_DECL tvec2<T, P> operator+(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
252 
253  template <typename T, precision P>
254  GLM_FUNC_DECL tvec2<T, P> operator-(tvec2<T, P> const & v, T const & s);
255 
256  template <typename T, precision P>
257  GLM_FUNC_DECL tvec2<T, P> operator-(tvec2<T, P> const & v1, tvec1<T, P> const & v2);
258 
259  template <typename T, precision P>
260  GLM_FUNC_DECL tvec2<T, P> operator-(T const & s, tvec2<T, P> const & v);
261 
262  template <typename T, precision P>
263  GLM_FUNC_DECL tvec2<T, P> operator-(tvec1<T, P> const & v1, tvec2<T, P> const & v2);
264 
265  template <typename T, precision P>
266  GLM_FUNC_DECL tvec2<T, P> operator-(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
267 
268  template <typename T, precision P>
269  GLM_FUNC_DECL tvec2<T, P> operator*(tvec2<T, P> const & v, T const & s);
270 
271  template <typename T, precision P>
272  GLM_FUNC_DECL tvec2<T, P> operator*(tvec2<T, P> const & v1, tvec1<T, P> const & v2);
273 
274  template <typename T, precision P>
275  GLM_FUNC_DECL tvec2<T, P> operator*(T const & s, tvec2<T, P> const & v);
276 
277  template <typename T, precision P>
278  GLM_FUNC_DECL tvec2<T, P> operator*(tvec1<T, P> const & v1, tvec2<T, P> const & v2);
279 
280  template <typename T, precision P>
281  GLM_FUNC_DECL tvec2<T, P> operator*(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
282 
283  template <typename T, precision P>
284  GLM_FUNC_DECL tvec2<T, P> operator/(tvec2<T, P> const & v, T const & s);
285 
286  template <typename T, precision P>
287  GLM_FUNC_DECL tvec2<T, P> operator/(tvec2<T, P> const & v1, tvec1<T, P> const & v2);
288 
289  template <typename T, precision P>
290  GLM_FUNC_DECL tvec2<T, P> operator/(T const & s, tvec2<T, P> const & v);
291 
292  template <typename T, precision P>
293  GLM_FUNC_DECL tvec2<T, P> operator/(tvec1<T, P> const & v1, tvec2<T, P> const & v2);
294 
295  template <typename T, precision P>
296  GLM_FUNC_DECL tvec2<T, P> operator/(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
297 
298  template <typename T, precision P>
299  GLM_FUNC_DECL tvec2<T, P> operator-(tvec2<T, P> const & v);
300 
301  template <typename T, precision P>
302  GLM_FUNC_DECL tvec2<T, P> operator%(tvec2<T, P> const & v, T const & s);
303 
304  template <typename T, precision P>
305  GLM_FUNC_DECL tvec2<T, P> operator%(tvec2<T, P> const & v1, tvec1<T, P> const & v2);
306 
307  template <typename T, precision P>
308  GLM_FUNC_DECL tvec2<T, P> operator%(T const & s, tvec2<T, P> const & v);
309 
310  template <typename T, precision P>
311  GLM_FUNC_DECL tvec2<T, P> operator%(tvec1<T, P> const & v1, tvec2<T, P> const & v2);
312 
313  template <typename T, precision P>
314  GLM_FUNC_DECL tvec2<T, P> operator%(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
315 
316  template <typename T, precision P>
317  GLM_FUNC_DECL tvec2<T, P> operator&(tvec2<T, P> const & v, T const & s);
318 
319  template <typename T, precision P>
320  GLM_FUNC_DECL tvec2<T, P> operator&(tvec2<T, P> const & v1, tvec1<T, P> const & v2);
321 
322  template <typename T, precision P>
323  GLM_FUNC_DECL tvec2<T, P> operator&(T const & s, tvec2<T, P> const & v);
324 
325  template <typename T, precision P>
326  GLM_FUNC_DECL tvec2<T, P> operator&(tvec1<T, P> const & v1, tvec2<T, P> const & v2);
327 
328  template <typename T, precision P>
329  GLM_FUNC_DECL tvec2<T, P> operator&(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
330 
331  template <typename T, precision P>
332  GLM_FUNC_DECL tvec2<T, P> operator|(tvec2<T, P> const & v, T const & s);
333 
334  template <typename T, precision P>
335  GLM_FUNC_DECL tvec2<T, P> operator|(tvec2<T, P> const & v1, tvec1<T, P> const & v2);
336 
337  template <typename T, precision P>
338  GLM_FUNC_DECL tvec2<T, P> operator|(T const & s, tvec2<T, P> const & v);
339 
340  template <typename T, precision P>
341  GLM_FUNC_DECL tvec2<T, P> operator|(tvec1<T, P> const & v1, tvec2<T, P> const & v2);
342 
343  template <typename T, precision P>
344  GLM_FUNC_DECL tvec2<T, P> operator|(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
345 
346  template <typename T, precision P>
347  GLM_FUNC_DECL tvec2<T, P> operator^(tvec2<T, P> const & v, T const & s);
348 
349  template <typename T, precision P>
350  GLM_FUNC_DECL tvec2<T, P> operator^(tvec2<T, P> const & v1, tvec1<T, P> const & v2);
351 
352  template <typename T, precision P>
353  GLM_FUNC_DECL tvec2<T, P> operator^(T const & s, tvec2<T, P> const & v);
354 
355  template <typename T, precision P>
356  GLM_FUNC_DECL tvec2<T, P> operator^(tvec1<T, P> const & v1, tvec2<T, P> const & v2);
357 
358  template <typename T, precision P>
359  GLM_FUNC_DECL tvec2<T, P> operator^(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
360 
361  template <typename T, precision P>
362  GLM_FUNC_DECL tvec2<T, P> operator<<(tvec2<T, P> const & v, T const & s);
363 
364  template <typename T, precision P>
365  GLM_FUNC_DECL tvec2<T, P> operator<<(tvec2<T, P> const & v1, tvec1<T, P> const & v2);
366 
367  template <typename T, precision P>
368  GLM_FUNC_DECL tvec2<T, P> operator<<(T const & s, tvec2<T, P> const & v);
369 
370  template <typename T, precision P>
371  GLM_FUNC_DECL tvec2<T, P> operator<<(tvec1<T, P> const & v1, tvec2<T, P> const & v2);
372 
373  template <typename T, precision P>
374  GLM_FUNC_DECL tvec2<T, P> operator<<(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
375 
376  template <typename T, precision P>
377  GLM_FUNC_DECL tvec2<T, P> operator>>(tvec2<T, P> const & v, T const & s);
378 
379  template <typename T, precision P>
380  GLM_FUNC_DECL tvec2<T, P> operator>>(tvec2<T, P> const & v1, tvec1<T, P> const & v2);
381 
382  template <typename T, precision P>
383  GLM_FUNC_DECL tvec2<T, P> operator>>(T const & s, tvec2<T, P> const & v);
384 
385  template <typename T, precision P>
386  GLM_FUNC_DECL tvec2<T, P> operator>>(tvec1<T, P> const & v1, tvec2<T, P> const & v2);
387 
388  template <typename T, precision P>
389  GLM_FUNC_DECL tvec2<T, P> operator>>(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
390 
391  template <typename T, precision P>
392  GLM_FUNC_DECL tvec2<T, P> operator~(tvec2<T, P> const & v);
393 
394  // -- Boolean operators --
395 
396  template <typename T, precision P>
397  GLM_FUNC_DECL bool operator==(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
398 
399  template <typename T, precision P>
400  GLM_FUNC_DECL bool operator!=(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
401 }//namespace glm
402 
403 #ifndef GLM_EXTERNAL_TEMPLATE
404 #include "type_vec2.inl"
405 #endif//GLM_EXTERNAL_TEMPLATE
glm::length
GLM_FUNC_DECL T length(vecType< T, P > const &x)
Returns the length of x, i.e., sqrt(x * x).
glm
Definition: _noise.hpp:40
_swizzle_func.hpp
OpenGL Mathematics (glm.g-truc.net)
type_vec.hpp
OpenGL Mathematics (glm.g-truc.net)
_swizzle.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00135.html000066400000000000000000000103411356361734700216420ustar00rootroot00000000000000 0.9.7: type_vec3.hpp File Reference
type_vec3.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2008-08-22 / 2011-06-15
Author
Christophe Riccio

Definition in file type_vec3.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00135_source.html000066400000000000000000002036731356361734700232360ustar00rootroot00000000000000 0.9.7: type_vec3.hpp Source File
type_vec3.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "type_vec.hpp"
36 #ifdef GLM_SWIZZLE
37 # if GLM_HAS_ANONYMOUS_UNION
38 # include "_swizzle.hpp"
39 # else
40 # include "_swizzle_func.hpp"
41 # endif
42 #endif //GLM_SWIZZLE
43 #include <cstddef>
44 
45 namespace glm
46 {
47  template <typename T, precision P = defaultp>
48  struct tvec3
49  {
50  // -- Implementation detail --
51 
52  typedef tvec3<T, P> type;
53  typedef tvec3<bool, P> bool_type;
54  typedef T value_type;
55 
56 # ifdef GLM_META_PROG_HELPERS
57  static GLM_RELAXED_CONSTEXPR length_t components = 3;
58  static GLM_RELAXED_CONSTEXPR precision prec = P;
59 # endif//GLM_META_PROG_HELPERS
60 
61  // -- Data --
62 
63 # if GLM_HAS_ANONYMOUS_UNION
64  union
65  {
66  struct{ T x, y, z; };
67  struct{ T r, g, b; };
68  struct{ T s, t, p; };
69 
70 # ifdef GLM_SWIZZLE
71  _GLM_SWIZZLE3_2_MEMBERS(T, P, tvec2, x, y, z)
72  _GLM_SWIZZLE3_2_MEMBERS(T, P, tvec2, r, g, b)
73  _GLM_SWIZZLE3_2_MEMBERS(T, P, tvec2, s, t, p)
74  _GLM_SWIZZLE3_3_MEMBERS(T, P, tvec3, x, y, z)
75  _GLM_SWIZZLE3_3_MEMBERS(T, P, tvec3, r, g, b)
76  _GLM_SWIZZLE3_3_MEMBERS(T, P, tvec3, s, t, p)
77  _GLM_SWIZZLE3_4_MEMBERS(T, P, tvec4, x, y, z)
78  _GLM_SWIZZLE3_4_MEMBERS(T, P, tvec4, r, g, b)
79  _GLM_SWIZZLE3_4_MEMBERS(T, P, tvec4, s, t, p)
80 # endif//GLM_SWIZZLE
81  };
82 # else
83  union { T x, r, s; };
84  union { T y, g, t; };
85  union { T z, b, p; };
86 
87 # ifdef GLM_SWIZZLE
88  GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, P, tvec3, tvec2, tvec3, tvec4)
89 # endif//GLM_SWIZZLE
90 # endif//GLM_LANG
91 
92  // -- Component accesses --
93 
94 # ifdef GLM_FORCE_SIZE_FUNC
95  typedef size_t size_type;
97  GLM_FUNC_DECL GLM_CONSTEXPR size_type size() const;
98 
99  GLM_FUNC_DECL T & operator[](size_type i);
100  GLM_FUNC_DECL T const & operator[](size_type i) const;
101 # else
102  typedef length_t length_type;
104  GLM_FUNC_DECL GLM_CONSTEXPR length_type length() const;
105 
106  GLM_FUNC_DECL T & operator[](length_type i);
107  GLM_FUNC_DECL T const & operator[](length_type i) const;
108 # endif//GLM_FORCE_SIZE_FUNC
109 
110  // -- Implicit basic constructors --
111 
112  GLM_FUNC_DECL tvec3() GLM_DEFAULT_CTOR;
113  GLM_FUNC_DECL tvec3(tvec3<T, P> const & v) GLM_DEFAULT;
114  template <precision Q>
115  GLM_FUNC_DECL tvec3(tvec3<T, Q> const & v);
116 
117  // -- Explicit basic constructors --
118 
119  GLM_FUNC_DECL explicit tvec3(ctor);
120  GLM_FUNC_DECL explicit tvec3(T const & s);
121  GLM_FUNC_DECL tvec3(T const & a, T const & b, T const & c);
122 
123  // -- Conversion scalar constructors --
124 
126  template <typename A, typename B, typename C>
127  GLM_FUNC_DECL tvec3(A const & a, B const & b, C const & c);
128  template <typename A, typename B, typename C>
129  GLM_FUNC_DECL tvec3(tvec1<A, P> const & a, tvec1<B, P> const & b, tvec1<C, P> const & c);
130 
131  // -- Conversion vector constructors --
132 
134  template <typename A, typename B, precision Q>
135  GLM_FUNC_DECL explicit tvec3(tvec2<A, Q> const & a, B const & b);
137  template <typename A, typename B, precision Q>
138  GLM_FUNC_DECL explicit tvec3(tvec2<A, Q> const & a, tvec1<B, Q> const & b);
140  template <typename A, typename B, precision Q>
141  GLM_FUNC_DECL explicit tvec3(A const & a, tvec2<B, Q> const & b);
143  template <typename A, typename B, precision Q>
144  GLM_FUNC_DECL explicit tvec3(tvec1<A, Q> const & a, tvec2<B, Q> const & b);
146  template <typename U, precision Q>
147  GLM_FUNC_DECL explicit tvec3(tvec4<U, Q> const & v);
148 
150  template <typename U, precision Q>
151  GLM_FUNC_DECL GLM_EXPLICIT tvec3(tvec3<U, Q> const & v);
152 
153  // -- Swizzle constructors --
154 
155 # if GLM_HAS_ANONYMOUS_UNION && defined(GLM_SWIZZLE)
156  template <int E0, int E1, int E2>
157  GLM_FUNC_DECL tvec3(detail::_swizzle<3, T, P, tvec3<T, P>, E0, E1, E2, -1> const & that)
158  {
159  *this = that();
160  }
161 
162  template <int E0, int E1>
163  GLM_FUNC_DECL tvec3(detail::_swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const & v, T const & s)
164  {
165  *this = tvec3<T, P>(v(), s);
166  }
167 
168  template <int E0, int E1>
169  GLM_FUNC_DECL tvec3(T const & s, detail::_swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const & v)
170  {
171  *this = tvec3<T, P>(s, v());
172  }
173 # endif// GLM_HAS_ANONYMOUS_UNION && defined(GLM_SWIZZLE)
174 
175  // -- Unary arithmetic operators --
176 
177  GLM_FUNC_DECL tvec3<T, P> & operator=(tvec3<T, P> const & v) GLM_DEFAULT;
178 
179  template <typename U>
180  GLM_FUNC_DECL tvec3<T, P> & operator=(tvec3<U, P> const & v);
181  template <typename U>
182  GLM_FUNC_DECL tvec3<T, P> & operator+=(U s);
183  template <typename U>
184  GLM_FUNC_DECL tvec3<T, P> & operator+=(tvec1<U, P> const & v);
185  template <typename U>
186  GLM_FUNC_DECL tvec3<T, P> & operator+=(tvec3<U, P> const & v);
187  template <typename U>
188  GLM_FUNC_DECL tvec3<T, P> & operator-=(U s);
189  template <typename U>
190  GLM_FUNC_DECL tvec3<T, P> & operator-=(tvec1<U, P> const & v);
191  template <typename U>
192  GLM_FUNC_DECL tvec3<T, P> & operator-=(tvec3<U, P> const & v);
193  template <typename U>
194  GLM_FUNC_DECL tvec3<T, P> & operator*=(U s);
195  template <typename U>
196  GLM_FUNC_DECL tvec3<T, P> & operator*=(tvec1<U, P> const & v);
197  template <typename U>
198  GLM_FUNC_DECL tvec3<T, P> & operator*=(tvec3<U, P> const & v);
199  template <typename U>
200  GLM_FUNC_DECL tvec3<T, P> & operator/=(U s);
201  template <typename U>
202  GLM_FUNC_DECL tvec3<T, P> & operator/=(tvec1<U, P> const & v);
203  template <typename U>
204  GLM_FUNC_DECL tvec3<T, P> & operator/=(tvec3<U, P> const & v);
205 
206  // -- Increment and decrement operators --
207 
208  GLM_FUNC_DECL tvec3<T, P> & operator++();
209  GLM_FUNC_DECL tvec3<T, P> & operator--();
210  GLM_FUNC_DECL tvec3<T, P> operator++(int);
211  GLM_FUNC_DECL tvec3<T, P> operator--(int);
212 
213  // -- Unary bit operators --
214 
215  template <typename U>
216  GLM_FUNC_DECL tvec3<T, P> & operator%=(U s);
217  template <typename U>
218  GLM_FUNC_DECL tvec3<T, P> & operator%=(tvec1<U, P> const & v);
219  template <typename U>
220  GLM_FUNC_DECL tvec3<T, P> & operator%=(tvec3<U, P> const & v);
221  template <typename U>
222  GLM_FUNC_DECL tvec3<T, P> & operator&=(U s);
223  template <typename U>
224  GLM_FUNC_DECL tvec3<T, P> & operator&=(tvec1<U, P> const & v);
225  template <typename U>
226  GLM_FUNC_DECL tvec3<T, P> & operator&=(tvec3<U, P> const & v);
227  template <typename U>
228  GLM_FUNC_DECL tvec3<T, P> & operator|=(U s);
229  template <typename U>
230  GLM_FUNC_DECL tvec3<T, P> & operator|=(tvec1<U, P> const & v);
231  template <typename U>
232  GLM_FUNC_DECL tvec3<T, P> & operator|=(tvec3<U, P> const & v);
233  template <typename U>
234  GLM_FUNC_DECL tvec3<T, P> & operator^=(U s);
235  template <typename U>
236  GLM_FUNC_DECL tvec3<T, P> & operator^=(tvec1<U, P> const & v);
237  template <typename U>
238  GLM_FUNC_DECL tvec3<T, P> & operator^=(tvec3<U, P> const & v);
239  template <typename U>
240  GLM_FUNC_DECL tvec3<T, P> & operator<<=(U s);
241  template <typename U>
242  GLM_FUNC_DECL tvec3<T, P> & operator<<=(tvec1<U, P> const & v);
243  template <typename U>
244  GLM_FUNC_DECL tvec3<T, P> & operator<<=(tvec3<U, P> const & v);
245  template <typename U>
246  GLM_FUNC_DECL tvec3<T, P> & operator>>=(U s);
247  template <typename U>
248  GLM_FUNC_DECL tvec3<T, P> & operator>>=(tvec1<U, P> const & v);
249  template <typename U>
250  GLM_FUNC_DECL tvec3<T, P> & operator>>=(tvec3<U, P> const & v);
251  };
252 
253  // -- Unary operators --
254 
255  template <typename T, precision P>
256  GLM_FUNC_DECL tvec3<T, P> operator-(tvec3<T, P> const & v);
257 
258  // -- Binary operators --
259 
260  template <typename T, precision P>
261  GLM_FUNC_DECL tvec3<T, P> operator+(tvec3<T, P> const & v, T const & s);
262 
263  template <typename T, precision P>
264  GLM_FUNC_DECL tvec3<T, P> operator+(tvec3<T, P> const & v, tvec1<T, P> const & s);
265 
266  template <typename T, precision P>
267  GLM_FUNC_DECL tvec3<T, P> operator+(T const & s, tvec3<T, P> const & v);
268 
269  template <typename T, precision P>
270  GLM_FUNC_DECL tvec3<T, P> operator+(tvec1<T, P> const & s, tvec3<T, P> const & v);
271 
272  template <typename T, precision P>
273  GLM_FUNC_DECL tvec3<T, P> operator+(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
274 
275  template <typename T, precision P>
276  GLM_FUNC_DECL tvec3<T, P> operator-(tvec3<T, P> const & v, T const & s);
277 
278  template <typename T, precision P>
279  GLM_FUNC_DECL tvec3<T, P> operator-(tvec3<T, P> const & v, tvec1<T, P> const & s);
280 
281  template <typename T, precision P>
282  GLM_FUNC_DECL tvec3<T, P> operator-(T const & s, tvec3<T, P> const & v);
283 
284  template <typename T, precision P>
285  GLM_FUNC_DECL tvec3<T, P> operator-(tvec1<T, P> const & s, tvec3<T, P> const & v);
286 
287  template <typename T, precision P>
288  GLM_FUNC_DECL tvec3<T, P> operator-(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
289 
290  template <typename T, precision P>
291  GLM_FUNC_DECL tvec3<T, P> operator*(tvec3<T, P> const & v, T const & s);
292 
293  template <typename T, precision P>
294  GLM_FUNC_DECL tvec3<T, P> operator*(tvec3<T, P> const & v, tvec1<T, P> const & s);
295 
296  template <typename T, precision P>
297  GLM_FUNC_DECL tvec3<T, P> operator*(T const & s, tvec3<T, P> const & v);
298 
299  template <typename T, precision P>
300  GLM_FUNC_DECL tvec3<T, P> operator*(tvec1<T, P> const & s, tvec3<T, P> const & v);
301 
302  template <typename T, precision P>
303  GLM_FUNC_DECL tvec3<T, P> operator*(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
304 
305  template <typename T, precision P>
306  GLM_FUNC_DECL tvec3<T, P> operator/(tvec3<T, P> const & v, T const & s);
307 
308  template <typename T, precision P>
309  GLM_FUNC_DECL tvec3<T, P> operator/(tvec3<T, P> const & v, tvec1<T, P> const & s);
310 
311  template <typename T, precision P>
312  GLM_FUNC_DECL tvec3<T, P> operator/(T const & s, tvec3<T, P> const & v);
313 
314  template <typename T, precision P>
315  GLM_FUNC_DECL tvec3<T, P> operator/(tvec1<T, P> const & s, tvec3<T, P> const & v);
316 
317  template <typename T, precision P>
318  GLM_FUNC_DECL tvec3<T, P> operator/(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
319 
320  template <typename T, precision P>
321  GLM_FUNC_DECL tvec3<T, P> operator%(tvec3<T, P> const & v, T const & s);
322 
323  template <typename T, precision P>
324  GLM_FUNC_DECL tvec3<T, P> operator%(tvec3<T, P> const & v, tvec1<T, P> const & s);
325 
326  template <typename T, precision P>
327  GLM_FUNC_DECL tvec3<T, P> operator%(T const & s, tvec3<T, P> const & v);
328 
329  template <typename T, precision P>
330  GLM_FUNC_DECL tvec3<T, P> operator%(tvec1<T, P> const & s, tvec3<T, P> const & v);
331 
332  template <typename T, precision P>
333  GLM_FUNC_DECL tvec3<T, P> operator%(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
334 
335  template <typename T, precision P>
336  GLM_FUNC_DECL tvec3<T, P> operator&(tvec3<T, P> const & v, T const & s);
337 
338  template <typename T, precision P>
339  GLM_FUNC_DECL tvec3<T, P> operator&(tvec3<T, P> const & v, tvec1<T, P> const & s);
340 
341  template <typename T, precision P>
342  GLM_FUNC_DECL tvec3<T, P> operator&(T const & s, tvec3<T, P> const & v);
343 
344  template <typename T, precision P>
345  GLM_FUNC_DECL tvec3<T, P> operator&(tvec1<T, P> const & s, tvec3<T, P> const & v);
346 
347  template <typename T, precision P>
348  GLM_FUNC_DECL tvec3<T, P> operator&(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
349 
350  template <typename T, precision P>
351  GLM_FUNC_DECL tvec3<T, P> operator|(tvec3<T, P> const & v, T const & s);
352 
353  template <typename T, precision P>
354  GLM_FUNC_DECL tvec3<T, P> operator|(tvec3<T, P> const & v, tvec1<T, P> const & s);
355 
356  template <typename T, precision P>
357  GLM_FUNC_DECL tvec3<T, P> operator|(T const & s, tvec3<T, P> const & v);
358 
359  template <typename T, precision P>
360  GLM_FUNC_DECL tvec3<T, P> operator|(tvec1<T, P> const & s, tvec3<T, P> const & v);
361 
362  template <typename T, precision P>
363  GLM_FUNC_DECL tvec3<T, P> operator|(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
364 
365  template <typename T, precision P>
366  GLM_FUNC_DECL tvec3<T, P> operator^(tvec3<T, P> const & v, T const & s);
367 
368  template <typename T, precision P>
369  GLM_FUNC_DECL tvec3<T, P> operator^(tvec3<T, P> const & v, tvec1<T, P> const & s);
370 
371  template <typename T, precision P>
372  GLM_FUNC_DECL tvec3<T, P> operator^(T const & s, tvec3<T, P> const & v);
373 
374  template <typename T, precision P>
375  GLM_FUNC_DECL tvec3<T, P> operator^(tvec1<T, P> const & s, tvec3<T, P> const & v);
376 
377  template <typename T, precision P>
378  GLM_FUNC_DECL tvec3<T, P> operator^(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
379 
380  template <typename T, precision P>
381  GLM_FUNC_DECL tvec3<T, P> operator<<(tvec3<T, P> const & v, T const & s);
382 
383  template <typename T, precision P>
384  GLM_FUNC_DECL tvec3<T, P> operator<<(tvec3<T, P> const & v, tvec1<T, P> const & s);
385 
386  template <typename T, precision P>
387  GLM_FUNC_DECL tvec3<T, P> operator<<(T const & s, tvec3<T, P> const & v);
388 
389  template <typename T, precision P>
390  GLM_FUNC_DECL tvec3<T, P> operator<<(tvec1<T, P> const & s, tvec3<T, P> const & v);
391 
392  template <typename T, precision P>
393  GLM_FUNC_DECL tvec3<T, P> operator<<(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
394 
395  template <typename T, precision P>
396  GLM_FUNC_DECL tvec3<T, P> operator>>(tvec3<T, P> const & v, T const & s);
397 
398  template <typename T, precision P>
399  GLM_FUNC_DECL tvec3<T, P> operator>>(tvec3<T, P> const & v, tvec1<T, P> const & s);
400 
401  template <typename T, precision P>
402  GLM_FUNC_DECL tvec3<T, P> operator>>(T const & s, tvec3<T, P> const & v);
403 
404  template <typename T, precision P>
405  GLM_FUNC_DECL tvec3<T, P> operator>>(tvec1<T, P> const & s, tvec3<T, P> const & v);
406 
407  template <typename T, precision P>
408  GLM_FUNC_DECL tvec3<T, P> operator>>(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
409 
410  template <typename T, precision P>
411  GLM_FUNC_DECL tvec3<T, P> operator~(tvec3<T, P> const & v);
412 
413  // -- Boolean operators --
414 
415  template <typename T, precision P>
416  GLM_FUNC_DECL bool operator==(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
417 
418  template <typename T, precision P>
419  GLM_FUNC_DECL bool operator!=(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
420 }//namespace glm
421 
422 #ifndef GLM_EXTERNAL_TEMPLATE
423 #include "type_vec3.inl"
424 #endif//GLM_EXTERNAL_TEMPLATE
glm::length
GLM_FUNC_DECL T length(vecType< T, P > const &x)
Returns the length of x, i.e., sqrt(x * x).
glm
Definition: _noise.hpp:40
_swizzle_func.hpp
OpenGL Mathematics (glm.g-truc.net)
type_vec.hpp
OpenGL Mathematics (glm.g-truc.net)
_swizzle.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00136.html000066400000000000000000000103411356361734700216430ustar00rootroot00000000000000 0.9.7: type_vec4.hpp File Reference
type_vec4.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2008-08-22 / 2011-06-15
Author
Christophe Riccio

Definition in file type_vec4.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00136_source.html000066400000000000000000002407161356361734700232360ustar00rootroot00000000000000 0.9.7: type_vec4.hpp Source File
type_vec4.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "setup.hpp"
36 #include "type_vec.hpp"
37 #ifdef GLM_SWIZZLE
38 # if GLM_HAS_ANONYMOUS_UNION
39 # include "_swizzle.hpp"
40 # else
41 # include "_swizzle_func.hpp"
42 # endif
43 #endif //GLM_SWIZZLE
44 #include <cstddef>
45 
46 namespace glm{
47 namespace detail
48 {
49  template <typename T>
50  struct simd
51  {
52  typedef T type[4];
53  };
54 
55 # define GLM_NOT_BUGGY_VC32BITS !(GLM_MODEL == GLM_MODEL_32 && (GLM_COMPILER & GLM_COMPILER_VC) && GLM_COMPILER < GLM_COMPILER_VC2013)
56 
57 # if (GLM_ARCH & GLM_ARCH_SSE2) && GLM_NOT_BUGGY_VC32BITS
58  template <>
59  struct simd<float>
60  {
61  typedef __m128 type;
62  };
63 
64  template <>
65  struct simd<int>
66  {
67  typedef __m128i type;
68  };
69 
70  template <>
71  struct simd<unsigned int>
72  {
73  typedef __m128i type;
74  };
75 # endif
76 
77 # if (GLM_ARCH & GLM_ARCH_AVX) && GLM_NOT_BUGGY_VC32BITS
78  template <>
79  struct simd<double>
80  {
81  typedef __m256d type;
82  };
83 # endif
84 
85 # if (GLM_ARCH & GLM_ARCH_AVX2) && GLM_NOT_BUGGY_VC32BITS
86  template <>
87  struct simd<int64>
88  {
89  typedef __m256i type;
90  };
91 
92  template <>
93  struct simd<uint64>
94  {
95  typedef __m256i type;
96  };
97 # endif
98 
99 }//namespace detail
100 
101  template <typename T, precision P = defaultp>
102  struct tvec4
103  {
104  // -- Implementation detail --
105 
106  typedef tvec4<T, P> type;
107  typedef tvec4<bool, P> bool_type;
108  typedef T value_type;
109 
110 # ifdef GLM_META_PROG_HELPERS
111  static GLM_RELAXED_CONSTEXPR length_t components = 4;
112  static GLM_RELAXED_CONSTEXPR precision prec = P;
113 # endif//GLM_META_PROG_HELPERS
114 
115  // -- Data --
116 
117 # if GLM_HAS_ANONYMOUS_UNION
118  union
119  {
120  struct { T x, y, z, w;};
121  struct { T r, g, b, a; };
122  struct { T s, t, p, q; };
123 
124  typename detail::simd<T>::type data;
125 
126 # ifdef GLM_SWIZZLE
127  _GLM_SWIZZLE4_2_MEMBERS(T, P, tvec2, x, y, z, w)
128  _GLM_SWIZZLE4_2_MEMBERS(T, P, tvec2, r, g, b, a)
129  _GLM_SWIZZLE4_2_MEMBERS(T, P, tvec2, s, t, p, q)
130  _GLM_SWIZZLE4_3_MEMBERS(T, P, tvec3, x, y, z, w)
131  _GLM_SWIZZLE4_3_MEMBERS(T, P, tvec3, r, g, b, a)
132  _GLM_SWIZZLE4_3_MEMBERS(T, P, tvec3, s, t, p, q)
133  _GLM_SWIZZLE4_4_MEMBERS(T, P, tvec4, x, y, z, w)
134  _GLM_SWIZZLE4_4_MEMBERS(T, P, tvec4, r, g, b, a)
135  _GLM_SWIZZLE4_4_MEMBERS(T, P, tvec4, s, t, p, q)
136 # endif//GLM_SWIZZLE
137  };
138 # else
139  union { T x, r, s; };
140  union { T y, g, t; };
141  union { T z, b, p; };
142  union { T w, a, q; };
143 
144 # ifdef GLM_SWIZZLE
145  GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, P, tvec4, tvec2, tvec3, tvec4)
146 # endif//GLM_SWIZZLE
147 # endif//GLM_LANG
148 
149  // -- Component accesses --
150 
151 # ifdef GLM_FORCE_SIZE_FUNC
152  typedef size_t size_type;
154  GLM_FUNC_DECL GLM_CONSTEXPR size_type size() const;
155 
156  GLM_FUNC_DECL T & operator[](size_type i);
157  GLM_FUNC_DECL T const & operator[](size_type i) const;
158 # else
159  typedef length_t length_type;
161  GLM_FUNC_DECL GLM_CONSTEXPR length_type length() const;
162 
163  GLM_FUNC_DECL T & operator[](length_type i);
164  GLM_FUNC_DECL T const & operator[](length_type i) const;
165 # endif//GLM_FORCE_SIZE_FUNC
166 
167  // -- Implicit basic constructors --
168 
169  GLM_FUNC_DECL tvec4() GLM_DEFAULT_CTOR;
170  GLM_FUNC_DECL tvec4(tvec4<T, P> const & v) GLM_DEFAULT;
171  template <precision Q>
172  GLM_FUNC_DECL tvec4(tvec4<T, Q> const & v);
173 
174  // -- Explicit basic constructors --
175 
176  GLM_FUNC_DECL explicit tvec4(ctor);
177  GLM_FUNC_DECL explicit tvec4(T s);
178  GLM_FUNC_DECL tvec4(T a, T b, T c, T d);
179 
180  // -- Conversion scalar constructors --
181 
183  template <typename A, typename B, typename C, typename D>
184  GLM_FUNC_DECL tvec4(A a, B b, C c, D d);
185  template <typename A, typename B, typename C, typename D>
186  GLM_FUNC_DECL tvec4(tvec1<A, P> const & a, tvec1<B, P> const & b, tvec1<C, P> const & c, tvec1<D, P> const & d);
187 
188  // -- Conversion vector constructors --
189 
191  template <typename A, typename B, typename C, precision Q>
192  GLM_FUNC_DECL explicit tvec4(tvec2<A, Q> const & a, B b, C c);
194  template <typename A, typename B, typename C, precision Q>
195  GLM_FUNC_DECL explicit tvec4(tvec2<A, Q> const & a, tvec1<B, Q> const & b, tvec1<C, Q> const & c);
197  template <typename A, typename B, typename C, precision Q>
198  GLM_FUNC_DECL explicit tvec4(A a, tvec2<B, Q> const & b, C c);
200  template <typename A, typename B, typename C, precision Q>
201  GLM_FUNC_DECL explicit tvec4(tvec1<A, Q> const & a, tvec2<B, Q> const & b, tvec1<C, Q> const & c);
203  template <typename A, typename B, typename C, precision Q>
204  GLM_FUNC_DECL explicit tvec4(A a, B b, tvec2<C, Q> const & c);
206  template <typename A, typename B, typename C, precision Q>
207  GLM_FUNC_DECL explicit tvec4(tvec1<A, Q> const & a, tvec1<B, Q> const & b, tvec2<C, Q> const & c);
209  template <typename A, typename B, precision Q>
210  GLM_FUNC_DECL explicit tvec4(tvec3<A, Q> const & a, B b);
212  template <typename A, typename B, precision Q>
213  GLM_FUNC_DECL explicit tvec4(tvec3<A, Q> const & a, tvec1<B, Q> const & b);
215  template <typename A, typename B, precision Q>
216  GLM_FUNC_DECL explicit tvec4(A a, tvec3<B, Q> const & b);
218  template <typename A, typename B, precision Q>
219  GLM_FUNC_DECL explicit tvec4(tvec1<A, Q> const & a, tvec3<B, Q> const & b);
221  template <typename A, typename B, precision Q>
222  GLM_FUNC_DECL explicit tvec4(tvec2<A, Q> const & a, tvec2<B, Q> const & b);
223 
225  template <typename U, precision Q>
226  GLM_FUNC_DECL GLM_EXPLICIT tvec4(tvec4<U, Q> const & v);
227 
228  // -- Swizzle constructors --
229 
230 # if GLM_HAS_ANONYMOUS_UNION && defined(GLM_SWIZZLE)
231  template <int E0, int E1, int E2, int E3>
232  GLM_FUNC_DECL tvec4(detail::_swizzle<4, T, P, tvec4<T, P>, E0, E1, E2, E3> const & that)
233  {
234  *this = that();
235  }
236 
237  template <int E0, int E1, int F0, int F1>
238  GLM_FUNC_DECL tvec4(detail::_swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const & v, detail::_swizzle<2, T, P, tvec2<T, P>, F0, F1, -1, -2> const & u)
239  {
240  *this = tvec4<T, P>(v(), u());
241  }
242 
243  template <int E0, int E1>
244  GLM_FUNC_DECL tvec4(T const & x, T const & y, detail::_swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const & v)
245  {
246  *this = tvec4<T, P>(x, y, v());
247  }
248 
249  template <int E0, int E1>
250  GLM_FUNC_DECL tvec4(T const & x, detail::_swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const & v, T const & w)
251  {
252  *this = tvec4<T, P>(x, v(), w);
253  }
254 
255  template <int E0, int E1>
256  GLM_FUNC_DECL tvec4(detail::_swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const & v, T const & z, T const & w)
257  {
258  *this = tvec4<T, P>(v(), z, w);
259  }
260 
261  template <int E0, int E1, int E2>
262  GLM_FUNC_DECL tvec4(detail::_swizzle<3, T, P, tvec3<T, P>, E0, E1, E2, -1> const & v, T const & w)
263  {
264  *this = tvec4<T, P>(v(), w);
265  }
266 
267  template <int E0, int E1, int E2>
268  GLM_FUNC_DECL tvec4(T const & x, detail::_swizzle<3, T, P, tvec3<T, P>, E0, E1, E2, -1> const & v)
269  {
270  *this = tvec4<T, P>(x, v());
271  }
272 # endif// GLM_HAS_ANONYMOUS_UNION && defined(GLM_SWIZZLE)
273 
274  // -- Unary arithmetic operators --
275 
276  GLM_FUNC_DECL tvec4<T, P> & operator=(tvec4<T, P> const & v) GLM_DEFAULT;
277 
278  template <typename U>
279  GLM_FUNC_DECL tvec4<T, P> & operator=(tvec4<U, P> const & v);
280  template <typename U>
281  GLM_FUNC_DECL tvec4<T, P> & operator+=(U scalar);
282  template <typename U>
283  GLM_FUNC_DECL tvec4<T, P> & operator+=(tvec1<U, P> const & v);
284  template <typename U>
285  GLM_FUNC_DECL tvec4<T, P> & operator+=(tvec4<U, P> const & v);
286  template <typename U>
287  GLM_FUNC_DECL tvec4<T, P> & operator-=(U scalar);
288  template <typename U>
289  GLM_FUNC_DECL tvec4<T, P> & operator-=(tvec1<U, P> const & v);
290  template <typename U>
291  GLM_FUNC_DECL tvec4<T, P> & operator-=(tvec4<U, P> const & v);
292  template <typename U>
293  GLM_FUNC_DECL tvec4<T, P> & operator*=(U scalar);
294  template <typename U>
295  GLM_FUNC_DECL tvec4<T, P> & operator*=(tvec1<U, P> const & v);
296  template <typename U>
297  GLM_FUNC_DECL tvec4<T, P> & operator*=(tvec4<U, P> const & v);
298  template <typename U>
299  GLM_FUNC_DECL tvec4<T, P> & operator/=(U scalar);
300  template <typename U>
301  GLM_FUNC_DECL tvec4<T, P> & operator/=(tvec1<U, P> const & v);
302  template <typename U>
303  GLM_FUNC_DECL tvec4<T, P> & operator/=(tvec4<U, P> const & v);
304 
305  // -- Increment and decrement operators --
306 
307  GLM_FUNC_DECL tvec4<T, P> & operator++();
308  GLM_FUNC_DECL tvec4<T, P> & operator--();
309  GLM_FUNC_DECL tvec4<T, P> operator++(int);
310  GLM_FUNC_DECL tvec4<T, P> operator--(int);
311 
312  // -- Unary bit operators --
313 
314  template <typename U>
315  GLM_FUNC_DECL tvec4<T, P> & operator%=(U scalar);
316  template <typename U>
317  GLM_FUNC_DECL tvec4<T, P> & operator%=(tvec1<U, P> const & v);
318  template <typename U>
319  GLM_FUNC_DECL tvec4<T, P> & operator%=(tvec4<U, P> const & v);
320  template <typename U>
321  GLM_FUNC_DECL tvec4<T, P> & operator&=(U scalar);
322  template <typename U>
323  GLM_FUNC_DECL tvec4<T, P> & operator&=(tvec1<U, P> const & v);
324  template <typename U>
325  GLM_FUNC_DECL tvec4<T, P> & operator&=(tvec4<U, P> const & v);
326  template <typename U>
327  GLM_FUNC_DECL tvec4<T, P> & operator|=(U scalar);
328  template <typename U>
329  GLM_FUNC_DECL tvec4<T, P> & operator|=(tvec1<U, P> const & v);
330  template <typename U>
331  GLM_FUNC_DECL tvec4<T, P> & operator|=(tvec4<U, P> const & v);
332  template <typename U>
333  GLM_FUNC_DECL tvec4<T, P> & operator^=(U scalar);
334  template <typename U>
335  GLM_FUNC_DECL tvec4<T, P> & operator^=(tvec1<U, P> const & v);
336  template <typename U>
337  GLM_FUNC_DECL tvec4<T, P> & operator^=(tvec4<U, P> const & v);
338  template <typename U>
339  GLM_FUNC_DECL tvec4<T, P> & operator<<=(U scalar);
340  template <typename U>
341  GLM_FUNC_DECL tvec4<T, P> & operator<<=(tvec1<U, P> const & v);
342  template <typename U>
343  GLM_FUNC_DECL tvec4<T, P> & operator<<=(tvec4<U, P> const & v);
344  template <typename U>
345  GLM_FUNC_DECL tvec4<T, P> & operator>>=(U scalar);
346  template <typename U>
347  GLM_FUNC_DECL tvec4<T, P> & operator>>=(tvec1<U, P> const & v);
348  template <typename U>
349  GLM_FUNC_DECL tvec4<T, P> & operator>>=(tvec4<U, P> const & v);
350  };
351 
352  // -- Unary operators --
353 
354  template <typename T, precision P>
355  GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> const & v);
356 
357  // -- Binary operators --
358 
359  template <typename T, precision P>
360  GLM_FUNC_DECL tvec4<T, P> operator+(tvec4<T, P> const & v, T scalar);
361 
362  template <typename T, precision P>
363  GLM_FUNC_DECL tvec4<T, P> operator+(tvec4<T, P> const & v, tvec1<T, P> const & s);
364 
365  template <typename T, precision P>
366  GLM_FUNC_DECL tvec4<T, P> operator+(T scalar, tvec4<T, P> const & v);
367 
368  template <typename T, precision P>
369  GLM_FUNC_DECL tvec4<T, P> operator+(tvec1<T, P> const & s, tvec4<T, P> const & v);
370 
371  template <typename T, precision P>
372  GLM_FUNC_DECL tvec4<T, P> operator+(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
373 
374  template <typename T, precision P>
375  GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> const & v, T scalar);
376 
377  template <typename T, precision P>
378  GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> const & v, tvec1<T, P> const & s);
379 
380  template <typename T, precision P>
381  GLM_FUNC_DECL tvec4<T, P> operator-(T scalar, tvec4<T, P> const & v);
382 
383  template <typename T, precision P>
384  GLM_FUNC_DECL tvec4<T, P> operator-(tvec1<T, P> const & s, tvec4<T, P> const & v);
385 
386  template <typename T, precision P>
387  GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
388 
389  template <typename T, precision P>
390  GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> const & v, T scalar);
391 
392  template <typename T, precision P>
393  GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> const & v, tvec1<T, P> const & s);
394 
395  template <typename T, precision P>
396  GLM_FUNC_DECL tvec4<T, P> operator*(T scalar, tvec4<T, P> const & v);
397 
398  template <typename T, precision P>
399  GLM_FUNC_DECL tvec4<T, P> operator*(tvec1<T, P> const & s, tvec4<T, P> const & v);
400 
401  template <typename T, precision P>
402  GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
403 
404  template <typename T, precision P>
405  GLM_FUNC_DECL tvec4<T, P> operator/(tvec4<T, P> const & v, T scalar);
406 
407  template <typename T, precision P>
408  GLM_FUNC_DECL tvec4<T, P> operator/(tvec4<T, P> const & v, tvec1<T, P> const & s);
409 
410  template <typename T, precision P>
411  GLM_FUNC_DECL tvec4<T, P> operator/(T scalar, tvec4<T, P> const & v);
412 
413  template <typename T, precision P>
414  GLM_FUNC_DECL tvec4<T, P> operator/(tvec1<T, P> const & s, tvec4<T, P> const & v);
415 
416  template <typename T, precision P>
417  GLM_FUNC_DECL tvec4<T, P> operator/(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
418 
419  template <typename T, precision P>
420  GLM_FUNC_DECL bool operator==(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
421 
422  template <typename T, precision P>
423  GLM_FUNC_DECL bool operator!=(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
424 
425  template <typename T, precision P>
426  GLM_FUNC_DECL tvec4<T, P> operator%(tvec4<T, P> const & v, T scalar);
427 
428  template <typename T, precision P>
429  GLM_FUNC_DECL tvec4<T, P> operator%(tvec4<T, P> const & v, tvec1<T, P> const & s);
430 
431  template <typename T, precision P>
432  GLM_FUNC_DECL tvec4<T, P> operator%(T scalar, tvec4<T, P> const & v);
433 
434  template <typename T, precision P>
435  GLM_FUNC_DECL tvec4<T, P> operator%(tvec1<T, P> const & s, tvec4<T, P> const & v);
436 
437  template <typename T, precision P>
438  GLM_FUNC_DECL tvec4<T, P> operator%(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
439 
440  template <typename T, precision P>
441  GLM_FUNC_DECL tvec4<T, P> operator&(tvec4<T, P> const & v, T scalar);
442 
443  template <typename T, precision P>
444  GLM_FUNC_DECL tvec4<T, P> operator&(tvec4<T, P> const & v, tvec1<T, P> const & s);
445 
446  template <typename T, precision P>
447  GLM_FUNC_DECL tvec4<T, P> operator&(T scalar, tvec4<T, P> const & v);
448 
449  template <typename T, precision P>
450  GLM_FUNC_DECL tvec4<T, P> operator&(tvec1<T, P> const & s, tvec4<T, P> const & v);
451 
452  template <typename T, precision P>
453  GLM_FUNC_DECL tvec4<T, P> operator&(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
454 
455  template <typename T, precision P>
456  GLM_FUNC_DECL tvec4<T, P> operator|(tvec4<T, P> const & v, T scalar);
457 
458  template <typename T, precision P>
459  GLM_FUNC_DECL tvec4<T, P> operator|(tvec4<T, P> const & v, tvec1<T, P> const & s);
460 
461  template <typename T, precision P>
462  GLM_FUNC_DECL tvec4<T, P> operator|(T scalar, tvec4<T, P> const & v);
463 
464  template <typename T, precision P>
465  GLM_FUNC_DECL tvec4<T, P> operator|(tvec1<T, P> const & s, tvec4<T, P> const & v);
466 
467  template <typename T, precision P>
468  GLM_FUNC_DECL tvec4<T, P> operator|(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
469 
470  template <typename T, precision P>
471  GLM_FUNC_DECL tvec4<T, P> operator^(tvec4<T, P> const & v, T scalar);
472 
473  template <typename T, precision P>
474  GLM_FUNC_DECL tvec4<T, P> operator^(tvec4<T, P> const & v, tvec1<T, P> const & s);
475 
476  template <typename T, precision P>
477  GLM_FUNC_DECL tvec4<T, P> operator^(T scalar, tvec4<T, P> const & v);
478 
479  template <typename T, precision P>
480  GLM_FUNC_DECL tvec4<T, P> operator^(tvec1<T, P> const & s, tvec4<T, P> const & v);
481 
482  template <typename T, precision P>
483  GLM_FUNC_DECL tvec4<T, P> operator^(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
484 
485  template <typename T, precision P>
486  GLM_FUNC_DECL tvec4<T, P> operator<<(tvec4<T, P> const & v, T scalar);
487 
488  template <typename T, precision P>
489  GLM_FUNC_DECL tvec4<T, P> operator<<(tvec4<T, P> const & v, tvec1<T, P> const & s);
490 
491  template <typename T, precision P>
492  GLM_FUNC_DECL tvec4<T, P> operator<<(T scalar, tvec4<T, P> const & v);
493 
494  template <typename T, precision P>
495  GLM_FUNC_DECL tvec4<T, P> operator<<(tvec1<T, P> const & s, tvec4<T, P> const & v);
496 
497  template <typename T, precision P>
498  GLM_FUNC_DECL tvec4<T, P> operator<<(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
499 
500  template <typename T, precision P>
501  GLM_FUNC_DECL tvec4<T, P> operator>>(tvec4<T, P> const & v, T scalar);
502 
503  template <typename T, precision P>
504  GLM_FUNC_DECL tvec4<T, P> operator>>(tvec4<T, P> const & v, tvec1<T, P> const & s);
505 
506  template <typename T, precision P>
507  GLM_FUNC_DECL tvec4<T, P> operator>>(T scalar, tvec4<T, P> const & v);
508 
509  template <typename T, precision P>
510  GLM_FUNC_DECL tvec4<T, P> operator>>(tvec1<T, P> const & s, tvec4<T, P> const & v);
511 
512  template <typename T, precision P>
513  GLM_FUNC_DECL tvec4<T, P> operator>>(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
514 
515  template <typename T, precision P>
516  GLM_FUNC_DECL tvec4<T, P> operator~(tvec4<T, P> const & v);
517 
518  // -- Boolean operators --
519 
520  template <typename T, precision P>
521  GLM_FUNC_DECL bool operator==(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
522 
523  template <typename T, precision P>
524  GLM_FUNC_DECL bool operator!=(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
525 }//namespace glm
526 
527 #ifndef GLM_EXTERNAL_TEMPLATE
528 #include "type_vec4.inl"
529 #endif//GLM_EXTERNAL_TEMPLATE
glm::length
GLM_FUNC_DECL T length(vecType< T, P > const &x)
Returns the length of x, i.e., sqrt(x * x).
glm
Definition: _noise.hpp:40
_swizzle_func.hpp
OpenGL Mathematics (glm.g-truc.net)
setup.hpp
OpenGL Mathematics (glm.g-truc.net)
type_vec.hpp
OpenGL Mathematics (glm.g-truc.net)
_swizzle.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00137.html000066400000000000000000000200461356361734700216470ustar00rootroot00000000000000 0.9.7: ulp.hpp File Reference
Functions
ulp.hpp File Reference

Go to the source code of this file.

Functions

template<typename T >
GLM_FUNC_DECL uint float_distance (T const &x, T const &y)
 
template<typename T , template< typename > class vecType>
GLM_FUNC_DECL vecType< uint > float_distance (vecType< T > const &x, vecType< T > const &y)
 
template<typename genType >
GLM_FUNC_DECL genType next_float (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL genType next_float (genType const &x, uint const &Distance)
 
template<typename genType >
GLM_FUNC_DECL genType prev_float (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL genType prev_float (genType const &x, uint const &Distance)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTC_ulp

Date
2011-02-21 / 2011-12-12
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file ulp.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00137_source.html000066400000000000000000000241701356361734700232310ustar00rootroot00000000000000 0.9.7: ulp.hpp Source File
ulp.hpp
Go to the documentation of this file.
1 
43 #pragma once
44 
45 // Dependencies
46 #include "../detail/setup.hpp"
47 #include "../detail/precision.hpp"
48 #include "../detail/type_int.hpp"
49 
50 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
51 # pragma message("GLM: GLM_GTC_ulp extension included")
52 #endif
53 
54 namespace glm
55 {
58 
61  template <typename genType>
62  GLM_FUNC_DECL genType next_float(genType const & x);
63 
66  template <typename genType>
67  GLM_FUNC_DECL genType prev_float(genType const & x);
68 
71  template <typename genType>
72  GLM_FUNC_DECL genType next_float(genType const & x, uint const & Distance);
73 
76  template <typename genType>
77  GLM_FUNC_DECL genType prev_float(genType const & x, uint const & Distance);
78 
81  template <typename T>
82  GLM_FUNC_DECL uint float_distance(T const & x, T const & y);
83 
86  template<typename T, template<typename> class vecType>
87  GLM_FUNC_DECL vecType<uint> float_distance(vecType<T> const & x, vecType<T> const & y);
88 
90 }// namespace glm
91 
92 #include "ulp.inl"
glm::float_distance
GLM_FUNC_DECL vecType< uint > float_distance(vecType< T > const &x, vecType< T > const &y)
Return the distance in the number of ULP between 2 vectors.
glm::prev_float
GLM_FUNC_DECL genType prev_float(genType const &x, uint const &Distance)
Return the value(s) ULP distance before the input value(s).
glm::uint
unsigned int uint
Unsigned integer type.
Definition: type_int.hpp:308
glm
Definition: _noise.hpp:40
glm::next_float
GLM_FUNC_DECL genType next_float(genType const &x, uint const &Distance)
Return the value(s) ULP distance after the input value(s).
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00138.html000066400000000000000000000235741356361734700216610ustar00rootroot00000000000000 0.9.7: vec1.hpp File Reference
Typedefs
vec1.hpp File Reference

Go to the source code of this file.

Typedefs

typedef highp_bvec1 bvec1
 
typedef highp_dvec1 dvec1
 
typedef highp_bvec1_t highp_bvec1
 
typedef highp_dvec1_t highp_dvec1
 
typedef highp_ivec1_t highp_ivec1
 
typedef highp_uvec1_t highp_uvec1
 
typedef highp_ivec1 ivec1
 
typedef lowp_bvec1_t lowp_bvec1
 
typedef lowp_dvec1_t lowp_dvec1
 
typedef lowp_ivec1_t lowp_ivec1
 
typedef lowp_uvec1_t lowp_uvec1
 
typedef mediump_bvec1_t mediump_bvec1
 
typedef mediump_dvec1_t mediump_dvec1
 
typedef mediump_ivec1_t mediump_ivec1
 
typedef mediump_uvec1_t mediump_uvec1
 
typedef highp_uvec1 uvec1
 
typedef highp_vec1 vec1
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTC_vec1

Date
2010-02-08 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file vec1.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00138_source.html000066400000000000000000000402401356361734700232260ustar00rootroot00000000000000 0.9.7: vec1.hpp Source File
vec1.hpp
Go to the documentation of this file.
1 
41 #pragma once
42 
43 // Dependency:
44 #include "../glm.hpp"
45 #include "../detail/type_vec1.hpp"
46 
47 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
48 # pragma message("GLM: GLM_GTC_vec1 extension included")
49 #endif
50 
51 namespace glm
52 {
56  typedef highp_vec1_t highp_vec1;
57 
61  typedef mediump_vec1_t mediump_vec1;
62 
66  typedef lowp_vec1_t lowp_vec1;
67 
71  typedef highp_dvec1_t highp_dvec1;
72 
76  typedef mediump_dvec1_t mediump_dvec1;
77 
81  typedef lowp_dvec1_t lowp_dvec1;
82 
86  typedef highp_ivec1_t highp_ivec1;
87 
91  typedef mediump_ivec1_t mediump_ivec1;
92 
96  typedef lowp_ivec1_t lowp_ivec1;
97 
101  typedef highp_uvec1_t highp_uvec1;
102 
106  typedef mediump_uvec1_t mediump_uvec1;
107 
111  typedef lowp_uvec1_t lowp_uvec1;
112 
116  typedef highp_bvec1_t highp_bvec1;
117 
121  typedef mediump_bvec1_t mediump_bvec1;
122 
126  typedef lowp_bvec1_t lowp_bvec1;
127 
129  // vec1 definition
130 
131 #if(defined(GLM_PRECISION_HIGHP_BOOL))
132  typedef highp_bvec1 bvec1;
133 #elif(defined(GLM_PRECISION_MEDIUMP_BOOL))
134  typedef mediump_bvec1 bvec1;
135 #elif(defined(GLM_PRECISION_LOWP_BOOL))
136  typedef lowp_bvec1 bvec1;
137 #else
138  typedef highp_bvec1 bvec1;
141 #endif//GLM_PRECISION
142 
143 #if(defined(GLM_PRECISION_HIGHP_FLOAT))
144  typedef highp_vec1 vec1;
145 #elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
146  typedef mediump_vec1 vec1;
147 #elif(defined(GLM_PRECISION_LOWP_FLOAT))
148  typedef lowp_vec1 vec1;
149 #else
150  typedef highp_vec1 vec1;
153 #endif//GLM_PRECISION
154 
155 #if(defined(GLM_PRECISION_HIGHP_DOUBLE))
156  typedef highp_dvec1 dvec1;
157 #elif(defined(GLM_PRECISION_MEDIUMP_DOUBLE))
158  typedef mediump_dvec1 dvec1;
159 #elif(defined(GLM_PRECISION_LOWP_DOUBLE))
160  typedef lowp_dvec1 dvec1;
161 #else
162  typedef highp_dvec1 dvec1;
165 #endif//GLM_PRECISION
166 
167 #if(defined(GLM_PRECISION_HIGHP_INT))
168  typedef highp_ivec1 ivec1;
169 #elif(defined(GLM_PRECISION_MEDIUMP_INT))
170  typedef mediump_ivec1 ivec1;
171 #elif(defined(GLM_PRECISION_LOWP_INT))
172  typedef lowp_ivec1 ivec1;
173 #else
174  typedef highp_ivec1 ivec1;
177 #endif//GLM_PRECISION
178 
179 #if(defined(GLM_PRECISION_HIGHP_UINT))
180  typedef highp_uvec1 uvec1;
181 #elif(defined(GLM_PRECISION_MEDIUMP_UINT))
182  typedef mediump_uvec1 uvec1;
183 #elif(defined(GLM_PRECISION_LOWP_UINT))
184  typedef lowp_uvec1 uvec1;
185 #else
186  typedef highp_uvec1 uvec1;
189 #endif//GLM_PRECISION
190 
191 }// namespace glm
192 
193 #include "vec1.inl"
glm
Definition: _noise.hpp:40
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00139.html000066400000000000000000000101601356361734700216450ustar00rootroot00000000000000 0.9.7: vec2.hpp File Reference
vec2.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-12-24 / 2013-12-24
Author
Christophe Riccio

Definition in file vec2.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00139_source.html000066400000000000000000000062411356361734700232320ustar00rootroot00000000000000 0.9.7: vec2.hpp Source File
vec2.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "detail/type_vec2.hpp"
type_vec2.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00140.html000066400000000000000000000101601356361734700216350ustar00rootroot00000000000000 0.9.7: vec3.hpp File Reference
vec3.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-12-24 / 2013-12-24
Author
Christophe Riccio

Definition in file vec3.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00140_source.html000066400000000000000000000062411356361734700232220ustar00rootroot00000000000000 0.9.7: vec3.hpp Source File
vec3.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "detail/type_vec3.hpp"
type_vec3.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00141.html000066400000000000000000000101601356361734700216360ustar00rootroot00000000000000 0.9.7: vec4.hpp File Reference
vec4.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-12-24 / 2013-12-24
Author
Christophe Riccio

Definition in file vec4.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00141_source.html000066400000000000000000000062411356361734700232230ustar00rootroot00000000000000 0.9.7: vec4.hpp Source File
vec4.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "detail/type_vec4.hpp"
type_vec4.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00142.html000066400000000000000000000151711356361734700216460ustar00rootroot00000000000000 0.9.7: vector_angle.hpp File Reference
Functions
vector_angle.hpp File Reference

Go to the source code of this file.

Functions

template<typename vecType >
GLM_FUNC_DECL vecType::value_type angle (vecType const &x, vecType const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL T orientedAngle (tvec2< T, P > const &x, tvec2< T, P > const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL T orientedAngle (tvec3< T, P > const &x, tvec3< T, P > const &y, tvec3< T, P > const &ref)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_vector_angle

Date
2005-12-30 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)
GLM_GTX_quaternion (dependence)
gtx_epsilon (dependence)

Definition in file vector_angle.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00142_source.html000066400000000000000000000210321356361734700232170ustar00rootroot00000000000000 0.9.7: vector_angle.hpp Source File
vector_angle.hpp
Go to the documentation of this file.
1 
44 #pragma once
45 
46 // Dependency:
47 #include "../glm.hpp"
48 #include "../gtc/epsilon.hpp"
49 #include "../gtx/quaternion.hpp"
50 #include "../gtx/rotate_vector.hpp"
51 
52 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
53 # pragma message("GLM: GLM_GTX_vector_angle extension included")
54 #endif
55 
56 namespace glm
57 {
60 
64  template <typename vecType>
65  GLM_FUNC_DECL typename vecType::value_type angle(
66  vecType const & x,
67  vecType const & y);
68 
72  template <typename T, precision P>
73  GLM_FUNC_DECL T orientedAngle(
74  tvec2<T, P> const & x,
75  tvec2<T, P> const & y);
76 
80  template <typename T, precision P>
81  GLM_FUNC_DECL T orientedAngle(
82  tvec3<T, P> const & x,
83  tvec3<T, P> const & y,
84  tvec3<T, P> const & ref);
85 
87 }// namespace glm
88 
89 #include "vector_angle.inl"
glm::angle
GLM_FUNC_DECL vecType::value_type angle(vecType const &x, vecType const &y)
Returns the absolute angle between two vectors Parameters need to be normalized.
glm
Definition: _noise.hpp:40
glm::orientedAngle
GLM_FUNC_DECL T orientedAngle(tvec3< T, P > const &x, tvec3< T, P > const &y, tvec3< T, P > const &ref)
Returns the oriented angle between two 3d vectors based from a reference axis.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00143.html000066400000000000000000000211521356361734700216430ustar00rootroot00000000000000 0.9.7: vector_query.hpp File Reference
Functions
vector_query.hpp File Reference

Go to the source code of this file.

Functions

template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL bool areCollinear (vecType< T, P > const &v0, vecType< T, P > const &v1, T const &epsilon)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL bool areOrthogonal (vecType< T, P > const &v0, vecType< T, P > const &v1, T const &epsilon)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL bool areOrthonormal (vecType< T, P > const &v0, vecType< T, P > const &v1, T const &epsilon)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > isCompNull (vecType< T, P > const &v, T const &epsilon)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL bool isNormalized (vecType< T, P > const &v, T const &epsilon)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL bool isNull (vecType< T, P > const &v, T const &epsilon)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_vector_query

Date
2008-03-10 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file vector_query.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00143_source.html000066400000000000000000000312341356361734700232250ustar00rootroot00000000000000 0.9.7: vector_query.hpp Source File
vector_query.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../glm.hpp"
46 #include <cfloat>
47 #include <limits>
48 
49 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
50 # pragma message("GLM: GLM_GTX_vector_query extension included")
51 #endif
52 
53 namespace glm
54 {
57 
60  template <typename T, precision P, template <typename, precision> class vecType>
61  GLM_FUNC_DECL bool areCollinear(vecType<T, P> const & v0, vecType<T, P> const & v1, T const & epsilon);
62 
65  template <typename T, precision P, template <typename, precision> class vecType>
66  GLM_FUNC_DECL bool areOrthogonal(vecType<T, P> const & v0, vecType<T, P> const & v1, T const & epsilon);
67 
70  template <typename T, precision P, template <typename, precision> class vecType>
71  GLM_FUNC_DECL bool isNormalized(vecType<T, P> const & v, T const & epsilon);
72 
75  template <typename T, precision P, template <typename, precision> class vecType>
76  GLM_FUNC_DECL bool isNull(vecType<T, P> const & v, T const & epsilon);
77 
80  template <typename T, precision P, template <typename, precision> class vecType>
81  GLM_FUNC_DECL vecType<bool, P> isCompNull(vecType<T, P> const & v, T const & epsilon);
82 
85  template <typename T, precision P, template <typename, precision> class vecType>
86  GLM_FUNC_DECL bool areOrthonormal(vecType<T, P> const & v0, vecType<T, P> const & v1, T const & epsilon);
87 
89 }// namespace glm
90 
91 #include "vector_query.inl"
glm::isNormalized
GLM_FUNC_DECL bool isNormalized(vecType< T, P > const &v, T const &epsilon)
Check whether a vector is normalized.
glm::epsilon
GLM_FUNC_DECL genType epsilon()
Return the epsilon constant for floating point types.
glm
Definition: _noise.hpp:40
glm::isCompNull
GLM_FUNC_DECL vecType< bool, P > isCompNull(vecType< T, P > const &v, T const &epsilon)
Check whether a each component of a vector is null.
glm::areOrthogonal
GLM_FUNC_DECL bool areOrthogonal(vecType< T, P > const &v0, vecType< T, P > const &v1, T const &epsilon)
Check whether two vectors are orthogonals.
glm::isNull
GLM_FUNC_DECL bool isNull(vecType< T, P > const &v, T const &epsilon)
Check whether a vector is null.
glm::areOrthonormal
GLM_FUNC_DECL bool areOrthonormal(vecType< T, P > const &v0, vecType< T, P > const &v1, T const &epsilon)
Check whether two vectors are orthonormal.
glm::areCollinear
GLM_FUNC_DECL bool areCollinear(vecType< T, P > const &v0, vecType< T, P > const &v1, T const &epsilon)
Check whether two vectors are collinears.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00144.html000066400000000000000000000102271356361734700216450ustar00rootroot00000000000000 0.9.7: vector_relational.hpp File Reference
vector_relational.hpp File Reference

Go to the source code of this file.

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM Core

Date
2013-12-24 / 2013-12-24
Author
Christophe Riccio

Definition in file vector_relational.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00144_source.html000066400000000000000000000063251356361734700232310ustar00rootroot00000000000000 0.9.7: vector_relational.hpp Source File
vector_relational.hpp
Go to the documentation of this file.
1 
33 #pragma once
34 
35 #include "detail/func_vector_relational.hpp"
func_vector_relational.hpp
OpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00145.html000066400000000000000000000155171356361734700216550ustar00rootroot00000000000000 0.9.7: wrap.hpp File Reference
Functions
wrap.hpp File Reference

Go to the source code of this file.

Functions

template<typename genType >
GLM_FUNC_DECL genType clamp (genType const &Texcoord)
 
template<typename genType >
GLM_FUNC_DECL genType mirrorClamp (genType const &Texcoord)
 
template<typename genType >
GLM_FUNC_DECL genType mirrorRepeat (genType const &Texcoord)
 
template<typename genType >
GLM_FUNC_DECL genType repeat (genType const &Texcoord)
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTX_wrap

Date
2009-11-25 / 2011-06-07
Author
Christophe Riccio
See also
GLM Core (dependence)

Definition in file wrap.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00145_source.html000066400000000000000000000200401356361734700232200ustar00rootroot00000000000000 0.9.7: wrap.hpp Source File
wrap.hpp
Go to the documentation of this file.
1 
42 #pragma once
43 
44 // Dependency:
45 #include "../glm.hpp"
46 
47 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
48 # pragma message("GLM: GLM_GTX_wrap extension included")
49 #endif
50 
51 namespace glm
52 {
55 
58  template <typename genType>
59  GLM_FUNC_DECL genType clamp(genType const & Texcoord);
60 
63  template <typename genType>
64  GLM_FUNC_DECL genType repeat(genType const & Texcoord);
65 
68  template <typename genType>
69  GLM_FUNC_DECL genType mirrorClamp(genType const & Texcoord);
70 
73  template <typename genType>
74  GLM_FUNC_DECL genType mirrorRepeat(genType const & Texcoord);
75 
77 }// namespace glm
78 
79 #include "wrap.inl"
glm::repeat
GLM_FUNC_DECL genType repeat(genType const &Texcoord)
Simulate GL_REPEAT OpenGL wrap mode.
glm::mirrorClamp
GLM_FUNC_DECL genType mirrorClamp(genType const &Texcoord)
Simulate GL_MIRRORED_REPEAT OpenGL wrap mode.
glm
Definition: _noise.hpp:40
glm::clamp
GLM_FUNC_DECL genType clamp(genType const &Texcoord)
Simulate GL_CLAMP OpenGL wrap mode.
glm::mirrorRepeat
GLM_FUNC_DECL genType mirrorRepeat(genType const &Texcoord)
Simulate GL_MIRROR_REPEAT OpenGL wrap mode.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00151.html000066400000000000000000001670021356361734700216470ustar00rootroot00000000000000 0.9.7: Common functions
Functions
Common functions
GLM Core

Functions

template<typename genType >
GLM_FUNC_DECL genType abs (genType x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > ceil (vecType< T, P > const &x)
 
template<typename genType >
GLM_FUNC_DECL genType clamp (genType x, genType minVal, genType maxVal)
 
GLM_FUNC_DECL int floatBitsToInt (float const &v)
 
template<template< typename, precision > class vecType, precision P>
GLM_FUNC_DECL vecType< int, P > floatBitsToInt (vecType< float, P > const &v)
 
GLM_FUNC_DECL uint floatBitsToUint (float const &v)
 
template<template< typename, precision > class vecType, precision P>
GLM_FUNC_DECL vecType< uint, P > floatBitsToUint (vecType< float, P > const &v)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > floor (vecType< T, P > const &x)
 
template<typename genType >
GLM_FUNC_DECL genType fma (genType const &a, genType const &b, genType const &c)
 
template<typename genType >
GLM_FUNC_DECL genType fract (genType x)
 
template<typename genType , typename genIType >
GLM_FUNC_DECL genType frexp (genType const &x, genIType &exp)
 
GLM_FUNC_DECL float intBitsToFloat (int const &v)
 
template<template< typename, precision > class vecType, precision P>
GLM_FUNC_DECL vecType< float, P > intBitsToFloat (vecType< int, P > const &v)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > isinf (vecType< T, P > const &x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > isnan (vecType< T, P > const &x)
 
template<typename genType , typename genIType >
GLM_FUNC_DECL genType ldexp (genType const &x, genIType const &exp)
 
template<typename genType >
GLM_FUNC_DECL genType max (genType x, genType y)
 
template<typename genType >
GLM_FUNC_DECL genType min (genType x, genType y)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > mix (vecType< T, P > const &x, vecType< T, P > const &y, vecType< U, P > const &a)
 
template<typename genType >
GLM_FUNC_DECL genType mod (genType x, genType y)
 
template<typename genType >
GLM_FUNC_DECL genType modf (genType x, genType &i)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > round (vecType< T, P > const &x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > roundEven (vecType< T, P > const &x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > sign (vecType< T, P > const &x)
 
template<typename genType >
GLM_FUNC_DECL genType smoothstep (genType edge0, genType edge1, genType x)
 
template<typename genType >
GLM_FUNC_DECL genType step (genType edge, genType x)
 
template<template< typename, precision > class vecType, typename T , precision P>
GLM_FUNC_DECL vecType< T, P > step (T edge, vecType< T, P > const &x)
 
template<template< typename, precision > class vecType, typename T , precision P>
GLM_FUNC_DECL vecType< T, P > step (vecType< T, P > const &edge, vecType< T, P > const &x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > trunc (vecType< T, P > const &x)
 
GLM_FUNC_DECL float uintBitsToFloat (uint const &v)
 
template<template< typename, precision > class vecType, precision P>
GLM_FUNC_DECL vecType< float, P > uintBitsToFloat (vecType< uint, P > const &v)
 

Detailed Description

These all operate component-wise.

The description is per component.

Function Documentation

GLM_FUNC_DECL genType glm::abs ( genType  x)

Returns x if x >= 0; otherwise, it returns -x.

Template Parameters
genTypefloating-point or signed integer; scalar or vector types.
See also
GLSL abs man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL vecType<T, P> glm::ceil ( vecType< T, P > const &  x)

Returns a value equal to the nearest integer that is greater than or equal to x.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL ceil man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL genType glm::clamp ( genType  x,
genType  minVal,
genType  maxVal 
)

Returns min(max(x, minVal), maxVal) for each component in x using the floating-point values minVal and maxVal.

Template Parameters
genTypeFloating-point or integer; scalar or vector types.
See also
GLSL clamp man page
GLSL 4.20.8 specification, section 8.3 Common Functions

Referenced by glm::saturate().

GLM_FUNC_DECL int glm::floatBitsToInt ( float const &  v)

Returns a signed integer value representing the encoding of a floating-point value.

The floating-point value's bit-level representation is preserved.

See also
GLSL floatBitsToInt man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL vecType<int, P> glm::floatBitsToInt ( vecType< float, P > const &  v)

Returns a signed integer value representing the encoding of a floating-point value.

The floatingpoint value's bit-level representation is preserved.

See also
GLSL floatBitsToInt man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL uint glm::floatBitsToUint ( float const &  v)

Returns a unsigned integer value representing the encoding of a floating-point value.

The floatingpoint value's bit-level representation is preserved.

See also
GLSL floatBitsToUint man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL vecType<uint, P> glm::floatBitsToUint ( vecType< float, P > const &  v)

Returns a unsigned integer value representing the encoding of a floating-point value.

The floatingpoint value's bit-level representation is preserved.

See also
GLSL floatBitsToUint man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL vecType<T, P> glm::floor ( vecType< T, P > const &  x)

Returns a value equal to the nearest integer that is less then or equal to x.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL floor man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL genType glm::fma ( genType const &  a,
genType const &  b,
genType const &  c 
)

Computes and returns a * b + c.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL fma man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL genType glm::fract ( genType  x)

Return x - floor(x).

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL fract man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL genType glm::frexp ( genType const &  x,
genIType &  exp 
)

Splits x into a floating-point significand in the range [0.5, 1.0) and an integral exponent of two, such that: x = significand * exp(2, exponent)

The significand is returned by the function and the exponent is returned in the parameter exp. For a floating-point value of zero, the significant and exponent are both zero. For a floating-point value that is an infinity or is not a number, the results are undefined.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL frexp man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL float glm::intBitsToFloat ( int const &  v)

Returns a floating-point value corresponding to a signed integer encoding of a floating-point value.

If an inf or NaN is passed in, it will not signal, and the resulting floating point value is unspecified. Otherwise, the bit-level representation is preserved.

See also
GLSL intBitsToFloat man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL vecType<float, P> glm::intBitsToFloat ( vecType< int, P > const &  v)

Returns a floating-point value corresponding to a signed integer encoding of a floating-point value.

If an inf or NaN is passed in, it will not signal, and the resulting floating point value is unspecified. Otherwise, the bit-level representation is preserved.

See also
GLSL intBitsToFloat man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL vecType<bool, P> glm::isinf ( vecType< T, P > const &  x)

Returns true if x holds a positive infinity or negative infinity representation in the underlying implementation's set of floating point representations.

Returns false otherwise, including for implementations with no infinity representations.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL isinf man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL vecType<bool, P> glm::isnan ( vecType< T, P > const &  x)

Returns true if x holds a NaN (not a number) representation in the underlying implementation's set of floating point representations.

Returns false otherwise, including for implementations with no NaN representations.

/!\ When using compiler fast math, this function may fail.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL isnan man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL genType glm::ldexp ( genType const &  x,
genIType const &  exp 
)

Builds a floating-point number from x and the corresponding integral exponent of two in exp, returning: significand * exp(2, exponent)

If this product is too large to be represented in the floating-point type, the result is undefined.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL ldexp man page;
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL genType glm::max ( genType  x,
genType  y 
)

Returns y if x < y; otherwise, it returns x.

Template Parameters
genTypeFloating-point or integer; scalar or vector types.
See also
GLSL max man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL genType glm::min ( genType  x,
genType  y 
)

Returns y if y < x; otherwise, it returns x.

Template Parameters
genTypeFloating-point or integer; scalar or vector types.
See also
GLSL min man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL vecType<T, P> glm::mix ( vecType< T, P > const &  x,
vecType< T, P > const &  y,
vecType< U, P > const &  a 
)

If genTypeU is a floating scalar or vector: Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a.

The value for a is not restricted to the range [0, 1].

If genTypeU is a boolean scalar or vector: Selects which vector each returned component comes from. For a component of that is false, the corresponding component of x is returned. For a component of a that is true, the corresponding component of y is returned. Components of x and y that are not selected are allowed to be invalid floating point values and will have no effect on the results. Thus, this provides different functionality than genType mix(genType x, genType y, genType(a)) where a is a Boolean vector.

See also
GLSL mix man page
GLSL 4.20.8 specification, section 8.3 Common Functions
Parameters
[in]xValue to interpolate.
[in]yValue to interpolate.
[in]aInterpolant.
Template Parameters
genTypeTFloating point scalar or vector.
genTypeUFloating point or boolean scalar or vector. It can't be a vector if it is the length of genTypeT.
#include <glm/glm.hpp>
...
float a;
bool b;
glm::dvec3 e;
glm::dvec3 f;
glm::vec4 g;
glm::vec4 h;
...
glm::vec4 r = glm::mix(g, h, a); // Interpolate with a floating-point scalar two vectors.
glm::vec4 s = glm::mix(g, h, b); // Teturns g or h;
glm::dvec3 t = glm::mix(e, f, a); // Types of the third parameter is not required to match with the first and the second.
glm::vec4 u = glm::mix(g, h, r); // Interpolations can be perform per component with a vector for the last parameter.

Referenced by glm::lerp().

GLM_FUNC_DECL genType glm::mod ( genType  x,
genType  y 
)

Modulus.

Returns x - y * floor(x / y) for each component in x using the floating point value y.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL mod man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL genType glm::modf ( genType  x,
genType &  i 
)

Returns the fractional part of x and sets i to the integer part (as a whole number floating point value).

Both the return value and the output parameter will have the same sign as x.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL modf man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL vecType<T, P> glm::round ( vecType< T, P > const &  x)

Returns a value equal to the nearest integer to x.

The fraction 0.5 will round in a direction chosen by the implementation, presumably the direction that is fastest. This includes the possibility that round(x) returns the same value as roundEven(x) for all values of x.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL round man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL vecType<T, P> glm::roundEven ( vecType< T, P > const &  x)

Returns a value equal to the nearest integer to x.

A fractional part of 0.5 will round toward the nearest even integer. (Both 3.5 and 4.5 for x will return 4.0.)

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL roundEven man page
GLSL 4.20.8 specification, section 8.3 Common Functions
New round to even technique
GLM_FUNC_DECL vecType<T, P> glm::sign ( vecType< T, P > const &  x)

Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0.

Template Parameters
genTypeFloating-point or signed integer; scalar or vector types.
See also
GLSL sign man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL genType glm::smoothstep ( genType  edge0,
genType  edge1,
genType  x 
)

Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and performs smooth Hermite interpolation between 0 and 1 when edge0 < x < edge1.

This is useful in cases where you would want a threshold function with a smooth transition. This is equivalent to: genType t; t = clamp ((x - edge0) / (edge1 - edge0), 0, 1); return t * t * (3 - 2 * t); Results are undefined if edge0 >= edge1.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL smoothstep man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL genType glm::step ( genType  edge,
genType  x 
)

Returns 0.0 if x < edge, otherwise it returns 1.0 for each component of a genType.

See also
GLSL step man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL vecType<T, P> glm::step ( T  edge,
vecType< T, P > const &  x 
)

Returns 0.0 if x < edge, otherwise it returns 1.0.

See also
GLSL step man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL vecType<T, P> glm::step ( vecType< T, P > const &  edge,
vecType< T, P > const &  x 
)

Returns 0.0 if x < edge, otherwise it returns 1.0.

See also
GLSL step man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL vecType<T, P> glm::trunc ( vecType< T, P > const &  x)

Returns a value equal to the nearest integer to x whose absolute value is not larger than the absolute value of x.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL trunc man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL float glm::uintBitsToFloat ( uint const &  v)

Returns a floating-point value corresponding to a unsigned integer encoding of a floating-point value.

If an inf or NaN is passed in, it will not signal, and the resulting floating point value is unspecified. Otherwise, the bit-level representation is preserved.

See also
GLSL uintBitsToFloat man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL vecType<float, P> glm::uintBitsToFloat ( vecType< uint, P > const &  v)

Returns a floating-point value corresponding to a unsigned integer encoding of a floating-point value.

If an inf or NaN is passed in, it will not signal, and the resulting floating point value is unspecified. Otherwise, the bit-level representation is preserved.

See also
GLSL uintBitsToFloat man page
GLSL 4.20.8 specification, section 8.3 Common Functions
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00152.html000066400000000000000000000377171356361734700216610ustar00rootroot00000000000000 0.9.7: Exponential functions
Functions
Exponential functions
GLM Core

Functions

template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > exp (vecType< T, P > const &v)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > exp2 (vecType< T, P > const &v)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > inversesqrt (vecType< T, P > const &v)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > log (vecType< T, P > const &v)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > log2 (vecType< T, P > const &v)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > pow (vecType< T, P > const &base, vecType< T, P > const &exponent)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > sqrt (vecType< T, P > const &v)
 

Detailed Description

These all operate component-wise.

The description is per component.

Function Documentation

GLM_FUNC_DECL vecType<T, P> glm::exp ( vecType< T, P > const &  v)

Returns the natural exponentiation of x, i.e., e^x.

Parameters
vexp function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type precision.
Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL exp man page
GLSL 4.20.8 specification, section 8.2 Exponential Functions
GLM_FUNC_DECL vecType<T, P> glm::exp2 ( vecType< T, P > const &  v)

Returns 2 raised to the v power.

Parameters
vexp2 function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type precision.
Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL exp2 man page
GLSL 4.20.8 specification, section 8.2 Exponential Functions
GLM_FUNC_DECL vecType<T, P> glm::inversesqrt ( vecType< T, P > const &  v)

Returns the reciprocal of the positive square root of v.

Parameters
vinversesqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type precision.
Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL inversesqrt man page
GLSL 4.20.8 specification, section 8.2 Exponential Functions
GLM_FUNC_DECL vecType<T, P> glm::log ( vecType< T, P > const &  v)

Returns the natural logarithm of v, i.e., returns the value y which satisfies the equation x = e^y.

Results are undefined if v <= 0.

Parameters
vlog function is defined for input values of v defined in the range (0, inf+) in the limit of the type precision.
Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL log man page
GLSL 4.20.8 specification, section 8.2 Exponential Functions
GLM_FUNC_DECL vecType<T, P> glm::log2 ( vecType< T, P > const &  v)

Returns the base 2 log of x, i.e., returns the value y, which satisfies the equation x = 2 ^ y.

Parameters
vlog2 function is defined for input values of v defined in the range (0, inf+) in the limit of the type precision.
Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL log2 man page
GLSL 4.20.8 specification, section 8.2 Exponential Functions
GLM_FUNC_DECL vecType<T, P> glm::pow ( vecType< T, P > const &  base,
vecType< T, P > const &  exponent 
)

Returns 'base' raised to the power 'exponent'.

Parameters
baseFloating point value. pow function is defined for input values of 'base' defined in the range (inf-, inf+) in the limit of the type precision.
exponentFloating point value representing the 'exponent'.
Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL pow man page
GLSL 4.20.8 specification, section 8.2 Exponential Functions
GLM_FUNC_DECL vecType<T, P> glm::sqrt ( vecType< T, P > const &  v)

Returns the positive square root of v.

Parameters
vsqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type precision.
Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL sqrt man page
GLSL 4.20.8 specification, section 8.2 Exponential Functions
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00153.html000066400000000000000000000424301356361734700216460ustar00rootroot00000000000000 0.9.7: Geometric functions
Functions
Geometric functions
GLM Core

Functions

template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > cross (tvec3< T, P > const &x, tvec3< T, P > const &y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL T distance (vecType< T, P > const &p0, vecType< T, P > const &p1)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL T dot (vecType< T, P > const &x, vecType< T, P > const &y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > faceforward (vecType< T, P > const &N, vecType< T, P > const &I, vecType< T, P > const &Nref)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL T length (vecType< T, P > const &x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > normalize (vecType< T, P > const &x)
 
template<typename genType >
GLM_FUNC_DECL genType reflect (genType const &I, genType const &N)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > refract (vecType< T, P > const &I, vecType< T, P > const &N, T eta)
 

Detailed Description

These operate on vectors as vectors, not component-wise.

Function Documentation

GLM_FUNC_DECL tvec3<T, P> glm::cross ( tvec3< T, P > const &  x,
tvec3< T, P > const &  y 
)

Returns the cross product of x and y.

Template Parameters
valTypeFloating-point scalar types.
See also
GLSL cross man page
GLSL 4.20.8 specification, section 8.5 Geometric Functions
GLM_FUNC_DECL T glm::distance ( vecType< T, P > const &  p0,
vecType< T, P > const &  p1 
)

Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).

Template Parameters
genTypeFloating-point vector types.
See also
GLSL distance man page
GLSL 4.20.8 specification, section 8.5 Geometric Functions
GLM_FUNC_DECL T glm::dot ( vecType< T, P > const &  x,
vecType< T, P > const &  y 
)

Returns the dot product of x and y, i.e., result = x * y.

Template Parameters
genTypeFloating-point vector types.
See also
GLSL dot man page
GLSL 4.20.8 specification, section 8.5 Geometric Functions
GLM_FUNC_DECL vecType<T, P> glm::faceforward ( vecType< T, P > const &  N,
vecType< T, P > const &  I,
vecType< T, P > const &  Nref 
)

If dot(Nref, I) < 0.0, return N, otherwise, return -N.

Template Parameters
genTypeFloating-point vector types.
See also
GLSL faceforward man page
GLSL 4.20.8 specification, section 8.5 Geometric Functions
GLM_FUNC_DECL T glm::length ( vecType< T, P > const &  x)

Returns the length of x, i.e., sqrt(x * x).

Template Parameters
genTypeFloating-point vector types.
See also
GLSL length man page
GLSL 4.20.8 specification, section 8.5 Geometric Functions
GLM_FUNC_DECL vecType<T, P> glm::normalize ( vecType< T, P > const &  x)

Returns a vector in the same direction as x but with length of 1.

According to issue 10 GLSL 1.10 specification, if length(x) == 0 then result is undefined and generate an error.

See also
GLSL normalize man page
GLSL 4.20.8 specification, section 8.5 Geometric Functions
GLM_FUNC_DECL genType glm::reflect ( genType const &  I,
genType const &  N 
)

For the incident vector I and surface orientation N, returns the reflection direction : result = I - 2.0 * dot(N, I) * N.

Template Parameters
genTypeFloating-point vector types.
See also
GLSL reflect man page
GLSL 4.20.8 specification, section 8.5 Geometric Functions
GLM_FUNC_DECL vecType<T, P> glm::refract ( vecType< T, P > const &  I,
vecType< T, P > const &  N,
T  eta 
)

For the incident vector I and surface normal N, and the ratio of indices of refraction eta, return the refraction vector.

Template Parameters
genTypeFloating-point vector types.
See also
GLSL refract man page
GLSL 4.20.8 specification, section 8.5 Geometric Functions
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00154.html000066400000000000000000000741531356361734700216560ustar00rootroot00000000000000 0.9.7: Integer functions
Functions
Integer functions
GLM Core

Functions

template<typename genType >
GLM_FUNC_DECL int bitCount (genType v)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< int, P > bitCount (vecType< T, P > const &v)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > bitfieldExtract (vecType< T, P > const &Value, int Offset, int Bits)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > bitfieldInsert (vecType< T, P > const &Base, vecType< T, P > const &Insert, int Offset, int Bits)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > bitfieldReverse (vecType< T, P > const &v)
 
template<typename genIUType >
GLM_FUNC_DECL int findLSB (genIUType x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< int, P > findLSB (vecType< T, P > const &v)
 
template<typename genIUType >
GLM_FUNC_DECL int findMSB (genIUType x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< int, P > findMSB (vecType< T, P > const &v)
 
template<precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL void imulExtended (vecType< int, P > const &x, vecType< int, P > const &y, vecType< int, P > &msb, vecType< int, P > &lsb)
 
template<precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< uint, P > uaddCarry (vecType< uint, P > const &x, vecType< uint, P > const &y, vecType< uint, P > &carry)
 
template<precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL void umulExtended (vecType< uint, P > const &x, vecType< uint, P > const &y, vecType< uint, P > &msb, vecType< uint, P > &lsb)
 
template<precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< uint, P > usubBorrow (vecType< uint, P > const &x, vecType< uint, P > const &y, vecType< uint, P > &borrow)
 

Detailed Description

These all operate component-wise.

The description is per component. The notation [a, b] means the set of bits from bit-number a through bit-number b, inclusive. The lowest-order bit is bit 0.

Function Documentation

GLM_FUNC_DECL int glm::bitCount ( genType  v)

Returns the number of bits set to 1 in the binary representation of value.

Template Parameters
TSigned or unsigned integer scalar or vector types.
See also
GLSL bitCount man page
GLSL 4.20.8 specification, section 8.8 Integer Functions
GLM_FUNC_DECL vecType<int, P> glm::bitCount ( vecType< T, P > const &  v)

Returns the number of bits set to 1 in the binary representation of value.

Template Parameters
TSigned or unsigned integer scalar or vector types.
See also
GLSL bitCount man page
GLSL 4.20.8 specification, section 8.8 Integer Functions
GLM_FUNC_DECL vecType<T, P> glm::bitfieldExtract ( vecType< T, P > const &  Value,
int  Offset,
int  Bits 
)

Extracts bits [offset, offset + bits - 1] from value, returning them in the least significant bits of the result.

For unsigned data types, the most significant bits of the result will be set to zero. For signed data types, the most significant bits will be set to the value of bit offset + base - 1.

If bits is zero, the result will be zero. The result will be undefined if offset or bits is negative, or if the sum of offset and bits is greater than the number of bits used to store the operand.

Template Parameters
TSigned or unsigned integer scalar or vector types.
See also
GLSL bitfieldExtract man page
GLSL 4.20.8 specification, section 8.8 Integer Functions
GLM_FUNC_DECL vecType<T, P> glm::bitfieldInsert ( vecType< T, P > const &  Base,
vecType< T, P > const &  Insert,
int  Offset,
int  Bits 
)

Returns the insertion the bits least-significant bits of insert into base.

The result will have bits [offset, offset + bits - 1] taken from bits [0, bits - 1] of insert, and all other bits taken directly from the corresponding bits of base. If bits is zero, the result will simply be base. The result will be undefined if offset or bits is negative, or if the sum of offset and bits is greater than the number of bits used to store the operand.

Template Parameters
TSigned or unsigned integer scalar or vector types.
See also
GLSL bitfieldInsert man page
GLSL 4.20.8 specification, section 8.8 Integer Functions
GLM_FUNC_DECL vecType<T, P> glm::bitfieldReverse ( vecType< T, P > const &  v)

Returns the reversal of the bits of value.

The bit numbered n of the result will be taken from bit (bits - 1) - n of value, where bits is the total number of bits used to represent value.

Template Parameters
TSigned or unsigned integer scalar or vector types.
See also
GLSL bitfieldReverse man page
GLSL 4.20.8 specification, section 8.8 Integer Functions
GLM_FUNC_DECL int glm::findLSB ( genIUType  x)

Returns the bit number of the least significant bit set to 1 in the binary representation of value.

If value is zero, -1 will be returned.

Template Parameters
TSigned or unsigned integer scalar types.
See also
GLSL findLSB man page
GLSL 4.20.8 specification, section 8.8 Integer Functions
GLM_FUNC_DECL vecType<int, P> glm::findLSB ( vecType< T, P > const &  v)

Returns the bit number of the least significant bit set to 1 in the binary representation of value.

If value is zero, -1 will be returned.

Template Parameters
TSigned or unsigned integer scalar types.
See also
GLSL findLSB man page
GLSL 4.20.8 specification, section 8.8 Integer Functions
GLM_FUNC_DECL int glm::findMSB ( genIUType  x)

Returns the bit number of the most significant bit in the binary representation of value.

For positive integers, the result will be the bit number of the most significant bit set to 1. For negative integers, the result will be the bit number of the most significant bit set to 0. For a value of zero or negative one, -1 will be returned.

Template Parameters
TSigned or unsigned integer scalar types.
See also
GLSL findMSB man page
GLSL 4.20.8 specification, section 8.8 Integer Functions
GLM_FUNC_DECL vecType<int, P> glm::findMSB ( vecType< T, P > const &  v)

Returns the bit number of the most significant bit in the binary representation of value.

For positive integers, the result will be the bit number of the most significant bit set to 1. For negative integers, the result will be the bit number of the most significant bit set to 0. For a value of zero or negative one, -1 will be returned.

Template Parameters
TSigned or unsigned integer scalar types.
See also
GLSL findMSB man page
GLSL 4.20.8 specification, section 8.8 Integer Functions
GLM_FUNC_DECL void glm::imulExtended ( vecType< int, P > const &  x,
vecType< int, P > const &  y,
vecType< int, P > &  msb,
vecType< int, P > &  lsb 
)

Multiplies 32-bit integers x and y, producing a 64-bit result.

The 32 least-significant bits are returned in lsb. The 32 most-significant bits are returned in msb.

Template Parameters
genITypeSigned integer scalar or vector types.
See also
GLSL imulExtended man page
GLSL 4.20.8 specification, section 8.8 Integer Functions
GLM_FUNC_DECL vecType<uint, P> glm::uaddCarry ( vecType< uint, P > const &  x,
vecType< uint, P > const &  y,
vecType< uint, P > &  carry 
)

Adds 32-bit unsigned integer x and y, returning the sum modulo pow(2, 32).

The value carry is set to 0 if the sum was less than pow(2, 32), or to 1 otherwise.

Template Parameters
genUTypeUnsigned integer scalar or vector types.
See also
GLSL uaddCarry man page
GLSL 4.20.8 specification, section 8.8 Integer Functions
GLM_FUNC_DECL void glm::umulExtended ( vecType< uint, P > const &  x,
vecType< uint, P > const &  y,
vecType< uint, P > &  msb,
vecType< uint, P > &  lsb 
)

Multiplies 32-bit integers x and y, producing a 64-bit result.

The 32 least-significant bits are returned in lsb. The 32 most-significant bits are returned in msb.

Template Parameters
genUTypeUnsigned integer scalar or vector types.
See also
GLSL umulExtended man page
GLSL 4.20.8 specification, section 8.8 Integer Functions
GLM_FUNC_DECL vecType<uint, P> glm::usubBorrow ( vecType< uint, P > const &  x,
vecType< uint, P > const &  y,
vecType< uint, P > &  borrow 
)

Subtracts the 32-bit unsigned integer y from x, returning the difference if non-negative, or pow(2, 32) plus the difference otherwise.

The value borrow is set to 0 if x >= y, or to 1 otherwise.

Template Parameters
genUTypeUnsigned integer scalar or vector types.
See also
GLSL usubBorrow man page
GLSL 4.20.8 specification, section 8.8 Integer Functions
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00155.html000066400000000000000000000246111356361734700216510ustar00rootroot00000000000000 0.9.7: Matrix functions
Functions
Matrix functions
GLM Core

Functions

template<typename T , precision P, template< typename, precision > class matType>
GLM_FUNC_DECL T determinant (matType< T, P > const &m)
 
template<typename T , precision P, template< typename, precision > class matType>
GLM_FUNC_DECL matType< T, P > inverse (matType< T, P > const &m)
 
template<typename T , precision P, template< typename, precision > class matType>
GLM_FUNC_DECL matType< T, P > matrixCompMult (matType< T, P > const &x, matType< T, P > const &y)
 
template<typename T , precision P, template< typename, precision > class vecTypeA, template< typename, precision > class vecTypeB>
GLM_FUNC_DECL detail::outerProduct_trait< T, P, vecTypeA, vecTypeB >::type outerProduct (vecTypeA< T, P > const &c, vecTypeB< T, P > const &r)
 

Detailed Description

For each of the following built-in matrix functions, there is both a single-precision floating point version, where all arguments and return values are single precision, and a double-precision floating version, where all arguments and return values are double precision.

Only the single-precision floating point version is shown.

Function Documentation

GLM_FUNC_DECL T glm::determinant ( matType< T, P > const &  m)

Returns the transposed matrix of x.

Template Parameters
matTypeFloating-point matrix types.
See also
GLSL transpose man page
GLSL 4.20.8 specification, section 8.6 Matrix Functions Return the determinant of a squared matrix.
Template Parameters
valTypeFloating-point scalar types.
See also
GLSL determinant man page
GLSL 4.20.8 specification, section 8.6 Matrix Functions
GLM_FUNC_DECL matType<T, P> glm::inverse ( matType< T, P > const &  m)

Return the inverse of a squared matrix.

Template Parameters
valTypeFloating-point scalar types.
See also
GLSL inverse man page
GLSL 4.20.8 specification, section 8.6 Matrix Functions
GLM_FUNC_DECL matType<T, P> glm::matrixCompMult ( matType< T, P > const &  x,
matType< T, P > const &  y 
)

Multiply matrix x by matrix y component-wise, i.e., result[i][j] is the scalar product of x[i][j] and y[i][j].

Template Parameters
matTypeFloating-point matrix types.
See also
GLSL matrixCompMult man page
GLSL 4.20.8 specification, section 8.6 Matrix Functions
GLM_FUNC_DECL detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type glm::outerProduct ( vecTypeA< T, P > const &  c,
vecTypeB< T, P > const &  r 
)

Treats the first parameter c as a column vector and the second parameter r as a row vector and does a linear algebraic matrix multiply c * r.

Template Parameters
matTypeFloating-point matrix types.
See also
GLSL outerProduct man page
GLSL 4.20.8 specification, section 8.6 Matrix Functions
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00156.html000066400000000000000000000213121356361734700216450ustar00rootroot00000000000000 0.9.7: Noise functions
Functions
Noise functions
GLM Core

Functions

template<typename genType >
GLM_FUNC_DECL genType::value_type noise1 (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL tvec2< typename genType::value_type, defaultp > noise2 (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL tvec3< typename genType::value_type, defaultp > noise3 (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL tvec4< typename genType::value_type, defaultp > noise4 (genType const &x)
 

Detailed Description

Noise functions are stochastic functions that can be used to increase visual complexity.

Values returned by the following noise functions give the appearance of randomness, but are not truly random.

Function Documentation

GLM_FUNC_DECL genType::value_type glm::noise1 ( genType const &  x)

Returns a 1D noise value based on the input value x.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL noise1 man page
GLSL 4.20.8 specification, section 8.13 Noise Functions
GLM_FUNC_DECL tvec2<typename genType::value_type, defaultp> glm::noise2 ( genType const &  x)

Returns a 2D noise value based on the input value x.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL noise2 man page
GLSL 4.20.8 specification, section 8.13 Noise Functions
GLM_FUNC_DECL tvec3<typename genType::value_type, defaultp> glm::noise3 ( genType const &  x)

Returns a 3D noise value based on the input value x.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL noise3 man page
GLSL 4.20.8 specification, section 8.13 Noise Functions
GLM_FUNC_DECL tvec4<typename genType::value_type, defaultp> glm::noise4 ( genType const &  x)

Returns a 4D noise value based on the input value x.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL noise4 man page
GLSL 4.20.8 specification, section 8.13 Noise Functions
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00157.html000066400000000000000000000551671356361734700216650ustar00rootroot00000000000000 0.9.7: Floating-Point Pack and Unpack Functions
Functions
Floating-Point Pack and Unpack Functions
GLM Core

Functions

GLM_FUNC_DECL double packDouble2x32 (uvec2 const &v)
 
GLM_FUNC_DECL uint packHalf2x16 (vec2 const &v)
 
GLM_FUNC_DECL uint packSnorm2x16 (vec2 const &v)
 
GLM_FUNC_DECL uint packSnorm4x8 (vec4 const &v)
 
GLM_FUNC_DECL uint packUnorm2x16 (vec2 const &v)
 
GLM_FUNC_DECL uint packUnorm4x8 (vec4 const &v)
 
GLM_FUNC_DECL uvec2 unpackDouble2x32 (double v)
 
GLM_FUNC_DECL vec2 unpackHalf2x16 (uint v)
 
GLM_FUNC_DECL vec2 unpackSnorm2x16 (uint p)
 
GLM_FUNC_DECL vec4 unpackSnorm4x8 (uint p)
 
GLM_FUNC_DECL vec2 unpackUnorm2x16 (uint p)
 
GLM_FUNC_DECL vec4 unpackUnorm4x8 (uint p)
 

Detailed Description

These functions do not operate component-wise, rather as described in each case.

Function Documentation

GLM_FUNC_DECL double glm::packDouble2x32 ( uvec2 const &  v)

Returns a double-precision value obtained by packing the components of v into a 64-bit value.

If an IEEE 754 Inf or NaN is created, it will not signal, and the resulting floating point value is unspecified. Otherwise, the bit- level representation of v is preserved. The first vector component specifies the 32 least significant bits; the second component specifies the 32 most significant bits.

See also
GLSL packDouble2x32 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL uint glm::packHalf2x16 ( vec2 const &  v)

Returns an unsigned integer obtained by converting the components of a two-component floating-point vector to the 16-bit floating-point representation found in the OpenGL Specification, and then packing these two 16- bit integers into a 32-bit unsigned integer.

The first vector component specifies the 16 least-significant bits of the result; the second component specifies the 16 most-significant bits.

See also
GLSL packHalf2x16 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL uint glm::packSnorm2x16 ( vec2 const &  v)

First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values.

Then, the results are packed into the returned 32-bit unsigned integer.

The conversion for component c of v to fixed point is done as follows: packSnorm2x16: round(clamp(v, -1, +1) * 32767.0)

The first component of the vector will be written to the least significant bits of the output; the last component will be written to the most significant bits.

See also
GLSL packSnorm2x16 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL uint glm::packSnorm4x8 ( vec4 const &  v)

First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values.

Then, the results are packed into the returned 32-bit unsigned integer.

The conversion for component c of v to fixed point is done as follows: packSnorm4x8: round(clamp(c, -1, +1) * 127.0)

The first component of the vector will be written to the least significant bits of the output; the last component will be written to the most significant bits.

See also
GLSL packSnorm4x8 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL uint glm::packUnorm2x16 ( vec2 const &  v)

First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values.

Then, the results are packed into the returned 32-bit unsigned integer.

The conversion for component c of v to fixed point is done as follows: packUnorm2x16: round(clamp(c, 0, +1) * 65535.0)

The first component of the vector will be written to the least significant bits of the output; the last component will be written to the most significant bits.

See also
GLSL packUnorm2x16 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL uint glm::packUnorm4x8 ( vec4 const &  v)

First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values.

Then, the results are packed into the returned 32-bit unsigned integer.

The conversion for component c of v to fixed point is done as follows: packUnorm4x8: round(clamp(c, 0, +1) * 255.0)

The first component of the vector will be written to the least significant bits of the output; the last component will be written to the most significant bits.

See also
GLSL packUnorm4x8 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL uvec2 glm::unpackDouble2x32 ( double  v)

Returns a two-component unsigned integer vector representation of v.

The bit-level representation of v is preserved. The first component of the vector contains the 32 least significant bits of the double; the second component consists the 32 most significant bits.

See also
GLSL unpackDouble2x32 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL vec2 glm::unpackHalf2x16 ( uint  v)

Returns a two-component floating-point vector with components obtained by unpacking a 32-bit unsigned integer into a pair of 16-bit values, interpreting those values as 16-bit floating-point numbers according to the OpenGL Specification, and converting them to 32-bit floating-point values.

The first component of the vector is obtained from the 16 least-significant bits of v; the second component is obtained from the 16 most-significant bits of v.

See also
GLSL unpackHalf2x16 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL vec2 glm::unpackSnorm2x16 ( uint  p)

First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.

Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.

The conversion for unpacked fixed-point value f to floating point is done as follows: unpackSnorm2x16: clamp(f / 32767.0, -1, +1)

The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.

See also
GLSL unpackSnorm2x16 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL vec4 glm::unpackSnorm4x8 ( uint  p)

First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.

Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.

The conversion for unpacked fixed-point value f to floating point is done as follows: unpackSnorm4x8: clamp(f / 127.0, -1, +1)

The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.

See also
GLSL unpackSnorm4x8 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL vec2 glm::unpackUnorm2x16 ( uint  p)

First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.

Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.

The conversion for unpacked fixed-point value f to floating point is done as follows: unpackUnorm2x16: f / 65535.0

The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.

See also
GLSL unpackUnorm2x16 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL vec4 glm::unpackUnorm4x8 ( uint  p)

First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.

Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.

The conversion for unpacked fixed-point value f to floating point is done as follows: unpackUnorm4x8: f / 255.0

The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.

See also
GLSL unpackUnorm4x8 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00158.html000066400000000000000000000702631356361734700216600ustar00rootroot00000000000000 0.9.7: Angle and Trigonometry Functions
Functions
Angle and Trigonometry Functions
GLM Core

Functions

template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > acos (vecType< T, P > const &x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > acosh (vecType< T, P > const &x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > asin (vecType< T, P > const &x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > asinh (vecType< T, P > const &x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > atan (vecType< T, P > const &y, vecType< T, P > const &x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > atan (vecType< T, P > const &y_over_x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > atanh (vecType< T, P > const &x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > cos (vecType< T, P > const &angle)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > cosh (vecType< T, P > const &angle)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > degrees (vecType< T, P > const &radians)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > radians (vecType< T, P > const &degrees)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > sin (vecType< T, P > const &angle)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > sinh (vecType< T, P > const &angle)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > tan (vecType< T, P > const &angle)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > tanh (vecType< T, P > const &angle)
 

Detailed Description

Function parameters specified as angle are assumed to be in units of radians.

In no case will any of these functions result in a divide by zero error. If the divisor of a ratio is 0, then results will be undefined.

These all operate component-wise. The description is per component.

Function Documentation

GLM_FUNC_DECL vecType<T, P> glm::acos ( vecType< T, P > const &  x)

Arc cosine.

Returns an angle whose sine is x. The range of values returned by this function is [0, PI]. Results are undefined if |x| > 1.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL acos man page
GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions
GLM_FUNC_DECL vecType<T, P> glm::acosh ( vecType< T, P > const &  x)

Arc hyperbolic cosine; returns the non-negative inverse of cosh.

Results are undefined if x < 1.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL acosh man page
GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions
GLM_FUNC_DECL vecType<T, P> glm::asin ( vecType< T, P > const &  x)

Arc sine.

Returns an angle whose sine is x. The range of values returned by this function is [-PI/2, PI/2]. Results are undefined if |x| > 1.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL asin man page
GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions
GLM_FUNC_DECL vecType<T, P> glm::asinh ( vecType< T, P > const &  x)

Arc hyperbolic sine; returns the inverse of sinh.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL asinh man page
GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions
GLM_FUNC_DECL vecType<T, P> glm::atan ( vecType< T, P > const &  y,
vecType< T, P > const &  x 
)

Arc tangent.

Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL atan man page
GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions

Referenced by glm::atan2().

GLM_FUNC_DECL vecType<T, P> glm::atan ( vecType< T, P > const &  y_over_x)

Arc tangent.

Returns an angle whose tangent is y_over_x. The range of values returned by this function is [-PI/2, PI/2].

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL atan man page
GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions
GLM_FUNC_DECL vecType<T, P> glm::atanh ( vecType< T, P > const &  x)

Arc hyperbolic tangent; returns the inverse of tanh.

Results are undefined if abs(x) >= 1.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL atanh man page
GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions
GLM_FUNC_DECL vecType<T, P> glm::cos ( vecType< T, P > const &  angle)

The standard trigonometric cosine function.

The values returned by this function will range from [-1, 1].

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL cos man page
GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions
GLM_FUNC_DECL vecType<T, P> glm::cosh ( vecType< T, P > const &  angle)

Returns the hyperbolic cosine function, (exp(x) + exp(-x)) / 2.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL cosh man page
GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions
GLM_FUNC_DECL vecType<T, P> glm::degrees ( vecType< T, P > const &  radians)

Converts radians to degrees and returns the result.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL degrees man page
GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions
GLM_FUNC_DECL vecType<T, P> glm::radians ( vecType< T, P > const &  degrees)

Converts degrees to radians and returns the result.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL radians man page
GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions
GLM_FUNC_DECL vecType<T, P> glm::sin ( vecType< T, P > const &  angle)

The standard trigonometric sine function.

The values returned by this function will range from [-1, 1].

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL sin man page
GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions
GLM_FUNC_DECL vecType<T, P> glm::sinh ( vecType< T, P > const &  angle)

Returns the hyperbolic sine function, (exp(x) - exp(-x)) / 2.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL sinh man page
GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions
GLM_FUNC_DECL vecType<T, P> glm::tan ( vecType< T, P > const &  angle)

The standard trigonometric tangent function.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL tan man page
GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions
GLM_FUNC_DECL vecType<T, P> glm::tanh ( vecType< T, P > const &  angle)

Returns the hyperbolic tangent function, sinh(angle) / cosh(angle)

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL tanh man page
GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00159.html000066400000000000000000000463231356361734700216610ustar00rootroot00000000000000 0.9.7: Vector Relational Functions
Functions
Vector Relational Functions
GLM Core

Functions

template<precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL bool all (vecType< bool, P > const &v)
 
template<precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL bool any (vecType< bool, P > const &v)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > equal (vecType< T, P > const &x, vecType< T, P > const &y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > greaterThan (vecType< T, P > const &x, vecType< T, P > const &y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > greaterThanEqual (vecType< T, P > const &x, vecType< T, P > const &y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > lessThan (vecType< T, P > const &x, vecType< T, P > const &y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > lessThanEqual (vecType< T, P > const &x, vecType< T, P > const &y)
 
template<precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > not_ (vecType< bool, P > const &v)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > notEqual (vecType< T, P > const &x, vecType< T, P > const &y)
 

Detailed Description

Relational and equality operators (<, <=, >, >=, ==, !=) are defined to operate on scalars and produce scalar Boolean results.

For vector results, use the following built-in functions.

In all cases, the sizes of all the input and return vectors for any particular call must match.

Function Documentation

GLM_FUNC_DECL bool glm::all ( vecType< bool, P > const &  v)

Returns true if all components of x are true.

Template Parameters
vecTypeBoolean vector types.
See also
GLSL all man page
GLSL 4.20.8 specification, section 8.7 Vector Relational Functions
GLM_FUNC_DECL bool glm::any ( vecType< bool, P > const &  v)

Returns true if any component of x is true.

Template Parameters
vecTypeBoolean vector types.
See also
GLSL any man page
GLSL 4.20.8 specification, section 8.7 Vector Relational Functions
GLM_FUNC_DECL vecType<bool, P> glm::equal ( vecType< T, P > const &  x,
vecType< T, P > const &  y 
)

Returns the component-wise comparison of result x == y.

Template Parameters
vecTypeFloating-point, integer or boolean vector types.
See also
GLSL equal man page
GLSL 4.20.8 specification, section 8.7 Vector Relational Functions
GLM_FUNC_DECL vecType<bool, P> glm::greaterThan ( vecType< T, P > const &  x,
vecType< T, P > const &  y 
)

Returns the component-wise comparison of result x > y.

Template Parameters
vecTypeFloating-point or integer vector types.
See also
GLSL greaterThan man page
GLSL 4.20.8 specification, section 8.7 Vector Relational Functions
GLM_FUNC_DECL vecType<bool, P> glm::greaterThanEqual ( vecType< T, P > const &  x,
vecType< T, P > const &  y 
)

Returns the component-wise comparison of result x >= y.

Template Parameters
vecTypeFloating-point or integer vector types.
See also
GLSL greaterThanEqual man page
GLSL 4.20.8 specification, section 8.7 Vector Relational Functions
GLM_FUNC_DECL vecType<bool, P> glm::lessThan ( vecType< T, P > const &  x,
vecType< T, P > const &  y 
)

Returns the component-wise comparison result of x < y.

Template Parameters
vecTypeFloating-point or integer vector types.
See also
GLSL lessThan man page
GLSL 4.20.8 specification, section 8.7 Vector Relational Functions
GLM_FUNC_DECL vecType<bool, P> glm::lessThanEqual ( vecType< T, P > const &  x,
vecType< T, P > const &  y 
)

Returns the component-wise comparison of result x <= y.

Template Parameters
vecTypeFloating-point or integer vector types.
See also
GLSL lessThanEqual man page
GLSL 4.20.8 specification, section 8.7 Vector Relational Functions
GLM_FUNC_DECL vecType<bool, P> glm::not_ ( vecType< bool, P > const &  v)

Returns the component-wise logical complement of x.

/!\ Because of language incompatibilities between C++ and GLSL, GLM defines the function not but not_ instead.

Template Parameters
vecTypeBoolean vector types.
See also
GLSL not man page
GLSL 4.20.8 specification, section 8.7 Vector Relational Functions
GLM_FUNC_DECL vecType<bool, P> glm::notEqual ( vecType< T, P > const &  x,
vecType< T, P > const &  y 
)

Returns the component-wise comparison of result x != y.

Template Parameters
vecTypeFloating-point, integer or boolean vector types.
See also
GLSL notEqual man page
GLSL 4.20.8 specification, section 8.7 Vector Relational Functions
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00160.html000066400000000000000000000167031356361734700216500ustar00rootroot00000000000000 0.9.7: GTC Extensions (Stable)
Modules
GTC Extensions (Stable)

Modules

 GLM_GTC_bitfield
 
 GLM_GTC_color_space
 
 GLM_GTC_constants
 
 GLM_GTC_epsilon
 
 GLM_GTC_integer
 
 GLM_GTC_matrix_access
 
 GLM_GTC_matrix_integer
 
 GLM_GTC_matrix_inverse
 
 GLM_GTC_matrix_transform
 
 GLM_GTC_noise
 
 GLM_GTC_packing
 
 GLM_GTC_quaternion
 
 GLM_GTC_random
 
 GLM_GTC_reciprocal
 
 GLM_GTC_round
 
 GLM_GTC_type_precision
 
 GLM_GTC_type_ptr
 
 GLM_GTC_ulp
 
 GLM_GTC_vec1
 

Detailed Description

Functions and types that the GLSL specification doesn't define, but useful to have for a C++ program.

GTC extensions aim to be stable.

Even if it's highly unrecommended, it's possible to include all the extensions at once by including <glm/ext.hpp>. Otherwise, each extension needs to be included a specific file.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00161.html000066400000000000000000000436621356361734700216550ustar00rootroot00000000000000 0.9.7: GTX Extensions (Experimental)
Modules
GTX Extensions (Experimental)

Modules

 GLM_GTX_associated_min_max
 
 GLM_GTX_bit
 
 GLM_GTX_closest_point
 
 GLM_GTX_color_space
 
 GLM_GTX_color_space_YCoCg
 
 GLM_GTX_common
 
 GLM_GTX_compatibility
 
 GLM_GTX_component_wise
 
 GLM_GTX_dual_quaternion
 
 GLM_GTX_euler_angles
 
 GLM_GTX_extend
 
 GLM_GTX_extented_min_max
 
 GLM_GTX_fast_exponential
 
 GLM_GTX_fast_square_root
 
 GLM_GTX_fast_trigonometry
 
 GLM_GTX_gradient_paint
 
 GLM_GTX_handed_coordinate_space
 
 GLM_GTX_hash
 
 GLM_GTX_integer
 
 GLM_GTX_intersect
 
 GLM_GTX_io
 
 GLM_GTX_log_base
 
 GLM_GTX_matrix_cross_product
 
 GLM_GTX_matrix_decompose
 
 GLM_GTX_matrix_interpolation
 
 GLM_GTX_matrix_major_storage
 
 GLM_GTX_matrix_operation
 
 GLM_GTX_matrix_query
 
 GLM_GTX_matrix_transform_2d
 
 GLM_GTX_mixed_producte
 
 GLM_GTX_norm
 
 GLM_GTX_normal
 
 GLM_GTX_normalize_dot
 
 GLM_GTX_number_precision
 
 GLM_GTX_optimum_pow
 
 GLM_GTX_orthonormalize
 
 GLM_GTX_perpendicular
 
 GLM_GTX_polar_coordinates
 
 GLM_GTX_projection
 
 GLM_GTX_quaternion
 
 GLM_GTX_range
 
 GLM_GTX_raw_data
 
 GLM_GTX_rotate_normalized_axis
 
 GLM_GTX_rotate_vector
 
 GLM_GTX_scalar_relational
 
 GLM_GTX_simd_mat4
 
 GLM_GTX_simd_quat
 
 GLM_GTX_simd_vec4
 
 GLM_GTX_spline
 
 GLM_GTX_std_based_type
 
 GLM_GTX_string_cast
 
 GLM_GTX_transform
 
 GLM_GTX_transform2
 
 GLM_GTX_type_aligned
 
 GLM_GTX_vector_angle
 
 GLM_GTX_vector_query
 
 GLM_GTX_wrap
 

Detailed Description

Functions and types that the GLSL specification doesn't define, but useful to have for a C++ program.

Experimental extensions are useful functions and types, but the development of their API and functionality is not necessarily stable. They can change substantially between versions. Backwards compatibility is not much of an issue for them.

Even if it's highly unrecommended, it's possible to include all the extensions at once by including <glm/ext.hpp>. Otherwise, each extension needs to be included a specific file.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00162.html000066400000000000000000000140331356361734700216440ustar00rootroot00000000000000 0.9.7: GLM Core
Modules
GLM Core

Modules

 Common functions
 
 Exponential functions
 
 Geometric functions
 
 Integer functions
 
 Matrix functions
 
 Noise functions
 
 Floating-Point Pack and Unpack Functions
 
 Angle and Trigonometry Functions
 
 Vector Relational Functions
 
 Types
 
 Precision types
 
 Template types
 

Detailed Description

The core of GLM, which implements exactly and only the GLSL specification to the degree possible.

The GLM core consists of C++ types that mirror GLSL types and C++ functions that mirror the GLSL functions. It also includes a set of precision-based types that can be used in the appropriate functions. The C++ types are all based on a basic set of template types.

The best documentation for GLM Core is the current GLSL specification, version 4.2 (pdf file).

GLM core functionnalities require <glm/glm.hpp> to be included to be used.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00163.html000066400000000000000000001254301356361734700216510ustar00rootroot00000000000000 0.9.7: Types
Modules | Typedefs
Types
GLM Core

Modules

 Precision types
 

Typedefs

typedef highp_bvec2 bvec2
 
typedef highp_bvec3 bvec3
 
typedef highp_bvec4 bvec4
 
typedef highp_dmat2x2 dmat2
 
typedef highp_dmat2x2 dmat2x2
 
typedef highp_dmat2x3 dmat2x3
 
typedef highp_dmat2x4 dmat2x4
 
typedef highp_dmat3x3 dmat3
 
typedef highp_dmat3x2 dmat3x2
 
typedef highp_dmat3x3 dmat3x3
 
typedef highp_dmat3x4 dmat3x4
 
typedef highp_dmat4x4 dmat4
 
typedef highp_dmat4x2 dmat4x2
 
typedef highp_dmat4x3 dmat4x3
 
typedef highp_dmat4x4 dmat4x4
 
typedef highp_dvec2 dvec2
 
typedef highp_dvec3 dvec3
 
typedef highp_dvec4 dvec4
 
typedef highp_ivec2 ivec2
 
typedef highp_ivec3 ivec3
 
typedef highp_ivec4 ivec4
 
typedef mat2x2 mat2
 
typedef highp_mat2x2 mat2x2
 
typedef highp_mat2x3 mat2x3
 
typedef highp_mat2x4 mat2x4
 
typedef mat3x3 mat3
 
typedef highp_mat3x2 mat3x2
 
typedef highp_mat3x3 mat3x3
 
typedef highp_mat3x4 mat3x4
 
typedef mat4x4 mat4
 
typedef highp_mat4x2 mat4x2
 
typedef highp_mat4x3 mat4x3
 
typedef highp_mat4x4 mat4x4
 
typedef highp_uvec2 uvec2
 
typedef highp_uvec3 uvec3
 
typedef highp_uvec4 uvec4
 
typedef highp_vec2 vec2
 
typedef highp_vec3 vec3
 
typedef highp_vec4 vec4
 

Detailed Description

The standard types defined by the specification.

These types are all typedefs of more generalized, template types. To see the definiton of these template types, go to Template types.

Typedef Documentation

typedef highp_bvec2 bvec2

2 components vector of boolean.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors

Definition at line 498 of file type_vec.hpp.

typedef highp_bvec3 bvec3

3 components vector of boolean.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors

Definition at line 503 of file type_vec.hpp.

typedef highp_bvec4 bvec4

4 components vector of boolean.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors

Definition at line 508 of file type_vec.hpp.

typedef highp_dmat2x2 dmat2

2 * 2 matrix of double-precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 733 of file type_mat.hpp.

typedef highp_dmat2x2 dmat2x2

2 * 2 matrix of double-precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 748 of file type_mat.hpp.

typedef highp_dmat2x3 dmat2x3

2 * 3 matrix of double-precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 753 of file type_mat.hpp.

typedef highp_dmat2x4 dmat2x4

2 * 4 matrix of double-precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 758 of file type_mat.hpp.

typedef highp_dmat3x3 dmat3

3 * 3 matrix of double-precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 738 of file type_mat.hpp.

typedef highp_dmat3x2 dmat3x2

3 * 2 matrix of double-precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 763 of file type_mat.hpp.

typedef highp_dmat3x3 dmat3x3

3 * 3 matrix of double-precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 768 of file type_mat.hpp.

typedef highp_dmat3x4 dmat3x4

3 * 4 matrix of double-precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 773 of file type_mat.hpp.

typedef highp_dmat4x4 dmat4

4 * 4 matrix of double-precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 743 of file type_mat.hpp.

typedef highp_dmat4x2 dmat4x2

4 * 2 matrix of double-precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 778 of file type_mat.hpp.

typedef highp_dmat4x3 dmat4x3

4 * 3 matrix of double-precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 783 of file type_mat.hpp.

typedef highp_dmat4x4 dmat4x4

4 * 4 matrix of double-precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 788 of file type_mat.hpp.

typedef highp_dvec2 dvec2

2 components vector of double-precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors

Definition at line 417 of file type_vec.hpp.

typedef highp_dvec3 dvec3

3 components vector of double-precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors

Definition at line 422 of file type_vec.hpp.

typedef highp_dvec4 dvec4

4 components vector of double-precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors

Definition at line 427 of file type_vec.hpp.

typedef highp_ivec2 ivec2

2 components vector of signed integer numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors

Definition at line 444 of file type_vec.hpp.

typedef highp_ivec3 ivec3

3 components vector of signed integer numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors

Definition at line 449 of file type_vec.hpp.

typedef highp_ivec4 ivec4

4 components vector of signed integer numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors

Definition at line 454 of file type_vec.hpp.

typedef mat2x2 mat2

2 columns of 2 components matrix of floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 432 of file type_mat.hpp.

typedef highp_mat2x2 mat2x2

2 columns of 2 components matrix of floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 385 of file type_mat.hpp.

typedef highp_mat2x3 mat2x3

2 columns of 3 components matrix of floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 390 of file type_mat.hpp.

typedef highp_mat2x4 mat2x4

2 columns of 4 components matrix of floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 395 of file type_mat.hpp.

typedef mat3x3 mat3

3 columns of 3 components matrix of floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 437 of file type_mat.hpp.

typedef highp_mat3x2 mat3x2

3 columns of 2 components matrix of floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 400 of file type_mat.hpp.

typedef highp_mat3x3 mat3x3

3 columns of 3 components matrix of floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 405 of file type_mat.hpp.

typedef highp_mat3x4 mat3x4

3 columns of 4 components matrix of floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 410 of file type_mat.hpp.

typedef mat4x4 mat4

4 columns of 4 components matrix of floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 442 of file type_mat.hpp.

typedef highp_mat4x2 mat4x2

4 columns of 2 components matrix of floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 415 of file type_mat.hpp.

typedef highp_mat4x3 mat4x3

4 columns of 3 components matrix of floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 420 of file type_mat.hpp.

typedef highp_mat4x4 mat4x4

4 columns of 4 components matrix of floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices

Definition at line 425 of file type_mat.hpp.

typedef highp_uvec2 uvec2

2 components vector of unsigned integer numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors

Definition at line 471 of file type_vec.hpp.

typedef highp_uvec3 uvec3

3 components vector of unsigned integer numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors

Definition at line 476 of file type_vec.hpp.

typedef highp_uvec4 uvec4

4 components vector of unsigned integer numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors

Definition at line 481 of file type_vec.hpp.

typedef highp_vec2 vec2

2 components vector of floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors

Definition at line 390 of file type_vec.hpp.

typedef highp_vec3 vec3

3 components vector of floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors

Definition at line 395 of file type_vec.hpp.

typedef highp_vec4 vec4

4 components vector of floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors

Definition at line 400 of file type_vec.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00164.html000066400000000000000000005067241356361734700216630ustar00rootroot00000000000000 0.9.7: Precision types
Typedefs
Precision types
GLM CoreGLM Core » | Types

Typedefs

typedef tvec2< bool, highp > highp_bvec2
 
typedef tvec3< bool, highp > highp_bvec3
 
typedef tvec4< bool, highp > highp_bvec4
 
typedef tmat2x2< double, highp > highp_dmat2
 
typedef tmat2x2< double, highp > highp_dmat2x2
 
typedef tmat2x3< double, highp > highp_dmat2x3
 
typedef tmat2x4< double, highp > highp_dmat2x4
 
typedef tmat3x3< double, highp > highp_dmat3
 
typedef tmat3x2< double, highp > highp_dmat3x2
 
typedef tmat3x3< double, highp > highp_dmat3x3
 
typedef tmat3x4< double, highp > highp_dmat3x4
 
typedef tmat4x4< double, highp > highp_dmat4
 
typedef tmat4x2< double, highp > highp_dmat4x2
 
typedef tmat4x3< double, highp > highp_dmat4x3
 
typedef tmat4x4< double, highp > highp_dmat4x4
 
typedef tvec2< double, highp > highp_dvec2
 
typedef tvec3< double, highp > highp_dvec3
 
typedef tvec4< double, highp > highp_dvec4
 
typedef highp_float_t highp_float
 
typedef detail::highp_int_t highp_int
 
typedef tvec2< int, highp > highp_ivec2
 
typedef tvec3< int, highp > highp_ivec3
 
typedef tvec4< int, highp > highp_ivec4
 
typedef tmat2x2< float, highp > highp_mat2
 
typedef tmat2x2< float, highp > highp_mat2x2
 
typedef tmat2x3< float, highp > highp_mat2x3
 
typedef tmat2x4< float, highp > highp_mat2x4
 
typedef tmat3x3< float, highp > highp_mat3
 
typedef tmat3x2< float, highp > highp_mat3x2
 
typedef tmat3x3< float, highp > highp_mat3x3
 
typedef tmat3x4< float, highp > highp_mat3x4
 
typedef tmat4x4< float, highp > highp_mat4
 
typedef tmat4x2< float, highp > highp_mat4x2
 
typedef tmat4x3< float, highp > highp_mat4x3
 
typedef tmat4x4< float, highp > highp_mat4x4
 
typedef detail::highp_uint_t highp_uint
 
typedef tvec2< uint, highp > highp_uvec2
 
typedef tvec3< uint, highp > highp_uvec3
 
typedef tvec4< uint, highp > highp_uvec4
 
typedef tvec2< float, highp > highp_vec2
 
typedef tvec3< float, highp > highp_vec3
 
typedef tvec4< float, highp > highp_vec4
 
typedef tvec2< bool, lowp > lowp_bvec2
 
typedef tvec3< bool, lowp > lowp_bvec3
 
typedef tvec4< bool, lowp > lowp_bvec4
 
typedef tmat2x2< double, lowp > lowp_dmat2
 
typedef tmat2x2< double, lowp > lowp_dmat2x2
 
typedef tmat2x3< double, lowp > lowp_dmat2x3
 
typedef tmat2x4< double, lowp > lowp_dmat2x4
 
typedef tmat3x3< float, lowp > lowp_dmat3
 
typedef tmat3x2< double, lowp > lowp_dmat3x2
 
typedef tmat3x3< double, lowp > lowp_dmat3x3
 
typedef tmat3x4< double, lowp > lowp_dmat3x4
 
typedef tmat4x4< double, lowp > lowp_dmat4
 
typedef tmat4x2< double, lowp > lowp_dmat4x2
 
typedef tmat4x3< double, lowp > lowp_dmat4x3
 
typedef tmat4x4< double, lowp > lowp_dmat4x4
 
typedef tvec2< double, lowp > lowp_dvec2
 
typedef tvec3< double, lowp > lowp_dvec3
 
typedef tvec4< double, lowp > lowp_dvec4
 
typedef lowp_float_t lowp_float
 
typedef detail::lowp_int_t lowp_int
 
typedef tvec2< int, lowp > lowp_ivec2
 
typedef tvec3< int, lowp > lowp_ivec3
 
typedef tvec4< int, lowp > lowp_ivec4
 
typedef tmat2x2< float, lowp > lowp_mat2
 
typedef tmat2x2< float, lowp > lowp_mat2x2
 
typedef tmat2x3< float, lowp > lowp_mat2x3
 
typedef tmat2x4< float, lowp > lowp_mat2x4
 
typedef tmat3x3< float, lowp > lowp_mat3
 
typedef tmat3x2< float, lowp > lowp_mat3x2
 
typedef tmat3x3< float, lowp > lowp_mat3x3
 
typedef tmat3x4< float, lowp > lowp_mat3x4
 
typedef tmat4x4< float, lowp > lowp_mat4
 
typedef tmat4x2< float, lowp > lowp_mat4x2
 
typedef tmat4x3< float, lowp > lowp_mat4x3
 
typedef tmat4x4< float, lowp > lowp_mat4x4
 
typedef detail::lowp_uint_t lowp_uint
 
typedef tvec2< uint, lowp > lowp_uvec2
 
typedef tvec3< uint, lowp > lowp_uvec3
 
typedef tvec4< uint, lowp > lowp_uvec4
 
typedef tvec2< float, lowp > lowp_vec2
 
typedef tvec3< float, lowp > lowp_vec3
 
typedef tvec4< float, lowp > lowp_vec4
 
typedef tvec2< bool, mediump > mediump_bvec2
 
typedef tvec3< bool, mediump > mediump_bvec3
 
typedef tvec4< bool, mediump > mediump_bvec4
 
typedef tmat2x2< double, mediump > mediump_dmat2
 
typedef tmat2x2< double, mediump > mediump_dmat2x2
 
typedef tmat2x3< double, mediump > mediump_dmat2x3
 
typedef tmat2x4< double, mediump > mediump_dmat2x4
 
typedef tmat3x3< double, mediump > mediump_dmat3
 
typedef tmat3x2< double, mediump > mediump_dmat3x2
 
typedef tmat3x3< double, mediump > mediump_dmat3x3
 
typedef tmat3x4< double, mediump > mediump_dmat3x4
 
typedef tmat4x4< double, mediump > mediump_dmat4
 
typedef tmat4x2< double, mediump > mediump_dmat4x2
 
typedef tmat4x3< double, mediump > mediump_dmat4x3
 
typedef tmat4x4< double, mediump > mediump_dmat4x4
 
typedef tvec2< double, mediump > mediump_dvec2
 
typedef tvec3< double, mediump > mediump_dvec3
 
typedef tvec4< double, mediump > mediump_dvec4
 
typedef mediump_float_t mediump_float
 
typedef detail::mediump_int_t mediump_int
 
typedef tvec2< int, mediump > mediump_ivec2
 
typedef tvec3< int, mediump > mediump_ivec3
 
typedef tvec4< int, mediump > mediump_ivec4
 
typedef tmat2x2< float, mediump > mediump_mat2
 
typedef tmat2x2< float, mediump > mediump_mat2x2
 
typedef tmat2x3< float, mediump > mediump_mat2x3
 
typedef tmat2x4< float, mediump > mediump_mat2x4
 
typedef tmat3x3< float, mediump > mediump_mat3
 
typedef tmat3x2< float, mediump > mediump_mat3x2
 
typedef tmat3x3< float, mediump > mediump_mat3x3
 
typedef tmat3x4< float, mediump > mediump_mat3x4
 
typedef tmat4x4< float, mediump > mediump_mat4
 
typedef tmat4x2< float, mediump > mediump_mat4x2
 
typedef tmat4x3< float, mediump > mediump_mat4x3
 
typedef tmat4x4< float, mediump > mediump_mat4x4
 
typedef detail::mediump_uint_t mediump_uint
 
typedef tvec2< uint, mediump > mediump_uvec2
 
typedef tvec3< uint, mediump > mediump_uvec3
 
typedef tvec4< uint, mediump > mediump_uvec4
 
typedef tvec2< float, mediump > mediump_vec2
 
typedef tvec3< float, mediump > mediump_vec3
 
typedef tvec4< float, mediump > mediump_vec4
 
typedef unsigned int uint
 

Detailed Description

Non-GLSL types that are used to define precision-based types.

The GLSL language allows the user to define the precision of a particular variable. In OpenGL's GLSL, these precision qualifiers have no effect; they are there for compatibility with OpenGL ES's precision qualifiers, where they do have an effect.

C++ has no language equivalent to precision qualifiers. So GLM provides the next-best thing: a number of typedefs of the Template types that use a particular precision.

None of these types make any guarantees about the actual precision used.

Typedef Documentation

typedef tvec2<bool, highp> highp_bvec2

2 components vector of high precision bool numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 153 of file type_vec.hpp.

typedef tvec3<bool, highp> highp_bvec3

3 components vector of high precision bool numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 262 of file type_vec.hpp.

typedef tvec4<bool, highp> highp_bvec4

4 components vector of high precision bool numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 357 of file type_vec.hpp.

typedef tmat2x2<double, highp> highp_dmat2

2 columns of 2 components matrix of high precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 466 of file type_mat.hpp.

typedef tmat2x2<double, highp> highp_dmat2x2

2 columns of 2 components matrix of high precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 484 of file type_mat.hpp.

typedef tmat2x3<double, highp> highp_dmat2x3

2 columns of 3 components matrix of high precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 507 of file type_mat.hpp.

typedef tmat2x4<double, highp> highp_dmat2x4

2 columns of 4 components matrix of high precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 530 of file type_mat.hpp.

typedef tmat3x3<double, highp> highp_dmat3

3 columns of 3 components matrix of high precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 576 of file type_mat.hpp.

typedef tmat3x2<double, highp> highp_dmat3x2

3 columns of 2 components matrix of high precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 553 of file type_mat.hpp.

typedef tmat3x3<double, highp> highp_dmat3x3

3 columns of 3 components matrix of high precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 594 of file type_mat.hpp.

typedef tmat3x4<double, highp> highp_dmat3x4

3 columns of 4 components matrix of high precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 617 of file type_mat.hpp.

typedef tmat4x4<double, highp> highp_dmat4

4 columns of 4 components matrix of high precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 686 of file type_mat.hpp.

typedef tmat4x2<double, highp> highp_dmat4x2

4 columns of 2 components matrix of high precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 640 of file type_mat.hpp.

typedef tmat4x3<double, highp> highp_dmat4x3

4 columns of 3 components matrix of high precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 663 of file type_mat.hpp.

typedef tmat4x4<double, highp> highp_dmat4x4

4 columns of 4 components matrix of high precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 704 of file type_mat.hpp.

typedef tvec2<double, highp> highp_dvec2

2 components vector of high double-precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 90 of file type_vec.hpp.

typedef tvec3<double, highp> highp_dvec3

3 components vector of high double-precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 200 of file type_vec.hpp.

typedef tvec4<double, highp> highp_dvec4

4 components vector of high double-precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 303 of file type_vec.hpp.

typedef highp_float_t highp_float

High precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.4 Floats
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 70 of file type_float.hpp.

typedef detail::highp_int_t highp_int

High precision signed integer.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.3 Integers
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 258 of file type_int.hpp.

typedef tvec2<int, highp> highp_ivec2

2 components vector of high precision signed integer numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 111 of file type_vec.hpp.

typedef tvec3<int, highp> highp_ivec3

3 components vector of high precision signed integer numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 221 of file type_vec.hpp.

typedef tvec4<int, highp> highp_ivec4

4 components vector of high precision signed integer numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 321 of file type_vec.hpp.

typedef tmat2x2< float, highp > highp_mat2

2 columns of 2 components matrix of high precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 79 of file type_mat.hpp.

typedef tmat2x2< float, highp > highp_mat2x2

2 columns of 2 components matrix of high precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 100 of file type_mat.hpp.

typedef tmat2x3< float, highp > highp_mat2x3

2 columns of 3 components matrix of high precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 126 of file type_mat.hpp.

typedef tmat2x4< float, highp > highp_mat2x4

2 columns of 4 components matrix of high precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 152 of file type_mat.hpp.

typedef tmat3x3< float, highp > highp_mat3

3 columns of 3 components matrix of high precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 204 of file type_mat.hpp.

typedef tmat3x2< float, highp > highp_mat3x2

3 columns of 2 components matrix of high precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 178 of file type_mat.hpp.

typedef tmat3x3< float, highp > highp_mat3x3

3 columns of 3 components matrix of high precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 225 of file type_mat.hpp.

typedef tmat3x4< float, highp > highp_mat3x4

3 columns of 4 components matrix of high precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 251 of file type_mat.hpp.

typedef tmat4x4< float, highp > highp_mat4

4 columns of 4 components matrix of high precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 330 of file type_mat.hpp.

typedef tmat4x2< float, highp > highp_mat4x2

4 columns of 2 components matrix of high precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 277 of file type_mat.hpp.

typedef tmat4x3< float, highp > highp_mat4x3

4 columns of 3 components matrix of high precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 303 of file type_mat.hpp.

typedef tmat4x4< float, highp > highp_mat4x4

4 columns of 4 components matrix of high precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 351 of file type_mat.hpp.

typedef detail::highp_uint_t highp_uint

High precision unsigned integer.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.3 Integers
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 279 of file type_int.hpp.

typedef tvec2<uint, highp> highp_uvec2

2 components vector of high precision unsigned integer numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 132 of file type_vec.hpp.

typedef tvec3<uint, highp> highp_uvec3

3 components vector of high precision unsigned integer numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 242 of file type_vec.hpp.

typedef tvec4<uint, highp> highp_uvec4

4 components vector of high precision unsigned integer numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 339 of file type_vec.hpp.

typedef tvec2< float, highp > highp_vec2

2 components vector of high single-precision floating-point numbers.

High Single-precision floating-point vector of 2 components.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier
Precision types

Definition at line 69 of file type_vec.hpp.

typedef tvec3< float, highp > highp_vec3

3 components vector of high single-precision floating-point numbers.

High Single-precision floating-point vector of 3 components.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier
Precision types

Definition at line 179 of file type_vec.hpp.

typedef tvec4< float, highp > highp_vec4

4 components vector of high single-precision floating-point numbers.

High Single-precision floating-point vector of 4 components.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier
Precision types

Definition at line 285 of file type_vec.hpp.

typedef tvec2<bool, lowp> lowp_bvec2

2 components vector of low precision bool numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 167 of file type_vec.hpp.

typedef tvec3<bool, lowp> lowp_bvec3

3 components vector of low precision bool numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 274 of file type_vec.hpp.

typedef tvec4<bool, lowp> lowp_bvec4

4 components vector of low precision bool numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 369 of file type_vec.hpp.

typedef tmat2x2<double, lowp> lowp_dmat2

2 columns of 2 components matrix of low precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 454 of file type_mat.hpp.

typedef tmat2x2<double, lowp> lowp_dmat2x2

2 columns of 2 components matrix of low precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 472 of file type_mat.hpp.

typedef tmat2x3<double, lowp> lowp_dmat2x3

2 columns of 3 components matrix of low precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 495 of file type_mat.hpp.

typedef tmat2x4<double, lowp> lowp_dmat2x4

2 columns of 4 components matrix of low precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 518 of file type_mat.hpp.

typedef tmat3x3<float, lowp> lowp_dmat3

3 columns of 3 components matrix of low precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 564 of file type_mat.hpp.

typedef tmat3x2<double, lowp> lowp_dmat3x2

3 columns of 2 components matrix of low precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 541 of file type_mat.hpp.

typedef tmat3x3<double, lowp> lowp_dmat3x3

3 columns of 3 components matrix of low precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 582 of file type_mat.hpp.

typedef tmat3x4<double, lowp> lowp_dmat3x4

3 columns of 4 components matrix of low precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 605 of file type_mat.hpp.

typedef tmat4x4<double, lowp> lowp_dmat4

4 columns of 4 components matrix of low precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 674 of file type_mat.hpp.

typedef tmat4x2<double, lowp> lowp_dmat4x2

4 columns of 2 components matrix of low precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 628 of file type_mat.hpp.

typedef tmat4x3<double, lowp> lowp_dmat4x3

4 columns of 3 components matrix of low precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 651 of file type_mat.hpp.

typedef tmat4x4<double, lowp> lowp_dmat4x4

4 columns of 4 components matrix of low precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 692 of file type_mat.hpp.

typedef tvec2<double, lowp> lowp_dvec2

2 components vector of low double-precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 104 of file type_vec.hpp.

typedef tvec3<double, lowp> lowp_dvec3

3 components vector of low double-precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 214 of file type_vec.hpp.

typedef tvec4<double, lowp> lowp_dvec4

4 components vector of low double-precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 315 of file type_vec.hpp.

typedef lowp_float_t lowp_float

Low precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.4 Floats
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 56 of file type_float.hpp.

typedef detail::lowp_int_t lowp_int

Low precision signed integer.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.3 Integers
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 244 of file type_int.hpp.

typedef tvec2<int, lowp> lowp_ivec2

2 components vector of low precision signed integer numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 125 of file type_vec.hpp.

typedef tvec3<int, lowp> lowp_ivec3

3 components vector of low precision signed integer numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 235 of file type_vec.hpp.

typedef tvec4<int, lowp> lowp_ivec4

4 components vector of low precision signed integer numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 333 of file type_vec.hpp.

typedef tmat2x2< float, lowp > lowp_mat2

2 columns of 2 components matrix of low precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 65 of file type_mat.hpp.

typedef tmat2x2< float, lowp > lowp_mat2x2

2 columns of 2 components matrix of low precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 86 of file type_mat.hpp.

typedef tmat2x3< float, lowp > lowp_mat2x3

2 columns of 3 components matrix of low precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 112 of file type_mat.hpp.

typedef tmat2x4< float, lowp > lowp_mat2x4

2 columns of 4 components matrix of low precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 138 of file type_mat.hpp.

typedef tmat3x3< float, lowp > lowp_mat3

3 columns of 3 components matrix of low precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 190 of file type_mat.hpp.

typedef tmat3x2< float, lowp > lowp_mat3x2

3 columns of 2 components matrix of low precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 164 of file type_mat.hpp.

typedef tmat3x3< float, lowp > lowp_mat3x3

3 columns of 3 components matrix of low precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 211 of file type_mat.hpp.

typedef tmat3x4< float, lowp > lowp_mat3x4

3 columns of 4 components matrix of low precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 237 of file type_mat.hpp.

typedef tmat4x4< float, lowp > lowp_mat4

4 columns of 4 components matrix of low precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 316 of file type_mat.hpp.

typedef tmat4x2< float, lowp > lowp_mat4x2

4 columns of 2 components matrix of low precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 263 of file type_mat.hpp.

typedef tmat4x3< float, lowp > lowp_mat4x3

4 columns of 3 components matrix of low precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 289 of file type_mat.hpp.

typedef tmat4x4< float, lowp > lowp_mat4x4

4 columns of 4 components matrix of low precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 337 of file type_mat.hpp.

typedef detail::lowp_uint_t lowp_uint

Low precision unsigned integer.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.3 Integers
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 265 of file type_int.hpp.

typedef tvec2<uint, lowp> lowp_uvec2

2 components vector of low precision unsigned integer numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 146 of file type_vec.hpp.

typedef tvec3<uint, lowp> lowp_uvec3

3 components vector of low precision unsigned integer numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 256 of file type_vec.hpp.

typedef tvec4<uint, lowp> lowp_uvec4

4 components vector of low precision unsigned integer numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 351 of file type_vec.hpp.

typedef tvec2< float, lowp > lowp_vec2

2 components vector of low single-precision floating-point numbers.

Low single-precision floating-point vector of 2 components.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier
Precision types

Definition at line 83 of file type_vec.hpp.

typedef tvec3< float, lowp > lowp_vec3

3 components vector of low single-precision floating-point numbers.

Low single-precision floating-point vector of 3 components.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier
Precision types

Definition at line 193 of file type_vec.hpp.

typedef tvec4< float, lowp > lowp_vec4

4 components vector of low single-precision floating-point numbers.

Low single-precision floating-point vector of 4 components.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier
Precision types

Definition at line 297 of file type_vec.hpp.

typedef tvec2<bool, mediump> mediump_bvec2

2 components vector of medium precision bool numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 160 of file type_vec.hpp.

typedef tvec3<bool, mediump> mediump_bvec3

3 components vector of medium precision bool numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 268 of file type_vec.hpp.

typedef tvec4<bool, mediump> mediump_bvec4

4 components vector of medium precision bool numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 363 of file type_vec.hpp.

typedef tmat2x2<double, mediump> mediump_dmat2

2 columns of 2 components matrix of medium precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 460 of file type_mat.hpp.

typedef tmat2x2<double, mediump> mediump_dmat2x2

2 columns of 2 components matrix of medium precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 478 of file type_mat.hpp.

typedef tmat2x3<double, mediump> mediump_dmat2x3

2 columns of 3 components matrix of medium precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 501 of file type_mat.hpp.

typedef tmat2x4<double, mediump> mediump_dmat2x4

2 columns of 4 components matrix of medium precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 524 of file type_mat.hpp.

typedef tmat3x3<double, mediump> mediump_dmat3

3 columns of 3 components matrix of medium precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 570 of file type_mat.hpp.

typedef tmat3x2<double, mediump> mediump_dmat3x2

3 columns of 2 components matrix of medium precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 547 of file type_mat.hpp.

typedef tmat3x3<double, mediump> mediump_dmat3x3

3 columns of 3 components matrix of medium precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 588 of file type_mat.hpp.

typedef tmat3x4<double, mediump> mediump_dmat3x4

3 columns of 4 components matrix of medium precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 611 of file type_mat.hpp.

typedef tmat4x4<double, mediump> mediump_dmat4

4 columns of 4 components matrix of medium precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 680 of file type_mat.hpp.

typedef tmat4x2<double, mediump> mediump_dmat4x2

4 columns of 2 components matrix of medium precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 634 of file type_mat.hpp.

typedef tmat4x3<double, mediump> mediump_dmat4x3

4 columns of 3 components matrix of medium precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 657 of file type_mat.hpp.

typedef tmat4x4<double, mediump> mediump_dmat4x4

4 columns of 4 components matrix of medium precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 698 of file type_mat.hpp.

typedef tvec2<double, mediump> mediump_dvec2

2 components vector of medium double-precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 97 of file type_vec.hpp.

typedef tvec3<double, mediump> mediump_dvec3

3 components vector of medium double-precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 207 of file type_vec.hpp.

typedef tvec4<double, mediump> mediump_dvec4

4 components vector of medium double-precision floating-point numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 309 of file type_vec.hpp.

typedef mediump_float_t mediump_float

Medium precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.4 Floats
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 63 of file type_float.hpp.

typedef detail::mediump_int_t mediump_int

Medium precision signed integer.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.3 Integers
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 251 of file type_int.hpp.

typedef tvec2<int, mediump> mediump_ivec2

2 components vector of medium precision signed integer numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 118 of file type_vec.hpp.

typedef tvec3<int, mediump> mediump_ivec3

3 components vector of medium precision signed integer numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 228 of file type_vec.hpp.

typedef tvec4<int, mediump> mediump_ivec4

4 components vector of medium precision signed integer numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 327 of file type_vec.hpp.

typedef tmat2x2< float, mediump > mediump_mat2

2 columns of 2 components matrix of medium precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 72 of file type_mat.hpp.

typedef tmat2x2< float, mediump > mediump_mat2x2

2 columns of 2 components matrix of medium precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 93 of file type_mat.hpp.

typedef tmat2x3< float, mediump > mediump_mat2x3

2 columns of 3 components matrix of medium precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 119 of file type_mat.hpp.

typedef tmat2x4< float, mediump > mediump_mat2x4

2 columns of 4 components matrix of medium precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 145 of file type_mat.hpp.

typedef tmat3x3< float, mediump > mediump_mat3

3 columns of 3 components matrix of medium precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 197 of file type_mat.hpp.

typedef tmat3x2< float, mediump > mediump_mat3x2

3 columns of 2 components matrix of medium precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 171 of file type_mat.hpp.

typedef tmat3x3< float, mediump > mediump_mat3x3

3 columns of 3 components matrix of medium precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 218 of file type_mat.hpp.

typedef tmat3x4< float, mediump > mediump_mat3x4

3 columns of 4 components matrix of medium precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 244 of file type_mat.hpp.

typedef tmat4x4< float, mediump > mediump_mat4

4 columns of 4 components matrix of medium precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 323 of file type_mat.hpp.

typedef tmat4x2< float, mediump > mediump_mat4x2

4 columns of 2 components matrix of medium precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 270 of file type_mat.hpp.

typedef tmat4x3< float, mediump > mediump_mat4x3

4 columns of 3 components matrix of medium precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 296 of file type_mat.hpp.

typedef tmat4x4< float, mediump > mediump_mat4x4

4 columns of 4 components matrix of medium precision floating-point numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.6 Matrices
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 344 of file type_mat.hpp.

typedef detail::mediump_uint_t mediump_uint

Medium precision unsigned integer.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.3 Integers
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 272 of file type_int.hpp.

typedef tvec2<uint, mediump> mediump_uvec2

2 components vector of medium precision unsigned integer numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 139 of file type_vec.hpp.

typedef tvec3<uint, mediump> mediump_uvec3

3 components vector of medium precision unsigned integer numbers.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 249 of file type_vec.hpp.

typedef tvec4<uint, mediump> mediump_uvec4

4 components vector of medium precision unsigned integer numbers.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier

Definition at line 345 of file type_vec.hpp.

typedef tvec2< float, mediump > mediump_vec2

2 components vector of medium single-precision floating-point numbers.

Medium Single-precision floating-point vector of 2 components.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier
Precision types

Definition at line 76 of file type_vec.hpp.

typedef tvec3< float, mediump > mediump_vec3

3 components vector of medium single-precision floating-point numbers.

Medium Single-precision floating-point vector of 3 components.

There is no guarantee on the actual precision.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier
Precision types

Definition at line 186 of file type_vec.hpp.

typedef tvec4< float, mediump > mediump_vec4

4 components vector of medium single-precision floating-point numbers.

Medium Single-precision floating-point vector of 4 components.

See also
GLSL 4.20.8 specification, section 4.1.5 Vectors
GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier
Precision types

Definition at line 291 of file type_vec.hpp.

typedef unsigned int uint

Unsigned integer type.

See also
GLSL 4.20.8 specification, section 4.1.3 Integers

Definition at line 308 of file type_int.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00165.html000066400000000000000000000040661356361734700216540ustar00rootroot00000000000000 0.9.7: Template types
Template types
GLM Core

The generic template types used as the basis for the core types.

These types are all templates used to define the actual Types. These templetes are implementation details of GLM types and should not be used explicitly.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00166.html000066400000000000000000001364771356361734700216710ustar00rootroot00000000000000 0.9.7: GLM_GTC_bitfield
Functions
GLM_GTC_bitfield
GTC Extensions (Stable)

Functions

template<typename genIUType >
GLM_FUNC_DECL genIUType bitfieldFillOne (genIUType Value, int FirstBit, int BitCount)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > bitfieldFillOne (vecType< T, P > const &Value, int FirstBit, int BitCount)
 
template<typename genIUType >
GLM_FUNC_DECL genIUType bitfieldFillZero (genIUType Value, int FirstBit, int BitCount)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > bitfieldFillZero (vecType< T, P > const &Value, int FirstBit, int BitCount)
 
GLM_FUNC_DECL int16 bitfieldInterleave (int8 x, int8 y)
 
GLM_FUNC_DECL uint16 bitfieldInterleave (uint8 x, uint8 y)
 
GLM_FUNC_DECL int32 bitfieldInterleave (int16 x, int16 y)
 
GLM_FUNC_DECL uint32 bitfieldInterleave (uint16 x, uint16 y)
 
GLM_FUNC_DECL int64 bitfieldInterleave (int32 x, int32 y)
 
GLM_FUNC_DECL uint64 bitfieldInterleave (uint32 x, uint32 y)
 
GLM_FUNC_DECL int32 bitfieldInterleave (int8 x, int8 y, int8 z)
 
GLM_FUNC_DECL uint32 bitfieldInterleave (uint8 x, uint8 y, uint8 z)
 
GLM_FUNC_DECL int64 bitfieldInterleave (int16 x, int16 y, int16 z)
 
GLM_FUNC_DECL uint64 bitfieldInterleave (uint16 x, uint16 y, uint16 z)
 
GLM_FUNC_DECL int64 bitfieldInterleave (int32 x, int32 y, int32 z)
 
GLM_FUNC_DECL uint64 bitfieldInterleave (uint32 x, uint32 y, uint32 z)
 
GLM_FUNC_DECL int32 bitfieldInterleave (int8 x, int8 y, int8 z, int8 w)
 
GLM_FUNC_DECL uint32 bitfieldInterleave (uint8 x, uint8 y, uint8 z, uint8 w)
 
GLM_FUNC_DECL int64 bitfieldInterleave (int16 x, int16 y, int16 z, int16 w)
 
GLM_FUNC_DECL uint64 bitfieldInterleave (uint16 x, uint16 y, uint16 z, uint16 w)
 
template<typename genIUType >
GLM_FUNC_DECL genIUType bitfieldRotateLeft (genIUType In, int Shift)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > bitfieldRotateLeft (vecType< T, P > const &In, int Shift)
 
template<typename genIUType >
GLM_FUNC_DECL genIUType bitfieldRotateRight (genIUType In, int Shift)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > bitfieldRotateRight (vecType< T, P > const &In, int Shift)
 
template<typename genIUType >
GLM_FUNC_DECL genIUType mask (genIUType Bits)
 
template<typename T , precision P, template< typename, precision > class vecIUType>
GLM_FUNC_DECL vecIUType< T, P > mask (vecIUType< T, P > const &v)
 

Detailed Description

Allow to perform bit operations on integer values.

<glm/gtc/bitfield.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL genIUType glm::bitfieldFillOne ( genIUType  Value,
int  FirstBit,
int  BitCount 
)

Set to 1 a range of bits.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL vecType<T, P> glm::bitfieldFillOne ( vecType< T, P > const &  Value,
int  FirstBit,
int  BitCount 
)

Set to 1 a range of bits.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL genIUType glm::bitfieldFillZero ( genIUType  Value,
int  FirstBit,
int  BitCount 
)

Set to 0 a range of bits.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL vecType<T, P> glm::bitfieldFillZero ( vecType< T, P > const &  Value,
int  FirstBit,
int  BitCount 
)

Set to 0 a range of bits.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL int16 glm::bitfieldInterleave ( int8  x,
int8  y 
)

Interleaves the bits of x and y.

The first bit is the first bit of x followed by the first bit of y. The other bits are interleaved following the previous sequence.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL uint16 glm::bitfieldInterleave ( uint8  x,
uint8  y 
)

Interleaves the bits of x and y.

The first bit is the first bit of x followed by the first bit of y. The other bits are interleaved following the previous sequence.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL int32 glm::bitfieldInterleave ( int16  x,
int16  y 
)

Interleaves the bits of x and y.

The first bit is the first bit of x followed by the first bit of y. The other bits are interleaved following the previous sequence.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL uint32 glm::bitfieldInterleave ( uint16  x,
uint16  y 
)

Interleaves the bits of x and y.

The first bit is the first bit of x followed by the first bit of y. The other bits are interleaved following the previous sequence.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL int64 glm::bitfieldInterleave ( int32  x,
int32  y 
)

Interleaves the bits of x and y.

The first bit is the first bit of x followed by the first bit of y. The other bits are interleaved following the previous sequence.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL uint64 glm::bitfieldInterleave ( uint32  x,
uint32  y 
)

Interleaves the bits of x and y.

The first bit is the first bit of x followed by the first bit of y. The other bits are interleaved following the previous sequence.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL int32 glm::bitfieldInterleave ( int8  x,
int8  y,
int8  z 
)

Interleaves the bits of x, y and z.

The first bit is the first bit of x followed by the first bit of y and the first bit of z. The other bits are interleaved following the previous sequence.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL uint32 glm::bitfieldInterleave ( uint8  x,
uint8  y,
uint8  z 
)

Interleaves the bits of x, y and z.

The first bit is the first bit of x followed by the first bit of y and the first bit of z. The other bits are interleaved following the previous sequence.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL int64 glm::bitfieldInterleave ( int16  x,
int16  y,
int16  z 
)

Interleaves the bits of x, y and z.

The first bit is the first bit of x followed by the first bit of y and the first bit of z. The other bits are interleaved following the previous sequence.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL uint64 glm::bitfieldInterleave ( uint16  x,
uint16  y,
uint16  z 
)

Interleaves the bits of x, y and z.

The first bit is the first bit of x followed by the first bit of y and the first bit of z. The other bits are interleaved following the previous sequence.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL int64 glm::bitfieldInterleave ( int32  x,
int32  y,
int32  z 
)

Interleaves the bits of x, y and z.

The first bit is the first bit of x followed by the first bit of y and the first bit of z. The other bits are interleaved following the previous sequence.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL uint64 glm::bitfieldInterleave ( uint32  x,
uint32  y,
uint32  z 
)

Interleaves the bits of x, y and z.

The first bit is the first bit of x followed by the first bit of y and the first bit of z. The other bits are interleaved following the previous sequence.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL int32 glm::bitfieldInterleave ( int8  x,
int8  y,
int8  z,
int8  w 
)

Interleaves the bits of x, y, z and w.

The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w. The other bits are interleaved following the previous sequence.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL uint32 glm::bitfieldInterleave ( uint8  x,
uint8  y,
uint8  z,
uint8  w 
)

Interleaves the bits of x, y, z and w.

The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w. The other bits are interleaved following the previous sequence.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL int64 glm::bitfieldInterleave ( int16  x,
int16  y,
int16  z,
int16  w 
)

Interleaves the bits of x, y, z and w.

The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w. The other bits are interleaved following the previous sequence.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL uint64 glm::bitfieldInterleave ( uint16  x,
uint16  y,
uint16  z,
uint16  w 
)

Interleaves the bits of x, y, z and w.

The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w. The other bits are interleaved following the previous sequence.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL genIUType glm::bitfieldRotateLeft ( genIUType  In,
int  Shift 
)

Rotate all bits to the left.

All the bits dropped in the left side are inserted back on the right side.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL vecType<T, P> glm::bitfieldRotateLeft ( vecType< T, P > const &  In,
int  Shift 
)

Rotate all bits to the left.

All the bits dropped in the left side are inserted back on the right side.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL genIUType glm::bitfieldRotateRight ( genIUType  In,
int  Shift 
)

Rotate all bits to the right.

All the bits dropped in the right side are inserted back on the left side.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL vecType<T, P> glm::bitfieldRotateRight ( vecType< T, P > const &  In,
int  Shift 
)

Rotate all bits to the right.

All the bits dropped in the right side are inserted back on the left side.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL genIUType glm::mask ( genIUType  Bits)

Build a mask of 'count' bits.

See also
GLM_GTC_bitfield
GLM_FUNC_DECL vecIUType<T, P> glm::mask ( vecIUType< T, P > const &  v)

Build a mask of 'count' bits.

See also
GLM_GTC_bitfield
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00167.html000066400000000000000000000121411356361734700216470ustar00rootroot00000000000000 0.9.7: GLM_GTC_color_space
Functions
GLM_GTC_color_space
GTC Extensions (Stable)

Functions

template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > convertLinearToSRGB (vecType< T, P > const &ColorLinear)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > convertLinearToSRGB (vecType< T, P > const &ColorLinear, T Gamma)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > convertSRGBToLinear (vecType< T, P > const &ColorSRGB)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > convertSRGBToLinear (vecType< T, P > const &ColorSRGB, T Gamma)
 

Detailed Description

Allow to perform bit operations on integer values.

<glm/gtc/color.hpp> need to be included to use these functionalities.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00168.html000066400000000000000000001043761356361734700216640ustar00rootroot00000000000000 0.9.7: GLM_GTC_constants
Functions
GLM_GTC_constants
GTC Extensions (Stable)

Functions

template<typename genType >
GLM_FUNC_DECL genType e ()
 
template<typename genType >
GLM_FUNC_DECL genType epsilon ()
 
template<typename genType >
GLM_FUNC_DECL genType euler ()
 
template<typename genType >
GLM_FUNC_DECL genType four_over_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType golden_ratio ()
 
template<typename genType >
GLM_FUNC_DECL genType half_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType ln_ln_two ()
 
template<typename genType >
GLM_FUNC_DECL genType ln_ten ()
 
template<typename genType >
GLM_FUNC_DECL genType ln_two ()
 
template<typename genType >
GLM_FUNC_DECL genType one ()
 
template<typename genType >
GLM_FUNC_DECL genType one_over_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType one_over_root_two ()
 
template<typename genType >
GLM_FUNC_DECL genType one_over_two_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType pi ()
 
template<typename genType >
GLM_FUNC_DECL genType quarter_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType root_five ()
 
template<typename genType >
GLM_FUNC_DECL genType root_half_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType root_ln_four ()
 
template<typename genType >
GLM_FUNC_DECL genType root_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType root_three ()
 
template<typename genType >
GLM_FUNC_DECL genType root_two ()
 
template<typename genType >
GLM_FUNC_DECL genType root_two_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType third ()
 
template<typename genType >
GLM_FUNC_DECL genType three_over_two_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType two_over_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType two_over_root_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType two_pi ()
 
template<typename genType >
GLM_FUNC_DECL genType two_thirds ()
 
template<typename genType >
GLM_FUNC_DECL genType zero ()
 

Detailed Description

Provide a list of constants and precomputed useful values.

<glm/gtc/constants.hpp> need to be included to use these features.

Function Documentation

GLM_FUNC_DECL genType glm::e ( )

Return e constant.

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::epsilon ( )

Return the epsilon constant for floating point types.

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::euler ( )

Return Euler's constant.

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::four_over_pi ( )

Return 4 / pi.

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::golden_ratio ( )

Return the golden ratio constant.

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::half_pi ( )

Return pi / 2.

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::ln_ln_two ( )

Return ln(ln(2)).

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::ln_ten ( )

Return ln(10).

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::ln_two ( )

Return ln(2).

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::one ( )

Return 1.

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::one_over_pi ( )

Return 1 / pi.

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::one_over_root_two ( )

Return 1 / sqrt(2).

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::one_over_two_pi ( )

Return 1 / (pi * 2).

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::pi ( )

Return the pi constant.

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::quarter_pi ( )

Return pi / 4.

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::root_five ( )

Return sqrt(5).

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::root_half_pi ( )

Return sqrt(pi / 2).

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::root_ln_four ( )

Return sqrt(ln(4)).

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::root_pi ( )

Return square root of pi.

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::root_three ( )

Return sqrt(3).

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::root_two ( )

Return sqrt(2).

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::root_two_pi ( )

Return sqrt(2 * pi).

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::third ( )

Return 1 / 3.

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::three_over_two_pi ( )

Return pi / 2 * 3.

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::two_over_pi ( )

Return 2 / pi.

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::two_over_root_pi ( )

Return 2 / sqrt(pi).

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::two_pi ( )

Return pi * 2.

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::two_thirds ( )

Return 2 / 3.

See also
GLM_GTC_constants
GLM_FUNC_DECL genType glm::zero ( )

Return 0.

See also
GLM_GTC_constants
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00169.html000066400000000000000000000233571356361734700216640ustar00rootroot00000000000000 0.9.7: GLM_GTC_epsilon
Functions
GLM_GTC_epsilon
GTC Extensions (Stable)

Functions

template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > epsilonEqual (vecType< T, P > const &x, vecType< T, P > const &y, T const &epsilon)
 
template<typename genType >
GLM_FUNC_DECL bool epsilonEqual (genType const &x, genType const &y, genType const &epsilon)
 
template<typename genType >
GLM_FUNC_DECL genType::boolType epsilonNotEqual (genType const &x, genType const &y, typename genType::value_type const &epsilon)
 
template<typename genType >
GLM_FUNC_DECL bool epsilonNotEqual (genType const &x, genType const &y, genType const &epsilon)
 

Detailed Description

Comparison functions for a user defined epsilon values.

<glm/gtc/epsilon.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL vecType<bool, P> glm::epsilonEqual ( vecType< T, P > const &  x,
vecType< T, P > const &  y,
T const &  epsilon 
)

Returns the component-wise comparison of |x - y| < epsilon.

True if this expression is satisfied.

See also
GLM_GTC_epsilon
GLM_FUNC_DECL bool glm::epsilonEqual ( genType const &  x,
genType const &  y,
genType const &  epsilon 
)

Returns the component-wise comparison of |x - y| < epsilon.

True if this expression is satisfied.

See also
GLM_GTC_epsilon
GLM_FUNC_DECL genType::boolType glm::epsilonNotEqual ( genType const &  x,
genType const &  y,
typename genType::value_type const &  epsilon 
)

Returns the component-wise comparison of |x - y| < epsilon.

True if this expression is not satisfied.

See also
GLM_GTC_epsilon
GLM_FUNC_DECL bool glm::epsilonNotEqual ( genType const &  x,
genType const &  y,
genType const &  epsilon 
)

Returns the component-wise comparison of |x - y| >= epsilon.

True if this expression is not satisfied.

See also
GLM_GTC_epsilon
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00170.html000066400000000000000000000233601356361734700216460ustar00rootroot00000000000000 0.9.7: GLM_GTC_integer
Functions
GLM_GTC_integer
GTC Extensions (Stable)

Functions

template<typename genIUType >
GLM_FUNC_DECL genIUType log2 (genIUType x)
 
template<typename genIUType >
GLM_FUNC_DECL genIUType mod (genIUType x, genIUType y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > mod (vecType< T, P > const &x, T y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > mod (vecType< T, P > const &x, vecType< T, P > const &y)
 

Detailed Description

Allow to perform bit operations on integer values.

<glm/gtc/integer.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL genIUType glm::log2 ( genIUType  x)

Returns the log2 of x for integer values.

Can be reliably using to compute mipmap count from the texture size.

See also
GLM_GTC_integer
GLM_FUNC_DECL genIUType glm::mod ( genIUType  x,
genIUType  y 
)

Modulus.

Returns x % y for each component in x using the floating point value y.

Template Parameters
genIUTypeInteger-point scalar or vector types.
See also
GLM_GTC_integer
GLSL mod man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL vecType< T, P > mod ( vecType< T, P > const &  x,
T  y 
)

Modulus.

Returns x % y for each component in x using the floating point value y.

Template Parameters
TInteger scalar types.
vecTypevector types.
See also
GLM_GTC_integer
GLSL mod man page
GLSL 4.20.8 specification, section 8.3 Common Functions
GLM_FUNC_DECL vecType< T, P > mod ( vecType< T, P > const &  x,
vecType< T, P > const &  y 
)

Modulus.

Returns x % y for each component in x using the floating point value y.

Template Parameters
TInteger scalar types.
vecTypevector types.
See also
GLM_GTC_integer
GLSL mod man page
GLSL 4.20.8 specification, section 8.3 Common Functions
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00171.html000066400000000000000000000215461356361734700216530ustar00rootroot00000000000000 0.9.7: GLM_GTC_matrix_access
Functions
GLM_GTC_matrix_access
GTC Extensions (Stable)

Functions

template<typename genType >
GLM_FUNC_DECL genType::col_type column (genType const &m, length_t index)
 
template<typename genType >
GLM_FUNC_DECL genType column (genType const &m, length_t index, typename genType::col_type const &x)
 
template<typename genType >
GLM_FUNC_DECL genType::row_type row (genType const &m, length_t index)
 
template<typename genType >
GLM_FUNC_DECL genType row (genType const &m, length_t index, typename genType::row_type const &x)
 

Detailed Description

Defines functions to access rows or columns of a matrix easily.

<glm/gtc/matrix_access.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL genType::col_type glm::column ( genType const &  m,
length_t  index 
)

Get a specific column of a matrix.

See also
GLM_GTC_matrix_access
GLM_FUNC_DECL genType glm::column ( genType const &  m,
length_t  index,
typename genType::col_type const &  x 
)

Set a specific column to a matrix.

See also
GLM_GTC_matrix_access
GLM_FUNC_DECL genType::row_type glm::row ( genType const &  m,
length_t  index 
)

Get a specific row of a matrix.

See also
GLM_GTC_matrix_access
GLM_FUNC_DECL genType glm::row ( genType const &  m,
length_t  index,
typename genType::row_type const &  x 
)

Set a specific row to a matrix.

See also
GLM_GTC_matrix_access
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00172.html000066400000000000000000003160341356361734700216530ustar00rootroot00000000000000 0.9.7: GLM_GTC_matrix_integer
Typedefs
GLM_GTC_matrix_integer
GTC Extensions (Stable)

Typedefs

typedef tmat2x2< int, highp > highp_imat2
 
typedef tmat2x2< int, highp > highp_imat2x2
 
typedef tmat2x3< int, highp > highp_imat2x3
 
typedef tmat2x4< int, highp > highp_imat2x4
 
typedef tmat3x3< int, highp > highp_imat3
 
typedef tmat3x2< int, highp > highp_imat3x2
 
typedef tmat3x3< int, highp > highp_imat3x3
 
typedef tmat3x4< int, highp > highp_imat3x4
 
typedef tmat4x4< int, highp > highp_imat4
 
typedef tmat4x2< int, highp > highp_imat4x2
 
typedef tmat4x3< int, highp > highp_imat4x3
 
typedef tmat4x4< int, highp > highp_imat4x4
 
typedef tmat2x2< uint, highp > highp_umat2
 
typedef tmat2x2< uint, highp > highp_umat2x2
 
typedef tmat2x3< uint, highp > highp_umat2x3
 
typedef tmat2x4< uint, highp > highp_umat2x4
 
typedef tmat3x3< uint, highp > highp_umat3
 
typedef tmat3x2< uint, highp > highp_umat3x2
 
typedef tmat3x3< uint, highp > highp_umat3x3
 
typedef tmat3x4< uint, highp > highp_umat3x4
 
typedef tmat4x4< uint, highp > highp_umat4
 
typedef tmat4x2< uint, highp > highp_umat4x2
 
typedef tmat4x3< uint, highp > highp_umat4x3
 
typedef tmat4x4< uint, highp > highp_umat4x4
 
typedef mediump_imat2 imat2
 
typedef mediump_imat2x2 imat2x2
 
typedef mediump_imat2x3 imat2x3
 
typedef mediump_imat2x4 imat2x4
 
typedef mediump_imat3 imat3
 
typedef mediump_imat3x2 imat3x2
 
typedef mediump_imat3x3 imat3x3
 
typedef mediump_imat3x4 imat3x4
 
typedef mediump_imat4 imat4
 
typedef mediump_imat4x2 imat4x2
 
typedef mediump_imat4x3 imat4x3
 
typedef mediump_imat4x4 imat4x4
 
typedef tmat2x2< int, lowp > lowp_imat2
 
typedef tmat2x2< int, lowp > lowp_imat2x2
 
typedef tmat2x3< int, lowp > lowp_imat2x3
 
typedef tmat2x4< int, lowp > lowp_imat2x4
 
typedef tmat3x3< int, lowp > lowp_imat3
 
typedef tmat3x2< int, lowp > lowp_imat3x2
 
typedef tmat3x3< int, lowp > lowp_imat3x3
 
typedef tmat3x4< int, lowp > lowp_imat3x4
 
typedef tmat4x4< int, lowp > lowp_imat4
 
typedef tmat4x2< int, lowp > lowp_imat4x2
 
typedef tmat4x3< int, lowp > lowp_imat4x3
 
typedef tmat4x4< int, lowp > lowp_imat4x4
 
typedef tmat2x2< uint, lowp > lowp_umat2
 
typedef tmat2x2< uint, lowp > lowp_umat2x2
 
typedef tmat2x3< uint, lowp > lowp_umat2x3
 
typedef tmat2x4< uint, lowp > lowp_umat2x4
 
typedef tmat3x3< uint, lowp > lowp_umat3
 
typedef tmat3x2< uint, lowp > lowp_umat3x2
 
typedef tmat3x3< uint, lowp > lowp_umat3x3
 
typedef tmat3x4< uint, lowp > lowp_umat3x4
 
typedef tmat4x4< uint, lowp > lowp_umat4
 
typedef tmat4x2< uint, lowp > lowp_umat4x2
 
typedef tmat4x3< uint, lowp > lowp_umat4x3
 
typedef tmat4x4< uint, lowp > lowp_umat4x4
 
typedef tmat2x2< int, mediump > mediump_imat2
 
typedef tmat2x2< int, mediump > mediump_imat2x2
 
typedef tmat2x3< int, mediump > mediump_imat2x3
 
typedef tmat2x4< int, mediump > mediump_imat2x4
 
typedef tmat3x3< int, mediump > mediump_imat3
 
typedef tmat3x2< int, mediump > mediump_imat3x2
 
typedef tmat3x3< int, mediump > mediump_imat3x3
 
typedef tmat3x4< int, mediump > mediump_imat3x4
 
typedef tmat4x4< int, mediump > mediump_imat4
 
typedef tmat4x2< int, mediump > mediump_imat4x2
 
typedef tmat4x3< int, mediump > mediump_imat4x3
 
typedef tmat4x4< int, mediump > mediump_imat4x4
 
typedef tmat2x2< uint, mediump > mediump_umat2
 
typedef tmat2x2< uint, mediump > mediump_umat2x2
 
typedef tmat2x3< uint, mediump > mediump_umat2x3
 
typedef tmat2x4< uint, mediump > mediump_umat2x4
 
typedef tmat3x3< uint, mediump > mediump_umat3
 
typedef tmat3x2< uint, mediump > mediump_umat3x2
 
typedef tmat3x3< uint, mediump > mediump_umat3x3
 
typedef tmat3x4< uint, mediump > mediump_umat3x4
 
typedef tmat4x4< uint, mediump > mediump_umat4
 
typedef tmat4x2< uint, mediump > mediump_umat4x2
 
typedef tmat4x3< uint, mediump > mediump_umat4x3
 
typedef tmat4x4< uint, mediump > mediump_umat4x4
 
typedef mediump_umat2 umat2
 
typedef mediump_umat2x2 umat2x2
 
typedef mediump_umat2x3 umat2x3
 
typedef mediump_umat2x4 umat2x4
 
typedef mediump_umat3 umat3
 
typedef mediump_umat3x2 umat3x2
 
typedef mediump_umat3x3 umat3x3
 
typedef mediump_umat3x4 umat3x4
 
typedef mediump_umat4 umat4
 
typedef mediump_umat4x2 umat4x2
 
typedef mediump_umat4x3 umat4x3
 
typedef mediump_umat4x4 umat4x4
 

Detailed Description

Defines a number of matrices with integer types.

<glm/gtc/matrix_integer.hpp> need to be included to use these functionalities.

Typedef Documentation

typedef tmat2x2<int, highp> highp_imat2

High-precision signed integer 2x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 65 of file matrix_integer.hpp.

typedef tmat2x2<int, highp> highp_imat2x2

High-precision signed integer 2x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 77 of file matrix_integer.hpp.

typedef tmat2x3<int, highp> highp_imat2x3

High-precision signed integer 2x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 81 of file matrix_integer.hpp.

typedef tmat2x4<int, highp> highp_imat2x4

High-precision signed integer 2x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 85 of file matrix_integer.hpp.

typedef tmat3x3<int, highp> highp_imat3

High-precision signed integer 3x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 69 of file matrix_integer.hpp.

typedef tmat3x2<int, highp> highp_imat3x2

High-precision signed integer 3x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 89 of file matrix_integer.hpp.

typedef tmat3x3<int, highp> highp_imat3x3

High-precision signed integer 3x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 93 of file matrix_integer.hpp.

typedef tmat3x4<int, highp> highp_imat3x4

High-precision signed integer 3x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 97 of file matrix_integer.hpp.

typedef tmat4x4<int, highp> highp_imat4

High-precision signed integer 4x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 73 of file matrix_integer.hpp.

typedef tmat4x2<int, highp> highp_imat4x2

High-precision signed integer 4x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 101 of file matrix_integer.hpp.

typedef tmat4x3<int, highp> highp_imat4x3

High-precision signed integer 4x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 105 of file matrix_integer.hpp.

typedef tmat4x4<int, highp> highp_imat4x4

High-precision signed integer 4x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 109 of file matrix_integer.hpp.

typedef tmat2x2<uint, highp> highp_umat2

High-precision unsigned integer 2x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 214 of file matrix_integer.hpp.

typedef tmat2x2<uint, highp> highp_umat2x2

High-precision unsigned integer 2x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 226 of file matrix_integer.hpp.

typedef tmat2x3<uint, highp> highp_umat2x3

High-precision unsigned integer 2x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 230 of file matrix_integer.hpp.

typedef tmat2x4<uint, highp> highp_umat2x4

High-precision unsigned integer 2x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 234 of file matrix_integer.hpp.

typedef tmat3x3<uint, highp> highp_umat3

High-precision unsigned integer 3x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 218 of file matrix_integer.hpp.

typedef tmat3x2<uint, highp> highp_umat3x2

High-precision unsigned integer 3x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 238 of file matrix_integer.hpp.

typedef tmat3x3<uint, highp> highp_umat3x3

High-precision unsigned integer 3x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 242 of file matrix_integer.hpp.

typedef tmat3x4<uint, highp> highp_umat3x4

High-precision unsigned integer 3x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 246 of file matrix_integer.hpp.

typedef tmat4x4<uint, highp> highp_umat4

High-precision unsigned integer 4x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 222 of file matrix_integer.hpp.

typedef tmat4x2<uint, highp> highp_umat4x2

High-precision unsigned integer 4x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 250 of file matrix_integer.hpp.

typedef tmat4x3<uint, highp> highp_umat4x3

High-precision unsigned integer 4x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 254 of file matrix_integer.hpp.

typedef tmat4x4<uint, highp> highp_umat4x4

High-precision unsigned integer 4x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 258 of file matrix_integer.hpp.

typedef mediump_imat2 imat2

Signed integer 2x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 390 of file matrix_integer.hpp.

typedef mediump_imat2x2 imat2x2

Signed integer 2x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 402 of file matrix_integer.hpp.

typedef mediump_imat2x3 imat2x3

Signed integer 2x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 406 of file matrix_integer.hpp.

typedef mediump_imat2x4 imat2x4

Signed integer 2x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 410 of file matrix_integer.hpp.

typedef mediump_imat3 imat3

Signed integer 3x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 394 of file matrix_integer.hpp.

typedef mediump_imat3x2 imat3x2

Signed integer 3x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 414 of file matrix_integer.hpp.

typedef mediump_imat3x3 imat3x3

Signed integer 3x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 418 of file matrix_integer.hpp.

typedef mediump_imat3x4 imat3x4

Signed integer 3x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 422 of file matrix_integer.hpp.

typedef mediump_imat4 imat4

Signed integer 4x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 398 of file matrix_integer.hpp.

typedef mediump_imat4x2 imat4x2

Signed integer 4x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 426 of file matrix_integer.hpp.

typedef mediump_imat4x3 imat4x3

Signed integer 4x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 430 of file matrix_integer.hpp.

typedef mediump_imat4x4 imat4x4

Signed integer 4x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 434 of file matrix_integer.hpp.

typedef tmat2x2<int, lowp> lowp_imat2

Low-precision signed integer 2x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 164 of file matrix_integer.hpp.

typedef tmat2x2<int, lowp> lowp_imat2x2

Low-precision signed integer 2x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 177 of file matrix_integer.hpp.

typedef tmat2x3<int, lowp> lowp_imat2x3

Low-precision signed integer 2x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 181 of file matrix_integer.hpp.

typedef tmat2x4<int, lowp> lowp_imat2x4

Low-precision signed integer 2x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 185 of file matrix_integer.hpp.

typedef tmat3x3<int, lowp> lowp_imat3

Low-precision signed integer 3x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 168 of file matrix_integer.hpp.

typedef tmat3x2<int, lowp> lowp_imat3x2

Low-precision signed integer 3x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 189 of file matrix_integer.hpp.

typedef tmat3x3<int, lowp> lowp_imat3x3

Low-precision signed integer 3x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 193 of file matrix_integer.hpp.

typedef tmat3x4<int, lowp> lowp_imat3x4

Low-precision signed integer 3x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 197 of file matrix_integer.hpp.

typedef tmat4x4<int, lowp> lowp_imat4

Low-precision signed integer 4x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 172 of file matrix_integer.hpp.

typedef tmat4x2<int, lowp> lowp_imat4x2

Low-precision signed integer 4x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 201 of file matrix_integer.hpp.

typedef tmat4x3<int, lowp> lowp_imat4x3

Low-precision signed integer 4x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 205 of file matrix_integer.hpp.

typedef tmat4x4<int, lowp> lowp_imat4x4

Low-precision signed integer 4x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 209 of file matrix_integer.hpp.

typedef tmat2x2<uint, lowp> lowp_umat2

Low-precision unsigned integer 2x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 313 of file matrix_integer.hpp.

typedef tmat2x2<uint, lowp> lowp_umat2x2

Low-precision unsigned integer 2x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 326 of file matrix_integer.hpp.

typedef tmat2x3<uint, lowp> lowp_umat2x3

Low-precision unsigned integer 2x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 330 of file matrix_integer.hpp.

typedef tmat2x4<uint, lowp> lowp_umat2x4

Low-precision unsigned integer 2x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 334 of file matrix_integer.hpp.

typedef tmat3x3<uint, lowp> lowp_umat3

Low-precision unsigned integer 3x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 317 of file matrix_integer.hpp.

typedef tmat3x2<uint, lowp> lowp_umat3x2

Low-precision unsigned integer 3x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 338 of file matrix_integer.hpp.

typedef tmat3x3<uint, lowp> lowp_umat3x3

Low-precision unsigned integer 3x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 342 of file matrix_integer.hpp.

typedef tmat3x4<uint, lowp> lowp_umat3x4

Low-precision unsigned integer 3x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 346 of file matrix_integer.hpp.

typedef tmat4x4<uint, lowp> lowp_umat4

Low-precision unsigned integer 4x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 321 of file matrix_integer.hpp.

typedef tmat4x2<uint, lowp> lowp_umat4x2

Low-precision unsigned integer 4x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 350 of file matrix_integer.hpp.

typedef tmat4x3<uint, lowp> lowp_umat4x3

Low-precision unsigned integer 4x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 354 of file matrix_integer.hpp.

typedef tmat4x4<uint, lowp> lowp_umat4x4

Low-precision unsigned integer 4x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 358 of file matrix_integer.hpp.

typedef tmat2x2<int, mediump> mediump_imat2

Medium-precision signed integer 2x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 114 of file matrix_integer.hpp.

typedef tmat2x2<int, mediump> mediump_imat2x2

Medium-precision signed integer 2x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 127 of file matrix_integer.hpp.

typedef tmat2x3<int, mediump> mediump_imat2x3

Medium-precision signed integer 2x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 131 of file matrix_integer.hpp.

typedef tmat2x4<int, mediump> mediump_imat2x4

Medium-precision signed integer 2x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 135 of file matrix_integer.hpp.

typedef tmat3x3<int, mediump> mediump_imat3

Medium-precision signed integer 3x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 118 of file matrix_integer.hpp.

typedef tmat3x2<int, mediump> mediump_imat3x2

Medium-precision signed integer 3x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 139 of file matrix_integer.hpp.

typedef tmat3x3<int, mediump> mediump_imat3x3

Medium-precision signed integer 3x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 143 of file matrix_integer.hpp.

typedef tmat3x4<int, mediump> mediump_imat3x4

Medium-precision signed integer 3x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 147 of file matrix_integer.hpp.

typedef tmat4x4<int, mediump> mediump_imat4

Medium-precision signed integer 4x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 122 of file matrix_integer.hpp.

typedef tmat4x2<int, mediump> mediump_imat4x2

Medium-precision signed integer 4x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 151 of file matrix_integer.hpp.

typedef tmat4x3<int, mediump> mediump_imat4x3

Medium-precision signed integer 4x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 155 of file matrix_integer.hpp.

typedef tmat4x4<int, mediump> mediump_imat4x4

Medium-precision signed integer 4x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 159 of file matrix_integer.hpp.

typedef tmat2x2<uint, mediump> mediump_umat2

Medium-precision unsigned integer 2x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 263 of file matrix_integer.hpp.

typedef tmat2x2<uint, mediump> mediump_umat2x2

Medium-precision unsigned integer 2x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 276 of file matrix_integer.hpp.

typedef tmat2x3<uint, mediump> mediump_umat2x3

Medium-precision unsigned integer 2x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 280 of file matrix_integer.hpp.

typedef tmat2x4<uint, mediump> mediump_umat2x4

Medium-precision unsigned integer 2x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 284 of file matrix_integer.hpp.

typedef tmat3x3<uint, mediump> mediump_umat3

Medium-precision unsigned integer 3x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 267 of file matrix_integer.hpp.

typedef tmat3x2<uint, mediump> mediump_umat3x2

Medium-precision unsigned integer 3x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 288 of file matrix_integer.hpp.

typedef tmat3x3<uint, mediump> mediump_umat3x3

Medium-precision unsigned integer 3x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 292 of file matrix_integer.hpp.

typedef tmat3x4<uint, mediump> mediump_umat3x4

Medium-precision unsigned integer 3x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 296 of file matrix_integer.hpp.

typedef tmat4x4<uint, mediump> mediump_umat4

Medium-precision unsigned integer 4x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 271 of file matrix_integer.hpp.

typedef tmat4x2<uint, mediump> mediump_umat4x2

Medium-precision unsigned integer 4x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 300 of file matrix_integer.hpp.

typedef tmat4x3<uint, mediump> mediump_umat4x3

Medium-precision unsigned integer 4x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 304 of file matrix_integer.hpp.

typedef tmat4x4<uint, mediump> mediump_umat4x4

Medium-precision unsigned integer 4x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 308 of file matrix_integer.hpp.

typedef mediump_umat2 umat2

Unsigned integer 2x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 467 of file matrix_integer.hpp.

typedef mediump_umat2x2 umat2x2

Unsigned integer 2x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 479 of file matrix_integer.hpp.

typedef mediump_umat2x3 umat2x3

Unsigned integer 2x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 483 of file matrix_integer.hpp.

typedef mediump_umat2x4 umat2x4

Unsigned integer 2x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 487 of file matrix_integer.hpp.

typedef mediump_umat3 umat3

Unsigned integer 3x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 471 of file matrix_integer.hpp.

typedef mediump_umat3x2 umat3x2

Unsigned integer 3x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 491 of file matrix_integer.hpp.

typedef mediump_umat3x3 umat3x3

Unsigned integer 3x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 495 of file matrix_integer.hpp.

typedef mediump_umat3x4 umat3x4

Unsigned integer 3x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 499 of file matrix_integer.hpp.

typedef mediump_umat4 umat4

Unsigned integer 4x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 475 of file matrix_integer.hpp.

typedef mediump_umat4x2 umat4x2

Unsigned integer 4x2 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 503 of file matrix_integer.hpp.

typedef mediump_umat4x3 umat4x3

Unsigned integer 4x3 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 507 of file matrix_integer.hpp.

typedef mediump_umat4x4 umat4x4

Unsigned integer 4x4 matrix.

See also
GLM_GTC_matrix_integer

Definition at line 511 of file matrix_integer.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00173.html000066400000000000000000000133721356361734700216530ustar00rootroot00000000000000 0.9.7: GLM_GTC_matrix_inverse
Functions
GLM_GTC_matrix_inverse
GTC Extensions (Stable)

Functions

template<typename genType >
GLM_FUNC_DECL genType affineInverse (genType const &m)
 
template<typename genType >
GLM_FUNC_DECL genType inverseTranspose (genType const &m)
 

Detailed Description

Defines additional matrix inverting functions.

<glm/gtc/matrix_inverse.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL genType glm::affineInverse ( genType const &  m)

Fast matrix inverse for affine matrix.

Parameters
mInput matrix to invert.
Template Parameters
genTypeSquared floating-point matrix: half, float or double. Inverse of matrix based of half-precision floating point value is highly innacurate.
See also
GLM_GTC_matrix_inverse
GLM_FUNC_DECL genType glm::inverseTranspose ( genType const &  m)

Compute the inverse transpose of a matrix.

Parameters
mInput matrix to invert transpose.
Template Parameters
genTypeSquared floating-point matrix: half, float or double. Inverse of matrix based of half-precision floating point value is highly innacurate.
See also
GLM_GTC_matrix_inverse
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00174.html000066400000000000000000001711451356361734700216570ustar00rootroot00000000000000 0.9.7: GLM_GTC_matrix_transform
Functions
GLM_GTC_matrix_transform
GTC Extensions (Stable)

Functions

template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > frustum (T left, T right, T bottom, T top, T near, T far)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > infinitePerspective (T fovy, T aspect, T near)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > lookAt (tvec3< T, P > const &eye, tvec3< T, P > const &center, tvec3< T, P > const &up)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > lookAtLH (tvec3< T, P > const &eye, tvec3< T, P > const &center, tvec3< T, P > const &up)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > lookAtRH (tvec3< T, P > const &eye, tvec3< T, P > const &center, tvec3< T, P > const &up)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > ortho (T left, T right, T bottom, T top, T zNear, T zFar)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > ortho (T left, T right, T bottom, T top)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > perspective (T fovy, T aspect, T near, T far)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > perspectiveFov (T fov, T width, T height, T near, T far)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > perspectiveFovLH (T fov, T width, T height, T near, T far)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > perspectiveFovRH (T fov, T width, T height, T near, T far)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > perspectiveLH (T fovy, T aspect, T near, T far)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > perspectiveRH (T fovy, T aspect, T near, T far)
 
template<typename T , precision P, typename U >
GLM_FUNC_DECL tmat4x4< T, P > pickMatrix (tvec2< T, P > const &center, tvec2< T, P > const &delta, tvec4< U, P > const &viewport)
 
template<typename T , typename U , precision P>
GLM_FUNC_DECL tvec3< T, P > project (tvec3< T, P > const &obj, tmat4x4< T, P > const &model, tmat4x4< T, P > const &proj, tvec4< U, P > const &viewport)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > rotate (tmat4x4< T, P > const &m, T angle, tvec3< T, P > const &axis)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > scale (tmat4x4< T, P > const &m, tvec3< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > translate (tmat4x4< T, P > const &m, tvec3< T, P > const &v)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > tweakedInfinitePerspective (T fovy, T aspect, T near)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > tweakedInfinitePerspective (T fovy, T aspect, T near, T ep)
 
template<typename T , typename U , precision P>
GLM_FUNC_DECL tvec3< T, P > unProject (tvec3< T, P > const &win, tmat4x4< T, P > const &model, tmat4x4< T, P > const &proj, tvec4< U, P > const &viewport)
 

Detailed Description

Defines functions that generate common transformation matrices.

The matrices generated by this extension use standard OpenGL fixed-function conventions. For example, the lookAt function generates a transform from world space into the specific eye space that the projective matrix functions (perspective, ortho, etc) are designed to expect. The OpenGL compatibility specifications defines the particular layout of this eye space.

<glm/gtc/matrix_transform.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL tmat4x4<T, defaultp> glm::frustum ( T  left,
T  right,
T  bottom,
T  top,
T  near,
T  far 
)

Creates a frustum matrix.

Parameters
left
right
bottom
top
near
far
Template Parameters
TValue type used to build the matrix. Currently supported: half (not recommanded), float or double.
See also
GLM_GTC_matrix_transform
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::infinitePerspective ( T  fovy,
T  aspect,
T  near 
)

Creates a matrix for a symmetric perspective-view frustum with far plane at infinite.

Parameters
fovySpecifies the field of view angle, in degrees, in the y direction. Expressed in radians.
aspectSpecifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
nearSpecifies the distance from the viewer to the near clipping plane (always positive).
Template Parameters
TValue type used to build the matrix. Currently supported: half (not recommanded), float or double.
See also
GLM_GTC_matrix_transform
GLM_FUNC_DECL tmat4x4<T, P> glm::lookAt ( tvec3< T, P > const &  eye,
tvec3< T, P > const &  center,
tvec3< T, P > const &  up 
)

Build a look at view matrix based on the default handedness.

Parameters
eyePosition of the camera
centerPosition where the camera is looking at
upNormalized up vector, how the camera is oriented. Typically (0, 0, 1)
See also
GLM_GTC_matrix_transform
- frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal) frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal)
GLM_FUNC_DECL tmat4x4<T, P> glm::lookAtLH ( tvec3< T, P > const &  eye,
tvec3< T, P > const &  center,
tvec3< T, P > const &  up 
)

Build a left handed look at view matrix.

Parameters
eyePosition of the camera
centerPosition where the camera is looking at
upNormalized up vector, how the camera is oriented. Typically (0, 0, 1)
See also
GLM_GTC_matrix_transform
- frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal) frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal)
GLM_FUNC_DECL tmat4x4<T, P> glm::lookAtRH ( tvec3< T, P > const &  eye,
tvec3< T, P > const &  center,
tvec3< T, P > const &  up 
)

Build a right handed look at view matrix.

Parameters
eyePosition of the camera
centerPosition where the camera is looking at
upNormalized up vector, how the camera is oriented. Typically (0, 0, 1)
See also
GLM_GTC_matrix_transform
- frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal) frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal)
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::ortho ( T  left,
T  right,
T  bottom,
T  top,
T  zNear,
T  zFar 
)

Creates a matrix for an orthographic parallel viewing volume.

Parameters
left
right
bottom
top
zNear
zFar
Template Parameters
TValue type used to build the matrix. Currently supported: half (not recommanded), float or double.
See also
GLM_GTC_matrix_transform
- glm::ortho(T const & left, T const & right, T const & bottom, T const & top)
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::ortho ( T  left,
T  right,
T  bottom,
T  top 
)

Creates a matrix for projecting two-dimensional coordinates onto the screen.

Parameters
left
right
bottom
top
Template Parameters
TValue type used to build the matrix. Currently supported: half (not recommanded), float or double.
See also
GLM_GTC_matrix_transform
- glm::ortho(T const & left, T const & right, T const & bottom, T const & top, T const & zNear, T const & zFar)
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::perspective ( T  fovy,
T  aspect,
T  near,
T  far 
)

Creates a matrix for a symetric perspective-view frustum based on the default handedness.

Parameters
fovySpecifies the field of view angle in the y direction. Expressed in radians.
aspectSpecifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
nearSpecifies the distance from the viewer to the near clipping plane (always positive).
farSpecifies the distance from the viewer to the far clipping plane (always positive).
Template Parameters
TValue type used to build the matrix. Currently supported: half (not recommanded), float or double.
See also
GLM_GTC_matrix_transform
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::perspectiveFov ( T  fov,
T  width,
T  height,
T  near,
T  far 
)

Builds a perspective projection matrix based on a field of view and the default handedness.

Parameters
fovExpressed in radians.
width
height
nearSpecifies the distance from the viewer to the near clipping plane (always positive).
farSpecifies the distance from the viewer to the far clipping plane (always positive).
Template Parameters
TValue type used to build the matrix. Currently supported: half (not recommanded), float or double.
See also
GLM_GTC_matrix_transform
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::perspectiveFovLH ( T  fov,
T  width,
T  height,
T  near,
T  far 
)

Builds a left handed perspective projection matrix based on a field of view.

Parameters
fovExpressed in radians.
width
height
nearSpecifies the distance from the viewer to the near clipping plane (always positive).
farSpecifies the distance from the viewer to the far clipping plane (always positive).
Template Parameters
TValue type used to build the matrix. Currently supported: half (not recommanded), float or double.
See also
GLM_GTC_matrix_transform
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::perspectiveFovRH ( T  fov,
T  width,
T  height,
T  near,
T  far 
)

Builds a right handed perspective projection matrix based on a field of view.

Parameters
fovExpressed in radians.
width
height
nearSpecifies the distance from the viewer to the near clipping plane (always positive).
farSpecifies the distance from the viewer to the far clipping plane (always positive).
Template Parameters
TValue type used to build the matrix. Currently supported: half (not recommanded), float or double.
See also
GLM_GTC_matrix_transform
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::perspectiveLH ( T  fovy,
T  aspect,
T  near,
T  far 
)

Creates a matrix for a left handed, symetric perspective-view frustum.

Parameters
fovySpecifies the field of view angle, in degrees, in the y direction. Expressed in radians.
aspectSpecifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
nearSpecifies the distance from the viewer to the near clipping plane (always positive).
farSpecifies the distance from the viewer to the far clipping plane (always positive).
Template Parameters
TValue type used to build the matrix. Currently supported: half (not recommanded), float or double.
See also
GLM_GTC_matrix_transform
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::perspectiveRH ( T  fovy,
T  aspect,
T  near,
T  far 
)

Creates a matrix for a right handed, symetric perspective-view frustum.

Parameters
fovySpecifies the field of view angle, in degrees, in the y direction. Expressed in radians.
aspectSpecifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
nearSpecifies the distance from the viewer to the near clipping plane (always positive).
farSpecifies the distance from the viewer to the far clipping plane (always positive).
Template Parameters
TValue type used to build the matrix. Currently supported: half (not recommanded), float or double.
See also
GLM_GTC_matrix_transform
GLM_FUNC_DECL tmat4x4<T, P> glm::pickMatrix ( tvec2< T, P > const &  center,
tvec2< T, P > const &  delta,
tvec4< U, P > const &  viewport 
)

Define a picking region.

Parameters
center
delta
viewport
Template Parameters
TNative type used for the computation. Currently supported: half (not recommanded), float or double.
UCurrently supported: Floating-point types and integer types.
See also
GLM_GTC_matrix_transform
GLM_FUNC_DECL tvec3<T, P> glm::project ( tvec3< T, P > const &  obj,
tmat4x4< T, P > const &  model,
tmat4x4< T, P > const &  proj,
tvec4< U, P > const &  viewport 
)

Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates.

Parameters
objSpecify the object coordinates.
modelSpecifies the current modelview matrix
projSpecifies the current projection matrix
viewportSpecifies the current viewport
Returns
Return the computed window coordinates.
Template Parameters
TNative type used for the computation. Currently supported: half (not recommanded), float or double.
UCurrently supported: Floating-point types and integer types.
See also
GLM_GTC_matrix_transform
GLM_FUNC_DECL tmat4x4<T, P> glm::rotate ( tmat4x4< T, P > const &  m,
T  angle,
tvec3< T, P > const &  axis 
)

Builds a rotation 4 * 4 matrix created from an axis vector and an angle.

Parameters
mInput matrix multiplied by this rotation matrix.
angleRotation angle expressed in radians.
axisRotation axis, recommended to be normalized.
Template Parameters
TValue type used to build the matrix. Supported: half, float or double.
See also
GLM_GTC_matrix_transform
- rotate(tmat4x4<T, P> const & m, T angle, T x, T y, T z)
- rotate(T angle, tvec3<T, P> const & v)
GLM_FUNC_DECL tmat4x4<T, P> glm::scale ( tmat4x4< T, P > const &  m,
tvec3< T, P > const &  v 
)

Builds a scale 4 * 4 matrix created from 3 scalars.

Parameters
mInput matrix multiplied by this scale matrix.
vRatio of scaling for each axis.
Template Parameters
TValue type used to build the matrix. Currently supported: half (not recommanded), float or double.
See also
GLM_GTC_matrix_transform
- scale(tmat4x4<T, P> const & m, T x, T y, T z)
- scale(tvec3<T, P> const & v)
GLM_FUNC_DECL tmat4x4<T, P> glm::translate ( tmat4x4< T, P > const &  m,
tvec3< T, P > const &  v 
)

Builds a translation 4 * 4 matrix created from a vector of 3 components.

Parameters
mInput matrix multiplied by this translation matrix.
vCoordinates of a translation vector.
Template Parameters
TValue type used to build the matrix. Currently supported: half (not recommanded), float or double.
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
...
glm::mat4 m = glm::translate(glm::mat4(1.0f), glm::vec3(1.0f));
// m[0][0] == 1.0f, m[0][1] == 0.0f, m[0][2] == 0.0f, m[0][3] == 0.0f
// m[1][0] == 0.0f, m[1][1] == 1.0f, m[1][2] == 0.0f, m[1][3] == 0.0f
// m[2][0] == 0.0f, m[2][1] == 0.0f, m[2][2] == 1.0f, m[2][3] == 0.0f
// m[3][0] == 1.0f, m[3][1] == 1.0f, m[3][2] == 1.0f, m[3][3] == 1.0f
See also
GLM_GTC_matrix_transform
- translate(tmat4x4<T, P> const & m, T x, T y, T z)
- translate(tvec3<T, P> const & v)
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::tweakedInfinitePerspective ( T  fovy,
T  aspect,
T  near 
)

Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.

Parameters
fovySpecifies the field of view angle, in degrees, in the y direction. Expressed in radians.
aspectSpecifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
nearSpecifies the distance from the viewer to the near clipping plane (always positive).
Template Parameters
TValue type used to build the matrix. Currently supported: half (not recommanded), float or double.
See also
GLM_GTC_matrix_transform
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::tweakedInfinitePerspective ( T  fovy,
T  aspect,
T  near,
T  ep 
)

Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.

Parameters
fovySpecifies the field of view angle, in degrees, in the y direction. Expressed in radians.
aspectSpecifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
nearSpecifies the distance from the viewer to the near clipping plane (always positive).
ep
Template Parameters
TValue type used to build the matrix. Currently supported: half (not recommanded), float or double.
See also
GLM_GTC_matrix_transform
GLM_FUNC_DECL tvec3<T, P> glm::unProject ( tvec3< T, P > const &  win,
tmat4x4< T, P > const &  model,
tmat4x4< T, P > const &  proj,
tvec4< U, P > const &  viewport 
)

Map the specified window coordinates (win.x, win.y, win.z) into object coordinates.

Parameters
winSpecify the window coordinates to be mapped.
modelSpecifies the modelview matrix
projSpecifies the projection matrix
viewportSpecifies the viewport
Returns
Returns the computed object coordinates.
Template Parameters
TNative type used for the computation. Currently supported: half (not recommanded), float or double.
UCurrently supported: Floating-point types and integer types.
See also
GLM_GTC_matrix_transform
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00175.html000066400000000000000000000156611356361734700216600ustar00rootroot00000000000000 0.9.7: GLM_GTC_noise
Functions
GLM_GTC_noise
GTC Extensions (Stable)

Functions

template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL T perlin (vecType< T, P > const &p)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL T perlin (vecType< T, P > const &p, vecType< T, P > const &rep)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL T simplex (vecType< T, P > const &p)
 

Detailed Description

Defines 2D, 3D and 4D procedural noise functions Based on the work of Stefan Gustavson and Ashima Arts on "webgl-noise": https://github.com/ashima/webgl-noise Following Stefan Gustavson's paper "Simplex noise demystified": http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf <glm/gtc/noise.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL T glm::perlin ( vecType< T, P > const &  p)

Classic perlin noise.

See also
GLM_GTC_noise
GLM_FUNC_DECL T glm::perlin ( vecType< T, P > const &  p,
vecType< T, P > const &  rep 
)

Periodic perlin noise.

See also
GLM_GTC_noise
GLM_FUNC_DECL T glm::simplex ( vecType< T, P > const &  p)

Simplex noise.

See also
GLM_GTC_noise
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00176.html000066400000000000000000001603521356361734700216570ustar00rootroot00000000000000 0.9.7: GLM_GTC_packing
Functions
GLM_GTC_packing
GTC Extensions (Stable)

Functions

GLM_FUNC_DECL uint32 packF2x11_1x10 (vec3 const &v)
 
GLM_FUNC_DECL uint16 packHalf1x16 (float v)
 
GLM_FUNC_DECL uint64 packHalf4x16 (vec4 const &v)
 
GLM_FUNC_DECL uint32 packI3x10_1x2 (ivec4 const &v)
 
GLM_FUNC_DECL uint16 packSnorm1x16 (float v)
 
GLM_FUNC_DECL uint8 packSnorm1x8 (float s)
 
GLM_FUNC_DECL uint16 packSnorm2x8 (vec2 const &v)
 
GLM_FUNC_DECL uint32 packSnorm3x10_1x2 (vec4 const &v)
 
GLM_FUNC_DECL uint64 packSnorm4x16 (vec4 const &v)
 
GLM_FUNC_DECL uint32 packU3x10_1x2 (uvec4 const &v)
 
GLM_FUNC_DECL uint16 packUnorm1x16 (float v)
 
GLM_FUNC_DECL uint8 packUnorm1x8 (float v)
 
GLM_FUNC_DECL uint16 packUnorm2x8 (vec2 const &v)
 
GLM_FUNC_DECL uint32 packUnorm3x10_1x2 (vec4 const &v)
 
GLM_FUNC_DECL uint64 packUnorm4x16 (vec4 const &v)
 
GLM_FUNC_DECL vec3 unpackF2x11_1x10 (uint32 p)
 
GLM_FUNC_DECL float unpackHalf1x16 (uint16 v)
 
GLM_FUNC_DECL vec4 unpackHalf4x16 (uint64 p)
 
GLM_FUNC_DECL ivec4 unpackI3x10_1x2 (uint32 p)
 
GLM_FUNC_DECL float unpackSnorm1x16 (uint16 p)
 
GLM_FUNC_DECL float unpackSnorm1x8 (uint8 p)
 
GLM_FUNC_DECL vec2 unpackSnorm2x8 (uint16 p)
 
GLM_FUNC_DECL vec4 unpackSnorm3x10_1x2 (uint32 p)
 
GLM_FUNC_DECL vec4 unpackSnorm4x16 (uint64 p)
 
GLM_FUNC_DECL uvec4 unpackU3x10_1x2 (uint32 p)
 
GLM_FUNC_DECL float unpackUnorm1x16 (uint16 p)
 
GLM_FUNC_DECL float unpackUnorm1x8 (uint8 p)
 
GLM_FUNC_DECL vec2 unpackUnorm2x8 (uint16 p)
 
GLM_FUNC_DECL vec4 unpackUnorm3x10_1x2 (uint32 p)
 
GLM_FUNC_DECL vec4 unpackUnorm4x16 (uint64 p)
 

Detailed Description

This extension provides a set of function to convert vertors to packed formats.

<glm/gtc/packing.hpp> need to be included to use these features.

Function Documentation

GLM_FUNC_DECL uint32 glm::packF2x11_1x10 ( vec3 const &  v)

First, converts the first two components of the normalized floating-point value v into 11-bit signless floating-point values.

Then, converts the third component of the normalized floating-point value v into a 10-bit signless floating-point value. Then, the results are packed into the returned 32-bit unsigned integer.

The first vector component specifies the 11 least-significant bits of the result; the last component specifies the 10 most-significant bits.

See also
GLM_GTC_packing
vec3 unpackF2x11_1x10(uint32 const & p)
GLM_FUNC_DECL uint16 glm::packHalf1x16 ( float  v)

Returns an unsigned integer obtained by converting the components of a floating-point scalar to the 16-bit floating-point representation found in the OpenGL Specification, and then packing this 16-bit value into a 16-bit unsigned integer.

See also
GLM_GTC_packing
uint32 packHalf2x16(vec2 const & v)
uint64 packHalf4x16(vec4 const & v)
GLSL packHalf2x16 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL uint64 glm::packHalf4x16 ( vec4 const &  v)

Returns an unsigned integer obtained by converting the components of a four-component floating-point vector to the 16-bit floating-point representation found in the OpenGL Specification, and then packing these four 16-bit values into a 64-bit unsigned integer.

The first vector component specifies the 16 least-significant bits of the result; the forth component specifies the 16 most-significant bits.

See also
GLM_GTC_packing
uint16 packHalf1x16(float const & v)
uint32 packHalf2x16(vec2 const & v)
GLSL packHalf2x16 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL uint32 glm::packI3x10_1x2 ( ivec4 const &  v)

Returns an unsigned integer obtained by converting the components of a four-component signed integer vector to the 10-10-10-2-bit signed integer representation found in the OpenGL Specification, and then packing these four values into a 32-bit unsigned integer.

The first vector component specifies the 10 least-significant bits of the result; the forth component specifies the 2 most-significant bits.

See also
GLM_GTC_packing
uint32 packI3x10_1x2(uvec4 const & v)
uint32 packSnorm3x10_1x2(vec4 const & v)
uint32 packUnorm3x10_1x2(vec4 const & v)
ivec4 unpackI3x10_1x2(uint32 const & p)
GLM_FUNC_DECL uint16 glm::packSnorm1x16 ( float  v)

First, converts the normalized floating-point value v into 16-bit integer value.

Then, the results are packed into the returned 16-bit unsigned integer.

The conversion to fixed point is done as follows: packSnorm1x8: round(clamp(s, -1, +1) * 32767.0)

See also
GLM_GTC_packing
uint32 packSnorm2x16(vec2 const & v)
uint64 packSnorm4x16(vec4 const & v)
GLSL packSnorm4x8 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL uint8 glm::packSnorm1x8 ( float  s)

First, converts the normalized floating-point value v into 8-bit integer value.

Then, the results are packed into the returned 8-bit unsigned integer.

The conversion to fixed point is done as follows: packSnorm1x8: round(clamp(s, -1, +1) * 127.0)

See also
GLM_GTC_packing
uint16 packSnorm2x8(vec2 const & v)
uint32 packSnorm4x8(vec4 const & v)
GLSL packSnorm4x8 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL uint16 glm::packSnorm2x8 ( vec2 const &  v)

First, converts each component of the normalized floating-point value v into 8-bit integer values.

Then, the results are packed into the returned 16-bit unsigned integer.

The conversion for component c of v to fixed point is done as follows: packSnorm2x8: round(clamp(c, -1, +1) * 127.0)

The first component of the vector will be written to the least significant bits of the output; the last component will be written to the most significant bits.

See also
GLM_GTC_packing
uint8 packSnorm1x8(float const & v)
uint32 packSnorm4x8(vec4 const & v)
GLSL packSnorm4x8 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL uint32 glm::packSnorm3x10_1x2 ( vec4 const &  v)

First, converts the first three components of the normalized floating-point value v into 10-bit signed integer values.

Then, converts the forth component of the normalized floating-point value v into 2-bit signed integer values. Then, the results are packed into the returned 32-bit unsigned integer.

The conversion for component c of v to fixed point is done as follows: packSnorm3x10_1x2(xyz): round(clamp(c, -1, +1) * 511.0) packSnorm3x10_1x2(w): round(clamp(c, -1, +1) * 1.0)

The first vector component specifies the 10 least-significant bits of the result; the forth component specifies the 2 most-significant bits.

See also
GLM_GTC_packing
vec4 unpackSnorm3x10_1x2(uint32 const & p)
uint32 packUnorm3x10_1x2(vec4 const & v)
uint32 packU3x10_1x2(uvec4 const & v)
uint32 packI3x10_1x2(ivec4 const & v)
GLM_FUNC_DECL uint64 glm::packSnorm4x16 ( vec4 const &  v)

First, converts each component of the normalized floating-point value v into 16-bit integer values.

Then, the results are packed into the returned 64-bit unsigned integer.

The conversion for component c of v to fixed point is done as follows: packSnorm2x8: round(clamp(c, -1, +1) * 32767.0)

The first component of the vector will be written to the least significant bits of the output; the last component will be written to the most significant bits.

See also
GLM_GTC_packing
uint16 packSnorm1x16(float const & v)
uint32 packSnorm2x16(vec2 const & v)
GLSL packSnorm4x8 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL uint32 glm::packU3x10_1x2 ( uvec4 const &  v)

Returns an unsigned integer obtained by converting the components of a four-component unsigned integer vector to the 10-10-10-2-bit unsigned integer representation found in the OpenGL Specification, and then packing these four values into a 32-bit unsigned integer.

The first vector component specifies the 10 least-significant bits of the result; the forth component specifies the 2 most-significant bits.

See also
GLM_GTC_packing
uint32 packI3x10_1x2(ivec4 const & v)
uint32 packSnorm3x10_1x2(vec4 const & v)
uint32 packUnorm3x10_1x2(vec4 const & v)
ivec4 unpackU3x10_1x2(uint32 const & p)
GLM_FUNC_DECL uint16 glm::packUnorm1x16 ( float  v)

First, converts the normalized floating-point value v into a 16-bit integer value.

Then, the results are packed into the returned 16-bit unsigned integer.

The conversion for component c of v to fixed point is done as follows: packUnorm1x16: round(clamp(c, 0, +1) * 65535.0)

See also
GLM_GTC_packing
uint16 packSnorm1x16(float const & v)
uint64 packSnorm4x16(vec4 const & v)
GLSL packUnorm4x8 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL uint8 glm::packUnorm1x8 ( float  v)

First, converts the normalized floating-point value v into a 8-bit integer value.

Then, the results are packed into the returned 8-bit unsigned integer.

The conversion for component c of v to fixed point is done as follows: packUnorm1x8: round(clamp(c, 0, +1) * 255.0)

See also
GLM_GTC_packing
uint16 packUnorm2x8(vec2 const & v)
uint32 packUnorm4x8(vec4 const & v)
GLSL packUnorm4x8 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL uint16 glm::packUnorm2x8 ( vec2 const &  v)

First, converts each component of the normalized floating-point value v into 8-bit integer values.

Then, the results are packed into the returned 16-bit unsigned integer.

The conversion for component c of v to fixed point is done as follows: packUnorm2x8: round(clamp(c, 0, +1) * 255.0)

The first component of the vector will be written to the least significant bits of the output; the last component will be written to the most significant bits.

See also
GLM_GTC_packing
uint8 packUnorm1x8(float const & v)
uint32 packUnorm4x8(vec4 const & v)
GLSL packUnorm4x8 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL uint32 glm::packUnorm3x10_1x2 ( vec4 const &  v)

First, converts the first three components of the normalized floating-point value v into 10-bit unsigned integer values.

Then, converts the forth component of the normalized floating-point value v into 2-bit signed uninteger values. Then, the results are packed into the returned 32-bit unsigned integer.

The conversion for component c of v to fixed point is done as follows: packUnorm3x10_1x2(xyz): round(clamp(c, 0, +1) * 1023.0) packUnorm3x10_1x2(w): round(clamp(c, 0, +1) * 3.0)

The first vector component specifies the 10 least-significant bits of the result; the forth component specifies the 2 most-significant bits.

See also
GLM_GTC_packing
vec4 unpackUnorm3x10_1x2(uint32 const & p)
uint32 packUnorm3x10_1x2(vec4 const & v)
uint32 packU3x10_1x2(uvec4 const & v)
uint32 packI3x10_1x2(ivec4 const & v)
GLM_FUNC_DECL uint64 glm::packUnorm4x16 ( vec4 const &  v)

First, converts each component of the normalized floating-point value v into 16-bit integer values.

Then, the results are packed into the returned 64-bit unsigned integer.

The conversion for component c of v to fixed point is done as follows: packUnorm4x16: round(clamp(c, 0, +1) * 65535.0)

The first component of the vector will be written to the least significant bits of the output; the last component will be written to the most significant bits.

See also
GLM_GTC_packing
uint16 packUnorm1x16(float const & v)
uint32 packUnorm2x16(vec2 const & v)
GLSL packUnorm4x8 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL vec3 glm::unpackF2x11_1x10 ( uint32  p)

First, unpacks a single 32-bit unsigned integer p into two 11-bit signless floating-point values and one 10-bit signless floating-point value .

Then, each component is converted to a normalized floating-point value to generate the returned three-component vector.

The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.

See also
GLM_GTC_packing
uint32 packF2x11_1x10(vec3 const & v)
GLM_FUNC_DECL float glm::unpackHalf1x16 ( uint16  v)

Returns a floating-point scalar with components obtained by unpacking a 16-bit unsigned integer into a 16-bit value, interpreted as a 16-bit floating-point number according to the OpenGL Specification, and converting it to 32-bit floating-point values.

See also
GLM_GTC_packing
vec2 unpackHalf2x16(uint32 const & v)
vec4 unpackHalf4x16(uint64 const & v)
GLSL unpackHalf2x16 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL vec4 glm::unpackHalf4x16 ( uint64  p)

Returns a four-component floating-point vector with components obtained by unpacking a 64-bit unsigned integer into four 16-bit values, interpreting those values as 16-bit floating-point numbers according to the OpenGL Specification, and converting them to 32-bit floating-point values.

The first component of the vector is obtained from the 16 least-significant bits of v; the forth component is obtained from the 16 most-significant bits of v.

See also
GLM_GTC_packing
float unpackHalf1x16(uint16 const & v)
vec2 unpackHalf2x16(uint32 const & v)
GLSL unpackHalf2x16 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL ivec4 glm::unpackI3x10_1x2 ( uint32  p)

Unpacks a single 32-bit unsigned integer p into three 10-bit and one 2-bit signed integers.

The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.

See also
GLM_GTC_packing
uint32 packU3x10_1x2(uvec4 const & v)
vec4 unpackSnorm3x10_1x2(uint32 const & p);
uvec4 unpackI3x10_1x2(uint32 const & p);
GLM_FUNC_DECL float glm::unpackSnorm1x16 ( uint16  p)

First, unpacks a single 16-bit unsigned integer p into a single 16-bit signed integers.

Then, each component is converted to a normalized floating-point value to generate the returned scalar.

The conversion for unpacked fixed-point value f to floating point is done as follows: unpackSnorm1x16: clamp(f / 32767.0, -1, +1)

See also
GLM_GTC_packing
vec2 unpackSnorm2x16(uint32 p)
vec4 unpackSnorm4x16(uint64 p)
GLSL unpackSnorm4x8 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL float glm::unpackSnorm1x8 ( uint8  p)

First, unpacks a single 8-bit unsigned integer p into a single 8-bit signed integers.

Then, the value is converted to a normalized floating-point value to generate the returned scalar.

The conversion for unpacked fixed-point value f to floating point is done as follows: unpackSnorm1x8: clamp(f / 127.0, -1, +1)

See also
GLM_GTC_packing
vec2 unpackSnorm2x8(uint16 p)
vec4 unpackSnorm4x8(uint32 p)
GLSL unpackSnorm4x8 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL vec2 glm::unpackSnorm2x8 ( uint16  p)

First, unpacks a single 16-bit unsigned integer p into a pair of 8-bit signed integers.

Then, each component is converted to a normalized floating-point value to generate the returned two-component vector.

The conversion for unpacked fixed-point value f to floating point is done as follows: unpackSnorm2x8: clamp(f / 127.0, -1, +1)

The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.

See also
GLM_GTC_packing
float unpackSnorm1x8(uint8 p)
vec4 unpackSnorm4x8(uint32 p)
GLSL unpackSnorm4x8 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL vec4 glm::unpackSnorm3x10_1x2 ( uint32  p)

First, unpacks a single 32-bit unsigned integer p into four 16-bit signed integers.

Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.

The conversion for unpacked fixed-point value f to floating point is done as follows: unpackSnorm3x10_1x2(xyz): clamp(f / 511.0, -1, +1) unpackSnorm3x10_1x2(w): clamp(f / 511.0, -1, +1)

The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.

See also
GLM_GTC_packing
uint32 packSnorm3x10_1x2(vec4 const & v)
vec4 unpackUnorm3x10_1x2(uint32 const & p))
uvec4 unpackI3x10_1x2(uint32 const & p)
uvec4 unpackU3x10_1x2(uint32 const & p)
GLM_FUNC_DECL vec4 glm::unpackSnorm4x16 ( uint64  p)

First, unpacks a single 64-bit unsigned integer p into four 16-bit signed integers.

Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.

The conversion for unpacked fixed-point value f to floating point is done as follows: unpackSnorm4x16: clamp(f / 32767.0, -1, +1)

The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.

See also
GLM_GTC_packing
float unpackSnorm1x16(uint16 p)
vec2 unpackSnorm2x16(uint32 p)
GLSL unpackSnorm4x8 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL uvec4 glm::unpackU3x10_1x2 ( uint32  p)

Unpacks a single 32-bit unsigned integer p into three 10-bit and one 2-bit unsigned integers.

The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.

See also
GLM_GTC_packing
uint32 packU3x10_1x2(uvec4 const & v)
vec4 unpackSnorm3x10_1x2(uint32 const & p);
uvec4 unpackI3x10_1x2(uint32 const & p);
GLM_FUNC_DECL float glm::unpackUnorm1x16 ( uint16  p)

First, unpacks a single 16-bit unsigned integer p into a of 16-bit unsigned integers.

Then, the value is converted to a normalized floating-point value to generate the returned scalar.

The conversion for unpacked fixed-point value f to floating point is done as follows: unpackUnorm1x16: f / 65535.0

See also
GLM_GTC_packing
vec2 unpackUnorm2x16(uint32 p)
vec4 unpackUnorm4x16(uint64 p)
GLSL unpackUnorm2x16 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL float glm::unpackUnorm1x8 ( uint8  p)

Convert a single 8-bit integer to a normalized floating-point value.

The conversion for unpacked fixed-point value f to floating point is done as follows: unpackUnorm4x8: f / 255.0

See also
GLM_GTC_packing
vec2 unpackUnorm2x8(uint16 p)
vec4 unpackUnorm4x8(uint32 p)
GLSL unpackUnorm4x8 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL vec2 glm::unpackUnorm2x8 ( uint16  p)

First, unpacks a single 16-bit unsigned integer p into a pair of 8-bit unsigned integers.

Then, each component is converted to a normalized floating-point value to generate the returned two-component vector.

The conversion for unpacked fixed-point value f to floating point is done as follows: unpackUnorm4x8: f / 255.0

The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.

See also
GLM_GTC_packing
float unpackUnorm1x8(uint8 v)
vec4 unpackUnorm4x8(uint32 p)
GLSL unpackUnorm4x8 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
GLM_FUNC_DECL vec4 glm::unpackUnorm3x10_1x2 ( uint32  p)

First, unpacks a single 32-bit unsigned integer p into four 16-bit signed integers.

Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.

The conversion for unpacked fixed-point value f to floating point is done as follows: unpackSnorm3x10_1x2(xyz): clamp(f / 1023.0, 0, +1) unpackSnorm3x10_1x2(w): clamp(f / 3.0, 0, +1)

The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.

See also
GLM_GTC_packing
uint32 packSnorm3x10_1x2(vec4 const & v)
vec4 unpackInorm3x10_1x2(uint32 const & p))
uvec4 unpackI3x10_1x2(uint32 const & p)
uvec4 unpackU3x10_1x2(uint32 const & p)
GLM_FUNC_DECL vec4 glm::unpackUnorm4x16 ( uint64  p)

First, unpacks a single 64-bit unsigned integer p into four 16-bit unsigned integers.

Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.

The conversion for unpacked fixed-point value f to floating point is done as follows: unpackUnormx4x16: f / 65535.0

The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.

See also
GLM_GTC_packing
float unpackUnorm1x16(uint16 p)
vec2 unpackUnorm2x16(uint32 p)
GLSL unpackUnorm2x16 man page
GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00177.html000066400000000000000000001301301356361734700216470ustar00rootroot00000000000000 0.9.7: GLM_GTC_quaternion
Functions
GLM_GTC_quaternion
GTC Extensions (Stable)

Functions

template<typename T , precision P>
GLM_FUNC_DECL T angle (tquat< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > angleAxis (T const &angle, tvec3< T, P > const &axis)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > axis (tquat< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > conjugate (tquat< T, P > const &q)
 
template<typename T , precision P, template< typename, precision > class quatType>
GLM_FUNC_DECL T dot (quatType< T, P > const &x, quatType< T, P > const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< bool, P > equal (tquat< T, P > const &x, tquat< T, P > const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > eulerAngles (tquat< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< bool, P > greaterThan (tquat< T, P > const &x, tquat< T, P > const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< bool, P > greaterThanEqual (tquat< T, P > const &x, tquat< T, P > const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > inverse (tquat< T, P > const &q)
 
template<typename T , precision P>
GLM_FUNC_DECL T length (tquat< T, P > const &q)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > lerp (tquat< T, P > const &x, tquat< T, P > const &y, T a)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< bool, P > lessThan (tquat< T, P > const &x, tquat< T, P > const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< bool, P > lessThanEqual (tquat< T, P > const &x, tquat< T, P > const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > mat3_cast (tquat< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > mat4_cast (tquat< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > mix (tquat< T, P > const &x, tquat< T, P > const &y, T a)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > normalize (tquat< T, P > const &q)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< bool, P > notEqual (tquat< T, P > const &x, tquat< T, P > const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL T pitch (tquat< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > quat_cast (tmat3x3< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > quat_cast (tmat4x4< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL T roll (tquat< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > rotate (tquat< T, P > const &q, T const &angle, tvec3< T, P > const &axis)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > slerp (tquat< T, P > const &x, tquat< T, P > const &y, T a)
 
template<typename T , precision P>
GLM_FUNC_DECL T yaw (tquat< T, P > const &x)
 

Detailed Description

Defines a templated quaternion type and several quaternion operations.

<glm/gtc/quaternion.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL T glm::angle ( tquat< T, P > const &  x)

Returns the quaternion rotation angle.

See also
GLM_GTC_quaternion
GLM_FUNC_DECL tquat<T, P> glm::angleAxis ( T const &  angle,
tvec3< T, P > const &  axis 
)

Build a quaternion from an angle and a normalized axis.

Parameters
angleAngle expressed in radians.
axisAxis of the quaternion, must be normalized.
See also
GLM_GTC_quaternion
GLM_FUNC_DECL tvec3<T, P> glm::axis ( tquat< T, P > const &  x)

Returns the q rotation axis.

See also
GLM_GTC_quaternion
GLM_FUNC_DECL tquat<T, P> glm::conjugate ( tquat< T, P > const &  q)

Returns the q conjugate.

See also
GLM_GTC_quaternion
GLM_FUNC_DECL T glm::dot ( quatType< T, P > const &  x,
quatType< T, P > const &  y 
)

Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ...

See also
GLM_GTC_quaternion
GLM_FUNC_DECL tvec4<bool, P> glm::equal ( tquat< T, P > const &  x,
tquat< T, P > const &  y 
)

Returns the component-wise comparison of result x == y.

Template Parameters
quatTypeFloating-point quaternion types.
See also
GLM_GTC_quaternion
GLM_FUNC_DECL tvec3<T, P> glm::eulerAngles ( tquat< T, P > const &  x)

Returns euler angles, yitch as x, yaw as y, roll as z.

The result is expressed in radians if GLM_FORCE_RADIANS is defined or degrees otherwise.

See also
GLM_GTC_quaternion
GLM_FUNC_DECL tvec4<bool, P> glm::greaterThan ( tquat< T, P > const &  x,
tquat< T, P > const &  y 
)

Returns the component-wise comparison of result x > y.

Template Parameters
quatTypeFloating-point quaternion types.
See also
GLM_GTC_quaternion
GLM_FUNC_DECL tvec4<bool, P> glm::greaterThanEqual ( tquat< T, P > const &  x,
tquat< T, P > const &  y 
)

Returns the component-wise comparison of result x >= y.

Template Parameters
quatTypeFloating-point quaternion types.
See also
GLM_GTC_quaternion
GLM_FUNC_DECL tquat<T, P> glm::inverse ( tquat< T, P > const &  q)

Returns the q inverse.

See also
GLM_GTC_quaternion
GLM_FUNC_DECL T glm::length ( tquat< T, P > const &  q)

Returns the length of the quaternion.

See also
GLM_GTC_quaternion
GLM_FUNC_DECL tquat<T, P> glm::lerp ( tquat< T, P > const &  x,
tquat< T, P > const &  y,
T  a 
)

Linear interpolation of two quaternions.

The interpolation is oriented.

Parameters
xA quaternion
yA quaternion
aInterpolation factor. The interpolation is defined in the range [0, 1].
Template Parameters
TValue type used to build the quaternion. Supported: half, float or double.
See also
GLM_GTC_quaternion
GLM_FUNC_DECL tvec4<bool, P> glm::lessThan ( tquat< T, P > const &  x,
tquat< T, P > const &  y 
)

Returns the component-wise comparison result of x < y.

Template Parameters
quatTypeFloating-point quaternion types.
See also
GLM_GTC_quaternion
GLM_FUNC_DECL tvec4<bool, P> glm::lessThanEqual ( tquat< T, P > const &  x,
tquat< T, P > const &  y 
)

Returns the component-wise comparison of result x <= y.

Template Parameters
quatTypeFloating-point quaternion types.
See also
GLM_GTC_quaternion
GLM_FUNC_DECL tmat3x3<T, P> glm::mat3_cast ( tquat< T, P > const &  x)

Converts a quaternion to a 3 * 3 matrix.

See also
GLM_GTC_quaternion

Referenced by glm::toMat3().

GLM_FUNC_DECL tmat4x4<T, P> glm::mat4_cast ( tquat< T, P > const &  x)

Converts a quaternion to a 4 * 4 matrix.

See also
GLM_GTC_quaternion

Referenced by glm::toMat4().

GLM_FUNC_DECL tquat<T, P> glm::mix ( tquat< T, P > const &  x,
tquat< T, P > const &  y,
T  a 
)

Spherical linear interpolation of two quaternions.

The interpolation is oriented and the rotation is performed at constant speed. For short path spherical linear interpolation, use the slerp function.

Parameters
xA quaternion
yA quaternion
aInterpolation factor. The interpolation is defined beyond the range [0, 1].
Template Parameters
TValue type used to build the quaternion. Supported: half, float or double.
See also
GLM_GTC_quaternion
- slerp(tquat<T, P> const & x, tquat<T, P> const & y, T const & a)
GLM_FUNC_DECL tquat<T, P> glm::normalize ( tquat< T, P > const &  q)

Returns the normalized quaternion.

See also
GLM_GTC_quaternion
GLM_FUNC_DECL tvec4<bool, P> glm::notEqual ( tquat< T, P > const &  x,
tquat< T, P > const &  y 
)

Returns the component-wise comparison of result x != y.

Template Parameters
quatTypeFloating-point quaternion types.
See also
GLM_GTC_quaternion
GLM_FUNC_DECL T glm::pitch ( tquat< T, P > const &  x)

Returns pitch value of euler angles expressed in radians.

See also
GLM_GTX_quaternion
GLM_FUNC_DECL tquat<T, P> glm::quat_cast ( tmat3x3< T, P > const &  x)

Converts a 3 * 3 matrix to a quaternion.

See also
GLM_GTC_quaternion

Referenced by glm::toQuat().

GLM_FUNC_DECL tquat<T, P> glm::quat_cast ( tmat4x4< T, P > const &  x)

Converts a 4 * 4 matrix to a quaternion.

See also
GLM_GTC_quaternion
GLM_FUNC_DECL T glm::roll ( tquat< T, P > const &  x)

Returns roll value of euler angles expressed in radians.

See also
GLM_GTX_quaternion
GLM_FUNC_DECL tquat<T, P> glm::rotate ( tquat< T, P > const &  q,
T const &  angle,
tvec3< T, P > const &  axis 
)

Rotates a quaternion from a vector of 3 components axis and an angle.

Parameters
qSource orientation
angleAngle expressed in radians.
axisAxis of the rotation
See also
GLM_GTC_quaternion
GLM_FUNC_DECL tquat<T, P> glm::slerp ( tquat< T, P > const &  x,
tquat< T, P > const &  y,
T  a 
)

Spherical linear interpolation of two quaternions.

The interpolation always take the short path and the rotation is performed at constant speed.

Parameters
xA quaternion
yA quaternion
aInterpolation factor. The interpolation is defined beyond the range [0, 1].
Template Parameters
TValue type used to build the quaternion. Supported: half, float or double.
See also
GLM_GTC_quaternion
GLM_FUNC_DECL T glm::yaw ( tquat< T, P > const &  x)

Returns yaw value of euler angles expressed in radians.

See also
GLM_GTX_quaternion
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00178.html000066400000000000000000000273711356361734700216640ustar00rootroot00000000000000 0.9.7: GLM_GTC_random
Functions
GLM_GTC_random
GTC Extensions (Stable)

Functions

template<typename T >
GLM_FUNC_DECL tvec3< T, defaultp > ballRand (T Radius)
 
template<typename T >
GLM_FUNC_DECL tvec2< T, defaultp > circularRand (T Radius)
 
template<typename T >
GLM_FUNC_DECL tvec2< T, defaultp > diskRand (T Radius)
 
template<typename genType >
GLM_FUNC_DECL genType gaussRand (genType Mean, genType Deviation)
 
template<typename genTYpe >
GLM_FUNC_DECL genTYpe linearRand (genTYpe Min, genTYpe Max)
 
template<typename T >
GLM_FUNC_DECL tvec3< T, defaultp > sphericalRand (T Radius)
 

Detailed Description

Generate random number from various distribution methods.

<glm/gtc/random.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL tvec3<T, defaultp> glm::ballRand ( T  Radius)

Generate a random 3D vector which coordinates are regulary distributed within the volume of a ball of a given radius.

Parameters
Radius
See also
GLM_GTC_random
GLM_FUNC_DECL tvec2<T, defaultp> glm::circularRand ( T  Radius)

Generate a random 2D vector which coordinates are regulary distributed on a circle of a given radius.

Parameters
Radius
See also
GLM_GTC_random
GLM_FUNC_DECL tvec2<T, defaultp> glm::diskRand ( T  Radius)

Generate a random 2D vector which coordinates are regulary distributed within the area of a disk of a given radius.

Parameters
Radius
See also
GLM_GTC_random
GLM_FUNC_DECL genType glm::gaussRand ( genType  Mean,
genType  Deviation 
)

Generate random numbers in the interval [Min, Max], according a gaussian distribution.

Parameters
Mean
Deviation
See also
GLM_GTC_random
GLM_FUNC_DECL genTYpe glm::linearRand ( genTYpe  Min,
genTYpe  Max 
)

Generate random numbers in the interval [Min, Max], according a linear distribution.

Parameters
Min
Max
Template Parameters
genTypeValue type. Currently supported: half (not recommanded), float or double scalars and vectors.
See also
GLM_GTC_random
GLM_FUNC_DECL tvec3<T, defaultp> glm::sphericalRand ( T  Radius)

Generate a random 3D vector which coordinates are regulary distributed on a sphere of a given radius.

Parameters
Radius
See also
GLM_GTC_random
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00179.html000066400000000000000000000413201356361734700216530ustar00rootroot00000000000000 0.9.7: GLM_GTC_reciprocal
Functions
GLM_GTC_reciprocal
GTC Extensions (Stable)

Functions

template<typename genType >
GLM_FUNC_DECL genType acot (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL genType acoth (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL genType acsc (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL genType acsch (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL genType asec (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL genType asech (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL genType cot (genType const &angle)
 
template<typename genType >
GLM_FUNC_DECL genType coth (genType const &angle)
 
template<typename genType >
GLM_FUNC_DECL genType csc (genType const &angle)
 
template<typename genType >
GLM_FUNC_DECL genType csch (genType const &angle)
 
template<typename genType >
GLM_FUNC_DECL genType sec (genType const &angle)
 
template<typename genType >
GLM_FUNC_DECL genType sech (genType const &angle)
 

Detailed Description

Define secant, cosecant and cotangent functions.

<glm/gtc/reciprocal.hpp> need to be included to use these features.

Function Documentation

GLM_FUNC_DECL genType glm::acot ( genType const &  x)

Inverse cotangent function.

See also
GLM_GTC_reciprocal
GLM_FUNC_DECL genType glm::acoth ( genType const &  x)

Inverse cotangent hyperbolic function.

See also
GLM_GTC_reciprocal
GLM_FUNC_DECL genType glm::acsc ( genType const &  x)

Inverse cosecant function.

See also
GLM_GTC_reciprocal
GLM_FUNC_DECL genType glm::acsch ( genType const &  x)

Inverse cosecant hyperbolic function.

See also
GLM_GTC_reciprocal
GLM_FUNC_DECL genType glm::asec ( genType const &  x)

Inverse secant function.

See also
GLM_GTC_reciprocal
GLM_FUNC_DECL genType glm::asech ( genType const &  x)

Inverse secant hyperbolic function.

See also
GLM_GTC_reciprocal
GLM_FUNC_DECL genType glm::cot ( genType const &  angle)

Cotangent function.

adjacent / opposite or 1 / tan(x)

See also
GLM_GTC_reciprocal
GLM_FUNC_DECL genType glm::coth ( genType const &  angle)

Cotangent hyperbolic function.

See also
GLM_GTC_reciprocal
GLM_FUNC_DECL genType glm::csc ( genType const &  angle)

Cosecant function.

hypotenuse / opposite or 1 / sin(x)

See also
GLM_GTC_reciprocal
GLM_FUNC_DECL genType glm::csch ( genType const &  angle)

Cosecant hyperbolic function.

See also
GLM_GTC_reciprocal
GLM_FUNC_DECL genType glm::sec ( genType const &  angle)

Secant function.

hypotenuse / adjacent or 1 / cos(x)

See also
GLM_GTC_reciprocal
GLM_FUNC_DECL genType glm::sech ( genType const &  angle)

Secant hyperbolic function.

See also
GLM_GTC_reciprocal
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00180.html000066400000000000000000000724611356361734700216550ustar00rootroot00000000000000 0.9.7: GLM_GTC_round
Functions
GLM_GTC_round
GTC Extensions (Stable)

Functions

template<typename genType >
GLM_FUNC_DECL genType ceilMultiple (genType Source, genType Multiple)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > ceilMultiple (vecType< T, P > const &Source, vecType< T, P > const &Multiple)
 
template<typename genIUType >
GLM_FUNC_DECL genIUType ceilPowerOfTwo (genIUType Value)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > ceilPowerOfTwo (vecType< T, P > const &value)
 
template<typename genType >
GLM_FUNC_DECL genType floorMultiple (genType Source, genType Multiple)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > floorMultiple (vecType< T, P > const &Source, vecType< T, P > const &Multiple)
 
template<typename genIUType >
GLM_FUNC_DECL genIUType floorPowerOfTwo (genIUType Value)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > floorPowerOfTwo (vecType< T, P > const &value)
 
template<typename genIUType >
GLM_FUNC_DECL bool isMultiple (genIUType Value, genIUType Multiple)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > isMultiple (vecType< T, P > const &Value, T Multiple)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > isMultiple (vecType< T, P > const &Value, vecType< T, P > const &Multiple)
 
template<typename genIUType >
GLM_FUNC_DECL bool isPowerOfTwo (genIUType Value)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > isPowerOfTwo (vecType< T, P > const &value)
 
template<typename genType >
GLM_FUNC_DECL genType roundMultiple (genType Source, genType Multiple)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > roundMultiple (vecType< T, P > const &Source, vecType< T, P > const &Multiple)
 
template<typename genIUType >
GLM_FUNC_DECL genIUType roundPowerOfTwo (genIUType Value)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > roundPowerOfTwo (vecType< T, P > const &value)
 

Detailed Description

rounding value to specific boundings

<glm/gtc/round.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL genType glm::ceilMultiple ( genType  Source,
genType  Multiple 
)

Higher multiple number of Source.

Template Parameters
genTypeFloating-point or integer scalar or vector types.
Parameters
Source
MultipleMust be a null or positive value
See also
GLM_GTC_round
GLM_FUNC_DECL vecType<T, P> glm::ceilMultiple ( vecType< T, P > const &  Source,
vecType< T, P > const &  Multiple 
)

Higher multiple number of Source.

Template Parameters
genTypeFloating-point or integer scalar or vector types.
Parameters
Source
MultipleMust be a null or positive value
See also
GLM_GTC_round
GLM_FUNC_DECL genIUType glm::ceilPowerOfTwo ( genIUType  Value)

Return the power of two number which value is just higher the input value, round up to a power of two.

See also
GLM_GTC_round
GLM_FUNC_DECL vecType<T, P> glm::ceilPowerOfTwo ( vecType< T, P > const &  value)

Return the power of two number which value is just higher the input value, round up to a power of two.

See also
GLM_GTC_round
GLM_FUNC_DECL genType glm::floorMultiple ( genType  Source,
genType  Multiple 
)

Lower multiple number of Source.

Template Parameters
genTypeFloating-point or integer scalar or vector types.
Parameters
Source
MultipleMust be a null or positive value
See also
GLM_GTC_round
GLM_FUNC_DECL vecType<T, P> glm::floorMultiple ( vecType< T, P > const &  Source,
vecType< T, P > const &  Multiple 
)

Lower multiple number of Source.

Template Parameters
genTypeFloating-point or integer scalar or vector types.
Parameters
Source
MultipleMust be a null or positive value
See also
GLM_GTC_round
GLM_FUNC_DECL genIUType glm::floorPowerOfTwo ( genIUType  Value)

Return the power of two number which value is just lower the input value, round down to a power of two.

See also
GLM_GTC_round
GLM_FUNC_DECL vecType<T, P> glm::floorPowerOfTwo ( vecType< T, P > const &  value)

Return the power of two number which value is just lower the input value, round down to a power of two.

See also
GLM_GTC_round
GLM_FUNC_DECL bool glm::isMultiple ( genIUType  Value,
genIUType  Multiple 
)

Return true if the 'Value' is a multiple of 'Multiple'.

See also
GLM_GTC_round
GLM_FUNC_DECL vecType<bool, P> glm::isMultiple ( vecType< T, P > const &  Value,
T  Multiple 
)

Return true if the 'Value' is a multiple of 'Multiple'.

See also
GLM_GTC_round
GLM_FUNC_DECL vecType<bool, P> glm::isMultiple ( vecType< T, P > const &  Value,
vecType< T, P > const &  Multiple 
)

Return true if the 'Value' is a multiple of 'Multiple'.

See also
GLM_GTC_round
GLM_FUNC_DECL bool glm::isPowerOfTwo ( genIUType  Value)

Return true if the value is a power of two number.

See also
GLM_GTC_round
GLM_FUNC_DECL vecType<bool, P> glm::isPowerOfTwo ( vecType< T, P > const &  value)

Return true if the value is a power of two number.

See also
GLM_GTC_round
GLM_FUNC_DECL genType glm::roundMultiple ( genType  Source,
genType  Multiple 
)

Lower multiple number of Source.

Template Parameters
genTypeFloating-point or integer scalar or vector types.
Parameters
Source
MultipleMust be a null or positive value
See also
GLM_GTC_round
GLM_FUNC_DECL vecType<T, P> glm::roundMultiple ( vecType< T, P > const &  Source,
vecType< T, P > const &  Multiple 
)

Lower multiple number of Source.

Template Parameters
genTypeFloating-point or integer scalar or vector types.
Parameters
Source
MultipleMust be a null or positive value
See also
GLM_GTC_round
GLM_FUNC_DECL genIUType glm::roundPowerOfTwo ( genIUType  Value)

Return the power of two number which value is the closet to the input value.

See also
GLM_GTC_round
GLM_FUNC_DECL vecType<T, P> glm::roundPowerOfTwo ( vecType< T, P > const &  value)

Return the power of two number which value is the closet to the input value.

See also
GLM_GTC_round
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00181.html000066400000000000000000006132421356361734700216540ustar00rootroot00000000000000 0.9.7: GLM_GTC_type_precision
Typedefs
GLM_GTC_type_precision
GTC Extensions (Stable)

Typedefs

typedef highp_float32_t f32
 
typedef f32mat2x2 f32mat2
 
typedef highp_f32mat2x2 f32mat2x2
 
typedef highp_f32mat2x3 f32mat2x3
 
typedef highp_f32mat2x4 f32mat2x4
 
typedef f32mat3x3 f32mat3
 
typedef highp_f32mat3x2 f32mat3x2
 
typedef highp_f32mat3x3 f32mat3x3
 
typedef highp_f32mat3x4 f32mat3x4
 
typedef f32mat4x4 f32mat4
 
typedef highp_f32mat4x2 f32mat4x2
 
typedef highp_f32mat4x3 f32mat4x3
 
typedef highp_f32mat4x4 f32mat4x4
 
typedef highp_f32quat f32quat
 
typedef highp_f32vec1 f32vec1
 
typedef highp_f32vec2 f32vec2
 
typedef highp_f32vec3 f32vec3
 
typedef highp_f32vec4 f32vec4
 
typedef highp_float64_t f64
 
typedef f64mat2x2 f64mat2
 
typedef highp_f64mat2x2 f64mat2x2
 
typedef highp_f64mat2x3 f64mat2x3
 
typedef highp_f64mat2x4 f64mat2x4
 
typedef f64mat3x3 f64mat3
 
typedef highp_f64mat3x2 f64mat3x2
 
typedef highp_f64mat3x3 f64mat3x3
 
typedef highp_f64mat3x4 f64mat3x4
 
typedef f64mat4x4 f64mat4
 
typedef highp_f64mat4x2 f64mat4x2
 
typedef highp_f64mat4x3 f64mat4x3
 
typedef highp_f64mat4x4 f64mat4x4
 
typedef highp_f64quat f64quat
 
typedef highp_f64vec1 f64vec1
 
typedef highp_f64vec2 f64vec2
 
typedef highp_f64vec3 f64vec3
 
typedef highp_f64vec4 f64vec4
 
typedef float float32
 
typedef highp_float32_t float32_t
 
typedef double float64
 
typedef highp_float64_t float64_t
 
typedef fmat2x2 fmat2
 
typedef highp_f32mat2x2 fmat2x2
 
typedef highp_f32mat2x3 fmat2x3
 
typedef highp_f32mat2x4 fmat2x4
 
typedef fmat3x3 fmat3
 
typedef highp_f32mat3x2 fmat3x2
 
typedef highp_f32mat3x3 fmat3x3
 
typedef highp_f32mat3x4 fmat3x4
 
typedef fmat4x4 fmat4
 
typedef highp_f32mat4x2 fmat4x2
 
typedef highp_f32mat4x3 fmat4x3
 
typedef highp_f32mat4x4 fmat4x4
 
typedef highp_f32vec1 fvec1
 
typedef highp_f32vec2 fvec2
 
typedef highp_f32vec3 fvec3
 
typedef highp_f32vec4 fvec4
 
typedef detail::int16 highp_i16
 
typedef detail::int32 highp_i32
 
typedef detail::int64 highp_i64
 
typedef detail::int8 highp_i8
 
typedef detail::int16 highp_int16
 
typedef detail::int16 highp_int16_t
 
typedef detail::int32 highp_int32
 
typedef detail::int32 highp_int32_t
 
typedef detail::int64 highp_int64
 
typedef detail::int64 highp_int64_t
 
typedef detail::int8 highp_int8
 
typedef detail::int8 highp_int8_t
 
typedef detail::uint16 highp_u16
 
typedef detail::uint32 highp_u32
 
typedef detail::uint64 highp_u64
 
typedef detail::uint8 highp_u8
 
typedef detail::uint16 highp_uint16
 
typedef detail::uint16 highp_uint16_t
 
typedef detail::uint32 highp_uint32
 
typedef detail::uint32 highp_uint32_t
 
typedef detail::uint64 highp_uint64
 
typedef detail::uint64 highp_uint64_t
 
typedef detail::uint8 highp_uint8
 
typedef detail::uint8 highp_uint8_t
 
typedef detail::int16 i16
 
typedef highp_i16vec1 i16vec1
 
typedef highp_i16vec2 i16vec2
 
typedef highp_i16vec3 i16vec3
 
typedef highp_i16vec4 i16vec4
 
typedef detail::int32 i32
 
typedef highp_i32vec1 i32vec1
 
typedef highp_i32vec2 i32vec2
 
typedef highp_i32vec3 i32vec3
 
typedef highp_i32vec4 i32vec4
 
typedef detail::int64 i64
 
typedef highp_i64vec1 i64vec1
 
typedef highp_i64vec2 i64vec2
 
typedef highp_i64vec3 i64vec3
 
typedef highp_i64vec4 i64vec4
 
typedef detail::int8 i8
 
typedef highp_i8vec1 i8vec1
 
typedef highp_i8vec2 i8vec2
 
typedef highp_i8vec3 i8vec3
 
typedef highp_i8vec4 i8vec4
 
typedef detail::int16 int16
 
typedef detail::int16 int16_t
 
typedef detail::int32 int32
 
typedef detail::int32 int32_t
 
typedef detail::int64 int64
 
typedef detail::int64 int64_t
 
typedef detail::int8 int8
 
typedef detail::int8 int8_t
 
typedef detail::int16 lowp_i16
 
typedef detail::int32 lowp_i32
 
typedef detail::int64 lowp_i64
 
typedef detail::int8 lowp_i8
 
typedef detail::int16 lowp_int16
 
typedef detail::int16 lowp_int16_t
 
typedef detail::int32 lowp_int32
 
typedef detail::int32 lowp_int32_t
 
typedef detail::int64 lowp_int64
 
typedef detail::int64 lowp_int64_t
 
typedef detail::int8 lowp_int8
 
typedef detail::int8 lowp_int8_t
 
typedef detail::uint16 lowp_u16
 
typedef detail::uint32 lowp_u32
 
typedef detail::uint64 lowp_u64
 
typedef detail::uint8 lowp_u8
 
typedef detail::uint16 lowp_uint16
 
typedef detail::uint16 lowp_uint16_t
 
typedef detail::uint32 lowp_uint32
 
typedef detail::uint32 lowp_uint32_t
 
typedef detail::uint64 lowp_uint64
 
typedef detail::uint64 lowp_uint64_t
 
typedef detail::uint8 lowp_uint8
 
typedef detail::uint8 lowp_uint8_t
 
typedef detail::int16 mediump_i16
 
typedef detail::int32 mediump_i32
 
typedef detail::int64 mediump_i64
 
typedef detail::int8 mediump_i8
 
typedef detail::int16 mediump_int16
 
typedef detail::int16 mediump_int16_t
 
typedef detail::int32 mediump_int32
 
typedef detail::int32 mediump_int32_t
 
typedef detail::int64 mediump_int64
 
typedef detail::int64 mediump_int64_t
 
typedef detail::int8 mediump_int8
 
typedef detail::int8 mediump_int8_t
 
typedef detail::uint16 mediump_u16
 
typedef detail::uint32 mediump_u32
 
typedef detail::uint64 mediump_u64
 
typedef detail::uint8 mediump_u8
 
typedef detail::uint16 mediump_uint16
 
typedef detail::uint16 mediump_uint16_t
 
typedef detail::uint32 mediump_uint32
 
typedef detail::uint32 mediump_uint32_t
 
typedef detail::uint64 mediump_uint64
 
typedef detail::uint64 mediump_uint64_t
 
typedef detail::uint8 mediump_uint8
 
typedef detail::uint8 mediump_uint8_t
 
typedef detail::uint16 u16
 
typedef highp_u16vec1 u16vec1
 
typedef highp_u16vec2 u16vec2
 
typedef highp_u16vec3 u16vec3
 
typedef highp_u16vec4 u16vec4
 
typedef detail::uint32 u32
 
typedef highp_u32vec1 u32vec1
 
typedef highp_u32vec2 u32vec2
 
typedef highp_u32vec3 u32vec3
 
typedef highp_u32vec4 u32vec4
 
typedef detail::uint64 u64
 
typedef highp_u64vec1 u64vec1
 
typedef highp_u64vec2 u64vec2
 
typedef highp_u64vec3 u64vec3
 
typedef highp_u64vec4 u64vec4
 
typedef detail::uint8 u8
 
typedef highp_u8vec1 u8vec1
 
typedef highp_u8vec2 u8vec2
 
typedef highp_u8vec3 u8vec3
 
typedef highp_u8vec4 u8vec4
 
typedef detail::uint16 uint16
 
typedef detail::uint16 uint16_t
 
typedef detail::uint32 uint32
 
typedef detail::uint32 uint32_t
 
typedef detail::uint64 uint64
 
typedef detail::uint64 uint64_t
 
typedef detail::uint8 uint8
 
typedef detail::uint8 uint8_t
 

Detailed Description

Defines specific C++-based precision types.

Precision types defines types based on GLSL's precision qualifiers. This extension defines types based on explicitly-sized C++ data types.

<glm/gtc/type_precision.hpp> need to be included to use these functionalities.

Typedef Documentation

typedef float32 f32

Default 32 bit single-precision floating-point scalar.

32 bit single-precision floating-point scalar.

See also
GLM_GTC_type_precision

Definition at line 1534 of file fwd.hpp.

typedef tmat2x2< f32, defaultp > f32mat2

Default single-precision floating-point 2x2 matrix.

Single-precision floating-point 1x1 matrix.

See also
GLM_GTC_type_precision
GLM_GTC_type_precision Single-precision floating-point 2x2 matrix.
GLM_GTC_type_precision

Definition at line 2478 of file fwd.hpp.

typedef tmat2x2< f32, defaultp > f32mat2x2

Default single-precision floating-point 2x2 matrix.

Single-precision floating-point 1x1 matrix.

See also
GLM_GTC_type_precision
GLM_GTC_type_precision Single-precision floating-point 2x2 matrix.
GLM_GTC_type_precision

Definition at line 2442 of file fwd.hpp.

typedef tmat2x3< f32, defaultp > f32mat2x3

Default single-precision floating-point 2x3 matrix.

Single-precision floating-point 2x3 matrix.

See also
GLM_GTC_type_precision

Definition at line 2446 of file fwd.hpp.

typedef tmat2x4< f32, defaultp > f32mat2x4

Default single-precision floating-point 2x4 matrix.

Single-precision floating-point 2x4 matrix.

See also
GLM_GTC_type_precision

Definition at line 2450 of file fwd.hpp.

typedef tmat3x3< f32, defaultp > f32mat3

Default single-precision floating-point 3x3 matrix.

Single-precision floating-point 3x3 matrix.

See also
GLM_GTC_type_precision

Definition at line 2482 of file fwd.hpp.

typedef tmat3x2< f32, defaultp > f32mat3x2

Default single-precision floating-point 3x2 matrix.

Single-precision floating-point 3x2 matrix.

See also
GLM_GTC_type_precision

Definition at line 2454 of file fwd.hpp.

typedef tmat3x3< f32, defaultp > f32mat3x3

Default single-precision floating-point 3x3 matrix.

Single-precision floating-point 3x3 matrix.

See also
GLM_GTC_type_precision

Definition at line 2458 of file fwd.hpp.

typedef tmat3x4< f32, defaultp > f32mat3x4

Default single-precision floating-point 3x4 matrix.

Single-precision floating-point 3x4 matrix.

See also
GLM_GTC_type_precision

Definition at line 2462 of file fwd.hpp.

typedef tmat4x4< f32, defaultp > f32mat4

Default single-precision floating-point 4x4 matrix.

Single-precision floating-point 4x4 matrix.

See also
GLM_GTC_type_precision

Definition at line 2486 of file fwd.hpp.

typedef tmat4x2< f32, defaultp > f32mat4x2

Default single-precision floating-point 4x2 matrix.

Single-precision floating-point 4x2 matrix.

See also
GLM_GTC_type_precision

Definition at line 2466 of file fwd.hpp.

typedef tmat4x3< f32, defaultp > f32mat4x3

Default single-precision floating-point 4x3 matrix.

Single-precision floating-point 4x3 matrix.

See also
GLM_GTC_type_precision

Definition at line 2470 of file fwd.hpp.

typedef tmat4x4< f32, defaultp > f32mat4x4

Default single-precision floating-point 4x4 matrix.

Single-precision floating-point 4x4 matrix.

See also
GLM_GTC_type_precision

Definition at line 2474 of file fwd.hpp.

typedef tquat< f32, defaultp > f32quat

Default single-precision floating-point quaternion.

Single-precision floating-point quaternion.

See also
GLM_GTC_type_precision

Definition at line 2490 of file fwd.hpp.

typedef tvec1< f32, defaultp > f32vec1

Default single-precision floating-point vector of 1 components.

Single-precision floating-point vector of 1 component.

See also
GLM_GTC_type_precision

Definition at line 2426 of file fwd.hpp.

typedef tvec2< f32, defaultp > f32vec2

Default single-precision floating-point vector of 2 components.

Single-precision floating-point vector of 2 components.

See also
GLM_GTC_type_precision

Definition at line 2430 of file fwd.hpp.

typedef tvec3< f32, defaultp > f32vec3

Default single-precision floating-point vector of 3 components.

Single-precision floating-point vector of 3 components.

See also
GLM_GTC_type_precision

Definition at line 2434 of file fwd.hpp.

typedef tvec4< f32, defaultp > f32vec4

Default single-precision floating-point vector of 4 components.

Single-precision floating-point vector of 4 components.

See also
GLM_GTC_type_precision

Definition at line 2438 of file fwd.hpp.

typedef float64 f64

Default 64 bit double-precision floating-point scalar.

64 bit double-precision floating-point scalar.

See also
GLM_GTC_type_precision

Definition at line 1538 of file fwd.hpp.

typedef tmat2x2< f64, defaultp > f64mat2

Default double-precision floating-point 2x2 matrix.

Double-precision floating-point 1x1 matrix.

See also
GLM_GTC_type_precision
GLM_GTC_type_precision Double-precision floating-point 2x2 matrix.
GLM_GTC_type_precision

Definition at line 2584 of file fwd.hpp.

typedef tmat2x2< f64, defaultp > f64mat2x2

Default double-precision floating-point 2x2 matrix.

Double-precision floating-point 1x1 matrix.

See also
GLM_GTC_type_precision
GLM_GTC_type_precision Double-precision floating-point 2x2 matrix.
GLM_GTC_type_precision

Definition at line 2548 of file fwd.hpp.

typedef tmat2x3< f64, defaultp > f64mat2x3

Default double-precision floating-point 2x3 matrix.

Double-precision floating-point 2x3 matrix.

See also
GLM_GTC_type_precision

Definition at line 2552 of file fwd.hpp.

typedef tmat2x4< f64, defaultp > f64mat2x4

Default double-precision floating-point 2x4 matrix.

Double-precision floating-point 2x4 matrix.

See also
GLM_GTC_type_precision

Definition at line 2556 of file fwd.hpp.

typedef tmat3x3< f64, defaultp > f64mat3

Default double-precision floating-point 3x3 matrix.

Double-precision floating-point 3x3 matrix.

See also
GLM_GTC_type_precision

Definition at line 2588 of file fwd.hpp.

typedef tmat3x2< f64, defaultp > f64mat3x2

Default double-precision floating-point 3x2 matrix.

Double-precision floating-point 3x2 matrix.

See also
GLM_GTC_type_precision

Definition at line 2560 of file fwd.hpp.

typedef tmat3x3< f64, defaultp > f64mat3x3

Default double-precision floating-point 3x3 matrix.

Double-precision floating-point 3x3 matrix.

See also
GLM_GTC_type_precision

Definition at line 2564 of file fwd.hpp.

typedef tmat3x4< f64, defaultp > f64mat3x4

Default double-precision floating-point 3x4 matrix.

Double-precision floating-point 3x4 matrix.

See also
GLM_GTC_type_precision

Definition at line 2568 of file fwd.hpp.

typedef tmat4x4< f64, defaultp > f64mat4

Default double-precision floating-point 4x4 matrix.

Double-precision floating-point 4x4 matrix.

See also
GLM_GTC_type_precision

Definition at line 2592 of file fwd.hpp.

typedef tmat4x2< f64, defaultp > f64mat4x2

Default double-precision floating-point 4x2 matrix.

Double-precision floating-point 4x2 matrix.

See also
GLM_GTC_type_precision

Definition at line 2572 of file fwd.hpp.

typedef tmat4x3< f64, defaultp > f64mat4x3

Default double-precision floating-point 4x3 matrix.

Double-precision floating-point 4x3 matrix.

See also
GLM_GTC_type_precision

Definition at line 2576 of file fwd.hpp.

typedef tmat4x4< f64, defaultp > f64mat4x4

Default double-precision floating-point 4x4 matrix.

Double-precision floating-point 4x4 matrix.

See also
GLM_GTC_type_precision

Definition at line 2580 of file fwd.hpp.

typedef tquat< f64, defaultp > f64quat

Default double-precision floating-point quaternion.

Double-precision floating-point quaternion.

See also
GLM_GTC_type_precision

Definition at line 2596 of file fwd.hpp.

typedef tvec1< f64, defaultp > f64vec1

Default double-precision floating-point vector of 1 components.

Double-precision floating-point vector of 1 component.

See also
GLM_GTC_type_precision

Definition at line 2532 of file fwd.hpp.

typedef tvec2< f64, defaultp > f64vec2

Default double-precision floating-point vector of 2 components.

Double-precision floating-point vector of 2 components.

See also
GLM_GTC_type_precision

Definition at line 2536 of file fwd.hpp.

typedef tvec3< f64, defaultp > f64vec3

Default double-precision floating-point vector of 3 components.

Double-precision floating-point vector of 3 components.

See also
GLM_GTC_type_precision

Definition at line 2540 of file fwd.hpp.

typedef tvec4< f64, defaultp > f64vec4

Default double-precision floating-point vector of 4 components.

Double-precision floating-point vector of 4 components.

See also
GLM_GTC_type_precision

Definition at line 2544 of file fwd.hpp.

typedef detail::float32 float32

Default 32 bit single-precision floating-point scalar.

32 bit single-precision floating-point scalar.

See also
GLM_GTC_type_precision

Definition at line 84 of file type_float.hpp.

typedef detail::float32 float32_t

Default 32 bit single-precision floating-point scalar.

32 bit single-precision floating-point scalar.

See also
GLM_GTC_type_precision

Definition at line 1526 of file fwd.hpp.

typedef detail::float64 float64

Default 64 bit double-precision floating-point scalar.

64 bit double-precision floating-point scalar.

See also
GLM_GTC_type_precision

Definition at line 85 of file type_float.hpp.

typedef detail::float64 float64_t

Default 64 bit double-precision floating-point scalar.

64 bit double-precision floating-point scalar.

See also
GLM_GTC_type_precision

Definition at line 1530 of file fwd.hpp.

typedef tmat2x2< f32, defaultp > fmat2

Default single-precision floating-point 2x2 matrix.

Single-precision floating-point 1x1 matrix.

See also
GLM_GTC_type_precision
GLM_GTC_type_precision Single-precision floating-point 2x2 matrix.
GLM_GTC_type_precision

Definition at line 2408 of file fwd.hpp.

typedef tmat2x2< f32, defaultp > fmat2x2

Default single-precision floating-point 2x2 matrix.

Single-precision floating-point 1x1 matrix.

See also
GLM_GTC_type_precision
GLM_GTC_type_precision Single-precision floating-point 2x2 matrix.
GLM_GTC_type_precision

Definition at line 2372 of file fwd.hpp.

typedef tmat2x3< f32, defaultp > fmat2x3

Default single-precision floating-point 2x3 matrix.

Single-precision floating-point 2x3 matrix.

See also
GLM_GTC_type_precision

Definition at line 2376 of file fwd.hpp.

typedef tmat2x4< f32, defaultp > fmat2x4

Default single-precision floating-point 2x4 matrix.

Single-precision floating-point 2x4 matrix.

See also
GLM_GTC_type_precision

Definition at line 2380 of file fwd.hpp.

typedef tmat3x3< f32, defaultp > fmat3

Default single-precision floating-point 3x3 matrix.

Single-precision floating-point 3x3 matrix.

See also
GLM_GTC_type_precision

Definition at line 2412 of file fwd.hpp.

typedef tmat3x2< f32, defaultp > fmat3x2

Default single-precision floating-point 3x2 matrix.

Single-precision floating-point 3x2 matrix.

See also
GLM_GTC_type_precision

Definition at line 2384 of file fwd.hpp.

typedef tmat3x3< f32, defaultp > fmat3x3

Default single-precision floating-point 3x3 matrix.

Single-precision floating-point 3x3 matrix.

See also
GLM_GTC_type_precision

Definition at line 2388 of file fwd.hpp.

typedef tmat3x4< f32, defaultp > fmat3x4

Default single-precision floating-point 3x4 matrix.

Single-precision floating-point 3x4 matrix.

See also
GLM_GTC_type_precision

Definition at line 2392 of file fwd.hpp.

typedef tmat4x4< f32, defaultp > fmat4

Default single-precision floating-point 4x4 matrix.

Single-precision floating-point 4x4 matrix.

See also
GLM_GTC_type_precision

Definition at line 2416 of file fwd.hpp.

typedef tmat4x2< f32, defaultp > fmat4x2

Default single-precision floating-point 4x2 matrix.

Single-precision floating-point 4x2 matrix.

See also
GLM_GTC_type_precision

Definition at line 2396 of file fwd.hpp.

typedef tmat4x3< f32, defaultp > fmat4x3

Default single-precision floating-point 4x3 matrix.

Single-precision floating-point 4x3 matrix.

See also
GLM_GTC_type_precision

Definition at line 2400 of file fwd.hpp.

typedef tmat4x4< f32, defaultp > fmat4x4

Default single-precision floating-point 4x4 matrix.

Single-precision floating-point 4x4 matrix.

See also
GLM_GTC_type_precision

Definition at line 2404 of file fwd.hpp.

typedef tvec1< float, defaultp > fvec1

Default single-precision floating-point vector of 1 components.

Single-precision floating-point vector of 1 component.

See also
GLM_GTC_type_precision

Definition at line 2356 of file fwd.hpp.

typedef tvec2< float, defaultp > fvec2

Default single-precision floating-point vector of 2 components.

Single-precision floating-point vector of 2 components.

See also
GLM_GTC_type_precision

Definition at line 2360 of file fwd.hpp.

typedef tvec3< float, defaultp > fvec3

Default single-precision floating-point vector of 3 components.

Single-precision floating-point vector of 3 components.

See also
GLM_GTC_type_precision

Definition at line 2364 of file fwd.hpp.

typedef tvec4< float, defaultp > fvec4

Default single-precision floating-point vector of 4 components.

Single-precision floating-point vector of 4 components.

See also
GLM_GTC_type_precision

Definition at line 2368 of file fwd.hpp.

typedef detail::int16 highp_i16

High precision 16 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 261 of file fwd.hpp.

typedef detail::int32 highp_i32

High precision 32 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 265 of file fwd.hpp.

typedef detail::int64 highp_i64

High precision 64 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 269 of file fwd.hpp.

typedef detail::int8 highp_i8

High precision 8 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 257 of file fwd.hpp.

typedef detail::int16 highp_int16

High precision 16 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 229 of file fwd.hpp.

typedef detail::int16 highp_int16_t

High precision 16 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 245 of file fwd.hpp.

typedef detail::int32 highp_int32

High precision 32 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 233 of file fwd.hpp.

typedef detail::int32 highp_int32_t

32 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 249 of file fwd.hpp.

typedef detail::int64 highp_int64

High precision 64 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 237 of file fwd.hpp.

typedef detail::int64 highp_int64_t

High precision 64 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 253 of file fwd.hpp.

typedef detail::int8 highp_int8

High precision 8 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 225 of file fwd.hpp.

typedef detail::int8 highp_int8_t

High precision 8 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 241 of file fwd.hpp.

typedef detail::uint16 highp_u16

Medium precision 16 bit unsigned integer type.

High precision 16 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 870 of file fwd.hpp.

typedef detail::uint32 highp_u32

Medium precision 32 bit unsigned integer type.

High precision 32 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 874 of file fwd.hpp.

typedef detail::uint64 highp_u64

Medium precision 64 bit unsigned integer type.

High precision 64 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 878 of file fwd.hpp.

typedef detail::uint8 highp_u8

Medium precision 8 bit unsigned integer type.

High precision 8 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 866 of file fwd.hpp.

typedef detail::uint16 highp_uint16

Medium precision 16 bit unsigned integer type.

High precision 16 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 838 of file fwd.hpp.

typedef detail::uint16 highp_uint16_t

Medium precision 16 bit unsigned integer type.

High precision 16 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 854 of file fwd.hpp.

typedef detail::uint32 highp_uint32

Medium precision 32 bit unsigned integer type.

High precision 32 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 842 of file fwd.hpp.

typedef detail::uint32 highp_uint32_t

Medium precision 32 bit unsigned integer type.

High precision 32 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 858 of file fwd.hpp.

typedef detail::uint64 highp_uint64

Medium precision 64 bit unsigned integer type.

High precision 64 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 846 of file fwd.hpp.

typedef detail::uint64 highp_uint64_t

Medium precision 64 bit unsigned integer type.

High precision 64 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 862 of file fwd.hpp.

typedef detail::uint8 highp_uint8

Medium precision 8 bit unsigned integer type.

High precision 8 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 834 of file fwd.hpp.

typedef detail::uint8 highp_uint8_t

Medium precision 8 bit unsigned integer type.

High precision 8 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 850 of file fwd.hpp.

typedef detail::int16 i16

16 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 318 of file fwd.hpp.

typedef tvec1< i16, defaultp > i16vec1

Default precision 16 bit signed integer scalar type.

16 bit signed integer scalar type.

See also
GLM_GTC_type_precision

Definition at line 473 of file fwd.hpp.

typedef tvec2< i16, defaultp > i16vec2

Default precision 16 bit signed integer vector of 2 components type.

16 bit signed integer vector of 2 components type.

See also
GLM_GTC_type_precision

Definition at line 477 of file fwd.hpp.

typedef tvec3< i16, defaultp > i16vec3

Default precision 16 bit signed integer vector of 3 components type.

16 bit signed integer vector of 3 components type.

See also
GLM_GTC_type_precision

Definition at line 481 of file fwd.hpp.

typedef tvec4< i16, defaultp > i16vec4

Default precision 16 bit signed integer vector of 4 components type.

16 bit signed integer vector of 4 components type.

See also
GLM_GTC_type_precision

Definition at line 485 of file fwd.hpp.

typedef detail::int32 i32

32 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 322 of file fwd.hpp.

typedef tvec1< i32, defaultp > i32vec1

Default precision 32 bit signed integer scalar type.

32 bit signed integer scalar type.

See also
GLM_GTC_type_precision

Definition at line 552 of file fwd.hpp.

typedef tvec2< i32, defaultp > i32vec2

Default precision 32 bit signed integer vector of 2 components type.

32 bit signed integer vector of 2 components type.

See also
GLM_GTC_type_precision

Definition at line 556 of file fwd.hpp.

typedef tvec3< i32, defaultp > i32vec3

Default precision 32 bit signed integer vector of 3 components type.

32 bit signed integer vector of 3 components type.

See also
GLM_GTC_type_precision

Definition at line 560 of file fwd.hpp.

typedef tvec4< i32, defaultp > i32vec4

Default precision 32 bit signed integer vector of 4 components type.

32 bit signed integer vector of 4 components type.

See also
GLM_GTC_type_precision

Definition at line 564 of file fwd.hpp.

typedef detail::int64 i64

64 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 326 of file fwd.hpp.

typedef tvec1< i64, defaultp > i64vec1

Default precision 64 bit signed integer scalar type.

64 bit signed integer scalar type.

See also
GLM_GTC_type_precision

Definition at line 711 of file fwd.hpp.

typedef tvec2< i64, defaultp > i64vec2

Default precision 64 bit signed integer vector of 2 components type.

64 bit signed integer vector of 2 components type.

See also
GLM_GTC_type_precision

Definition at line 715 of file fwd.hpp.

typedef tvec3< i64, defaultp > i64vec3

Default precision 64 bit signed integer vector of 3 components type.

64 bit signed integer vector of 3 components type.

See also
GLM_GTC_type_precision

Definition at line 719 of file fwd.hpp.

typedef tvec4< i64, defaultp > i64vec4

Default precision 64 bit signed integer vector of 4 components type.

64 bit signed integer vector of 4 components type.

See also
GLM_GTC_type_precision

Definition at line 723 of file fwd.hpp.

typedef detail::int8 i8

8 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 314 of file fwd.hpp.

typedef tvec1< i8, defaultp > i8vec1

Default precision 8 bit signed integer scalar type.

8 bit signed integer scalar type.

See also
GLM_GTC_type_precision

Definition at line 393 of file fwd.hpp.

typedef tvec2< i8, defaultp > i8vec2

Default precision 8 bit signed integer vector of 2 components type.

8 bit signed integer vector of 2 components type.

See also
GLM_GTC_type_precision

Definition at line 397 of file fwd.hpp.

typedef tvec3< i8, defaultp > i8vec3

Default precision 8 bit signed integer vector of 3 components type.

8 bit signed integer vector of 3 components type.

See also
GLM_GTC_type_precision

Definition at line 401 of file fwd.hpp.

typedef tvec4< i8, defaultp > i8vec4

Default precision 8 bit signed integer vector of 4 components type.

8 bit signed integer vector of 4 components type.

See also
GLM_GTC_type_precision

Definition at line 405 of file fwd.hpp.

typedef detail::int16 int16

16 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 227 of file type_int.hpp.

typedef detail::int16 int16_t

16 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 301 of file fwd.hpp.

typedef detail::int32 int32

32 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 228 of file type_int.hpp.

typedef detail::int32 int32_t

32 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 305 of file fwd.hpp.

typedef detail::int64 int64

64 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 229 of file type_int.hpp.

typedef detail::int64 int64_t

64 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 309 of file fwd.hpp.

typedef detail::int8 int8

8 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 226 of file type_int.hpp.

typedef detail::int8 int8_t

8 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 297 of file fwd.hpp.

typedef detail::int16 lowp_i16

Low precision 16 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 165 of file fwd.hpp.

typedef detail::int32 lowp_i32

Low precision 32 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 169 of file fwd.hpp.

typedef detail::int64 lowp_i64

Low precision 64 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 173 of file fwd.hpp.

typedef detail::int8 lowp_i8

Low precision 8 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 161 of file fwd.hpp.

typedef detail::int16 lowp_int16

Low precision 16 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 133 of file fwd.hpp.

typedef detail::int16 lowp_int16_t

Low precision 16 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 149 of file fwd.hpp.

typedef detail::int32 lowp_int32

Low precision 32 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 137 of file fwd.hpp.

typedef detail::int32 lowp_int32_t

Low precision 32 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 153 of file fwd.hpp.

typedef detail::int64 lowp_int64

Low precision 64 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 141 of file fwd.hpp.

typedef detail::int64 lowp_int64_t

Low precision 64 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 157 of file fwd.hpp.

typedef detail::int8 lowp_int8

Low precision 8 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 129 of file fwd.hpp.

typedef detail::int8 lowp_int8_t

Low precision 8 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 145 of file fwd.hpp.

typedef detail::uint16 lowp_u16

Low precision 16 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 770 of file fwd.hpp.

typedef detail::uint32 lowp_u32

Low precision 32 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 774 of file fwd.hpp.

typedef detail::uint64 lowp_u64

Low precision 64 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 778 of file fwd.hpp.

typedef detail::uint8 lowp_u8

Low precision 8 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 766 of file fwd.hpp.

typedef detail::uint16 lowp_uint16

Low precision 16 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 736 of file fwd.hpp.

typedef detail::uint16 lowp_uint16_t

Low precision 16 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 753 of file fwd.hpp.

typedef detail::uint32 lowp_uint32

Low precision 32 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 740 of file fwd.hpp.

typedef detail::uint32 lowp_uint32_t

Low precision 32 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 757 of file fwd.hpp.

typedef detail::uint64 lowp_uint64

Low precision 64 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 744 of file fwd.hpp.

typedef detail::uint64 lowp_uint64_t

Low precision 64 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 761 of file fwd.hpp.

typedef detail::uint8 lowp_uint8

Low precision 8 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 732 of file fwd.hpp.

typedef detail::uint8 lowp_uint8_t

Low precision 8 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 749 of file fwd.hpp.

typedef detail::int16 mediump_i16

Medium precision 16 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 213 of file fwd.hpp.

typedef detail::int32 mediump_i32

Medium precision 32 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 217 of file fwd.hpp.

typedef detail::int64 mediump_i64

Medium precision 64 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 221 of file fwd.hpp.

typedef detail::int8 mediump_i8

Medium precision 8 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 209 of file fwd.hpp.

typedef detail::int16 mediump_int16

Medium precision 16 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 181 of file fwd.hpp.

typedef detail::int16 mediump_int16_t

Medium precision 16 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 197 of file fwd.hpp.

typedef detail::int32 mediump_int32

Medium precision 32 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 185 of file fwd.hpp.

typedef detail::int32 mediump_int32_t

Medium precision 32 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 201 of file fwd.hpp.

typedef detail::int64 mediump_int64

Medium precision 64 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 189 of file fwd.hpp.

typedef detail::int64 mediump_int64_t

Medium precision 64 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 205 of file fwd.hpp.

typedef detail::int8 mediump_int8

Medium precision 8 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 177 of file fwd.hpp.

typedef detail::int8 mediump_int8_t

Medium precision 8 bit signed integer type.

See also
GLM_GTC_type_precision

Definition at line 193 of file fwd.hpp.

typedef detail::uint16 mediump_u16

Medium precision 16 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 820 of file fwd.hpp.

typedef detail::uint32 mediump_u32

Medium precision 32 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 824 of file fwd.hpp.

typedef detail::uint64 mediump_u64

Medium precision 64 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 828 of file fwd.hpp.

typedef detail::uint8 mediump_u8

Medium precision 8 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 816 of file fwd.hpp.

typedef detail::uint16 mediump_uint16

Medium precision 16 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 788 of file fwd.hpp.

typedef detail::uint16 mediump_uint16_t

Medium precision 16 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 804 of file fwd.hpp.

typedef detail::uint32 mediump_uint32

Medium precision 32 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 792 of file fwd.hpp.

typedef detail::uint32 mediump_uint32_t

Medium precision 32 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 808 of file fwd.hpp.

typedef detail::uint64 mediump_uint64

Medium precision 64 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 796 of file fwd.hpp.

typedef detail::uint64 mediump_uint64_t

Medium precision 64 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 812 of file fwd.hpp.

typedef detail::uint8 mediump_uint8

Medium precision 8 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 784 of file fwd.hpp.

typedef detail::uint8 mediump_uint8_t

Medium precision 8 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 800 of file fwd.hpp.

typedef detail::uint16 u16

16 bit unsigned integer type.

Default precision 16 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 927 of file fwd.hpp.

typedef tvec1< u16, defaultp > u16vec1

Default precision 16 bit unsigned integer scalar type.

See also
GLM_GTC_type_precision

Definition at line 1082 of file fwd.hpp.

typedef tvec2< u16, defaultp > u16vec2

Default precision 16 bit unsigned integer vector of 2 components type.

See also
GLM_GTC_type_precision

Definition at line 1086 of file fwd.hpp.

typedef tvec3< u16, defaultp > u16vec3

Default precision 16 bit unsigned integer vector of 3 components type.

See also
GLM_GTC_type_precision

Definition at line 1090 of file fwd.hpp.

typedef tvec4< u16, defaultp > u16vec4

Default precision 16 bit unsigned integer vector of 4 components type.

See also
GLM_GTC_type_precision

Definition at line 1094 of file fwd.hpp.

typedef detail::uint32 u32

32 bit unsigned integer type.

Default precision 32 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 931 of file fwd.hpp.

typedef tvec1< u32, defaultp > u32vec1

Default precision 32 bit unsigned integer scalar type.

See also
GLM_GTC_type_precision

Definition at line 1161 of file fwd.hpp.

typedef tvec2< u32, defaultp > u32vec2

Default precision 32 bit unsigned integer vector of 2 components type.

See also
GLM_GTC_type_precision

Definition at line 1165 of file fwd.hpp.

typedef tvec3< u32, defaultp > u32vec3

Default precision 32 bit unsigned integer vector of 3 components type.

See also
GLM_GTC_type_precision

Definition at line 1169 of file fwd.hpp.

typedef tvec4< u32, defaultp > u32vec4

Default precision 32 bit unsigned integer vector of 4 components type.

See also
GLM_GTC_type_precision

Definition at line 1173 of file fwd.hpp.

typedef detail::uint64 u64

64 bit unsigned integer type.

Default precision 64 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 935 of file fwd.hpp.

typedef tvec1< u64, defaultp > u64vec1

Default precision 64 bit unsigned integer scalar type.

See also
GLM_GTC_type_precision

Definition at line 1320 of file fwd.hpp.

typedef tvec2< u64, defaultp > u64vec2

Default precision 64 bit unsigned integer vector of 2 components type.

See also
GLM_GTC_type_precision

Definition at line 1324 of file fwd.hpp.

typedef tvec3< u64, defaultp > u64vec3

Default precision 64 bit unsigned integer vector of 3 components type.

See also
GLM_GTC_type_precision

Definition at line 1328 of file fwd.hpp.

typedef tvec4< u64, defaultp > u64vec4

Default precision 64 bit unsigned integer vector of 4 components type.

See also
GLM_GTC_type_precision

Definition at line 1332 of file fwd.hpp.

typedef detail::uint8 u8

8 bit unsigned integer type.

Default precision 8 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 923 of file fwd.hpp.

typedef tvec1< u8, defaultp > u8vec1

Default precision 8 bit unsigned integer scalar type.

See also
GLM_GTC_type_precision

Definition at line 1002 of file fwd.hpp.

typedef tvec2< u8, defaultp > u8vec2

Default precision 8 bit unsigned integer vector of 2 components type.

See also
GLM_GTC_type_precision

Definition at line 1006 of file fwd.hpp.

typedef tvec3< u8, defaultp > u8vec3

Default precision 8 bit unsigned integer vector of 3 components type.

See also
GLM_GTC_type_precision

Definition at line 1010 of file fwd.hpp.

typedef tvec4< u8, defaultp > u8vec4

Default precision 8 bit unsigned integer vector of 4 components type.

See also
GLM_GTC_type_precision

Definition at line 1014 of file fwd.hpp.

typedef detail::uint16 uint16

16 bit unsigned integer type.

Default precision 16 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 232 of file type_int.hpp.

typedef detail::uint16 uint16_t

16 bit unsigned integer type.

Default precision 16 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 910 of file fwd.hpp.

typedef detail::uint32 uint32

32 bit unsigned integer type.

Default precision 32 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 233 of file type_int.hpp.

typedef detail::uint32 uint32_t

32 bit unsigned integer type.

Default precision 32 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 914 of file fwd.hpp.

typedef detail::uint64 uint64

64 bit unsigned integer type.

Default precision 64 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 234 of file type_int.hpp.

typedef detail::uint64 uint64_t

64 bit unsigned integer type.

Default precision 64 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 918 of file fwd.hpp.

typedef detail::uint8 uint8

8 bit unsigned integer type.

Default precision 8 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 231 of file type_int.hpp.

typedef detail::uint8 uint8_t

8 bit unsigned integer type.

Default precision 8 bit unsigned integer type.

See also
GLM_GTC_type_precision

Definition at line 906 of file fwd.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00182.html000066400000000000000000000613741356361734700216600ustar00rootroot00000000000000 0.9.7: GLM_GTC_type_ptr
Functions
GLM_GTC_type_ptr
GTC Extensions (Stable)

Functions

template<typename T >
GLM_FUNC_DECL tmat2x2< T, defaultp > make_mat2 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tmat2x2< T, defaultp > make_mat2x2 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tmat2x3< T, defaultp > make_mat2x3 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tmat2x4< T, defaultp > make_mat2x4 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tmat3x3< T, defaultp > make_mat3 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tmat3x2< T, defaultp > make_mat3x2 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tmat3x3< T, defaultp > make_mat3x3 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tmat3x4< T, defaultp > make_mat3x4 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > make_mat4 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tmat4x2< T, defaultp > make_mat4x2 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tmat4x3< T, defaultp > make_mat4x3 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > make_mat4x4 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tquat< T, defaultp > make_quat (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tvec2< T, defaultp > make_vec2 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tvec3< T, defaultp > make_vec3 (T const *const ptr)
 
template<typename T >
GLM_FUNC_DECL tvec4< T, defaultp > make_vec4 (T const *const ptr)
 
template<typename genType >
GLM_FUNC_DECL genType::value_type const * value_ptr (genType const &vec)
 

Detailed Description

Handles the interaction between pointers and vector, matrix types.

This extension defines an overloaded function, glm::value_ptr, which takes any of the core template types. It returns a pointer to the memory layout of the object. Matrix types store their values in column-major order.

This is useful for uploading data to matrices or copying data to buffer objects.

Example:

#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
glm::vec3 aVector(3);
glm::mat4 someMatrix(1.0);
glUniform3fv(uniformLoc, 1, glm::value_ptr(aVector));
glUniformMatrix4fv(uniformMatrixLoc, 1, GL_FALSE, glm::value_ptr(someMatrix));

<glm/gtc/type_ptr.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL tmat2x2<T, defaultp> glm::make_mat2 ( T const *const  ptr)

Build a matrix from a pointer.

See also
GLM_GTC_type_ptr
GLM_FUNC_DECL tmat2x2<T, defaultp> glm::make_mat2x2 ( T const *const  ptr)

Build a matrix from a pointer.

See also
GLM_GTC_type_ptr
GLM_FUNC_DECL tmat2x3<T, defaultp> glm::make_mat2x3 ( T const *const  ptr)

Build a matrix from a pointer.

See also
GLM_GTC_type_ptr
GLM_FUNC_DECL tmat2x4<T, defaultp> glm::make_mat2x4 ( T const *const  ptr)

Build a matrix from a pointer.

See also
GLM_GTC_type_ptr
GLM_FUNC_DECL tmat3x3<T, defaultp> glm::make_mat3 ( T const *const  ptr)

Build a matrix from a pointer.

See also
GLM_GTC_type_ptr
GLM_FUNC_DECL tmat3x2<T, defaultp> glm::make_mat3x2 ( T const *const  ptr)

Build a matrix from a pointer.

See also
GLM_GTC_type_ptr
GLM_FUNC_DECL tmat3x3<T, defaultp> glm::make_mat3x3 ( T const *const  ptr)

Build a matrix from a pointer.

See also
GLM_GTC_type_ptr
GLM_FUNC_DECL tmat3x4<T, defaultp> glm::make_mat3x4 ( T const *const  ptr)

Build a matrix from a pointer.

See also
GLM_GTC_type_ptr
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::make_mat4 ( T const *const  ptr)

Build a matrix from a pointer.

See also
GLM_GTC_type_ptr
GLM_FUNC_DECL tmat4x2<T, defaultp> glm::make_mat4x2 ( T const *const  ptr)

Build a matrix from a pointer.

See also
GLM_GTC_type_ptr
GLM_FUNC_DECL tmat4x3<T, defaultp> glm::make_mat4x3 ( T const *const  ptr)

Build a matrix from a pointer.

See also
GLM_GTC_type_ptr
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::make_mat4x4 ( T const *const  ptr)

Build a matrix from a pointer.

See also
GLM_GTC_type_ptr
GLM_FUNC_DECL tquat<T, defaultp> glm::make_quat ( T const *const  ptr)

Build a quaternion from a pointer.

See also
GLM_GTC_type_ptr
GLM_FUNC_DECL tvec2<T, defaultp> glm::make_vec2 ( T const *const  ptr)

Build a vector from a pointer.

See also
GLM_GTC_type_ptr
GLM_FUNC_DECL tvec3<T, defaultp> glm::make_vec3 ( T const *const  ptr)

Build a vector from a pointer.

See also
GLM_GTC_type_ptr
GLM_FUNC_DECL tvec4<T, defaultp> glm::make_vec4 ( T const *const  ptr)

Build a vector from a pointer.

See also
GLM_GTC_type_ptr
GLM_FUNC_DECL genType::value_type const* glm::value_ptr ( genType const &  vec)

Return the constant address to the data of the input parameter.

See also
GLM_GTC_type_ptr
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00183.html000066400000000000000000000265611356361734700216600ustar00rootroot00000000000000 0.9.7: GLM_GTC_ulp
Functions
GLM_GTC_ulp
GTC Extensions (Stable)

Functions

template<typename T >
GLM_FUNC_DECL uint float_distance (T const &x, T const &y)
 
template<typename T , template< typename > class vecType>
GLM_FUNC_DECL vecType< uint > float_distance (vecType< T > const &x, vecType< T > const &y)
 
template<typename genType >
GLM_FUNC_DECL genType next_float (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL genType next_float (genType const &x, uint const &Distance)
 
template<typename genType >
GLM_FUNC_DECL genType prev_float (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL genType prev_float (genType const &x, uint const &Distance)
 

Detailed Description

Allow the measurement of the accuracy of a function against a reference implementation.

This extension works on floating-point data and provide results in ULP. <glm/gtc/ulp.hpp> need to be included to use these features.

Function Documentation

GLM_FUNC_DECL uint glm::float_distance ( T const &  x,
T const &  y 
)

Return the distance in the number of ULP between 2 scalars.

See also
GLM_GTC_ulp
GLM_FUNC_DECL vecType<uint> glm::float_distance ( vecType< T > const &  x,
vecType< T > const &  y 
)

Return the distance in the number of ULP between 2 vectors.

See also
GLM_GTC_ulp
GLM_FUNC_DECL genType glm::next_float ( genType const &  x)

Return the next ULP value(s) after the input value(s).

See also
GLM_GTC_ulp
GLM_FUNC_DECL genType glm::next_float ( genType const &  x,
uint const &  Distance 
)

Return the value(s) ULP distance after the input value(s).

See also
GLM_GTC_ulp
GLM_FUNC_DECL genType glm::prev_float ( genType const &  x)

Return the previous ULP value(s) before the input value(s).

See also
GLM_GTC_ulp
GLM_FUNC_DECL genType glm::prev_float ( genType const &  x,
uint const &  Distance 
)

Return the value(s) ULP distance before the input value(s).

See also
GLM_GTC_ulp
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00184.html000066400000000000000000000040061356361734700216470ustar00rootroot00000000000000 0.9.7: GLM_GTC_vec1
GLM_GTC_vec1
GTC Extensions (Stable)

Add vec1, ivec1, uvec1 and bvec1 types.

<glm/gtc/vec1.hpp> need to be included to use these functionalities.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00185.html000066400000000000000000001615241356361734700216610ustar00rootroot00000000000000 0.9.7: GLM_GTX_associated_min_max
Functions
GLM_GTX_associated_min_max
GTX Extensions (Experimental)

Functions

template<typename T , typename U >
GLM_FUNC_DECL U associatedMax (T x, U a, T y, U b)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL tvec2< U, P > associatedMax (vecType< T, P > const &x, vecType< U, P > const &a, vecType< T, P > const &y, vecType< U, P > const &b)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > associatedMax (T x, vecType< U, P > const &a, T y, vecType< U, P > const &b)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMax (vecType< T, P > const &x, U a, vecType< T, P > const &y, U b)
 
template<typename T , typename U >
GLM_FUNC_DECL U associatedMax (T x, U a, T y, U b, T z, U c)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMax (vecType< T, P > const &x, vecType< U, P > const &a, vecType< T, P > const &y, vecType< U, P > const &b, vecType< T, P > const &z, vecType< U, P > const &c)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > associatedMax (T x, vecType< U, P > const &a, T y, vecType< U, P > const &b, T z, vecType< U, P > const &c)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMax (vecType< T, P > const &x, U a, vecType< T, P > const &y, U b, vecType< T, P > const &z, U c)
 
template<typename T , typename U >
GLM_FUNC_DECL U associatedMax (T x, U a, T y, U b, T z, U c, T w, U d)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMax (vecType< T, P > const &x, vecType< U, P > const &a, vecType< T, P > const &y, vecType< U, P > const &b, vecType< T, P > const &z, vecType< U, P > const &c, vecType< T, P > const &w, vecType< U, P > const &d)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMax (T x, vecType< U, P > const &a, T y, vecType< U, P > const &b, T z, vecType< U, P > const &c, T w, vecType< U, P > const &d)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMax (vecType< T, P > const &x, U a, vecType< T, P > const &y, U b, vecType< T, P > const &z, U c, vecType< T, P > const &w, U d)
 
template<typename T , typename U , precision P>
GLM_FUNC_DECL U associatedMin (T x, U a, T y, U b)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL tvec2< U, P > associatedMin (vecType< T, P > const &x, vecType< U, P > const &a, vecType< T, P > const &y, vecType< U, P > const &b)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMin (T x, const vecType< U, P > &a, T y, const vecType< U, P > &b)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMin (vecType< T, P > const &x, U a, vecType< T, P > const &y, U b)
 
template<typename T , typename U >
GLM_FUNC_DECL U associatedMin (T x, U a, T y, U b, T z, U c)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMin (vecType< T, P > const &x, vecType< U, P > const &a, vecType< T, P > const &y, vecType< U, P > const &b, vecType< T, P > const &z, vecType< U, P > const &c)
 
template<typename T , typename U >
GLM_FUNC_DECL U associatedMin (T x, U a, T y, U b, T z, U c, T w, U d)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMin (vecType< T, P > const &x, vecType< U, P > const &a, vecType< T, P > const &y, vecType< U, P > const &b, vecType< T, P > const &z, vecType< U, P > const &c, vecType< T, P > const &w, vecType< U, P > const &d)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMin (T x, vecType< U, P > const &a, T y, vecType< U, P > const &b, T z, vecType< U, P > const &c, T w, vecType< U, P > const &d)
 
template<typename T , typename U , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< U, P > associatedMin (vecType< T, P > const &x, U a, vecType< T, P > const &y, U b, vecType< T, P > const &z, U c, vecType< T, P > const &w, U d)
 

Detailed Description

Min and max functions that return associated values not the compared onces.

<glm/gtx/associated_min_max.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL U glm::associatedMax ( T  x,
U  a,
T  y,
U  b 
)

Maximum comparison between 2 variables and returns 2 associated variable values.

See also
GLM_GTX_associated_min_max
GLM_FUNC_DECL tvec2<U, P> glm::associatedMax ( vecType< T, P > const &  x,
vecType< U, P > const &  a,
vecType< T, P > const &  y,
vecType< U, P > const &  b 
)

Maximum comparison between 2 variables and returns 2 associated variable values.

See also
GLM_GTX_associated_min_max
GLM_FUNC_DECL vecType<T, P> glm::associatedMax ( T  x,
vecType< U, P > const &  a,
T  y,
vecType< U, P > const &  b 
)

Maximum comparison between 2 variables and returns 2 associated variable values.

See also
GLM_GTX_associated_min_max
GLM_FUNC_DECL vecType<U, P> glm::associatedMax ( vecType< T, P > const &  x,
U  a,
vecType< T, P > const &  y,
U  b 
)

Maximum comparison between 2 variables and returns 2 associated variable values.

See also
GLM_GTX_associated_min_max
GLM_FUNC_DECL U glm::associatedMax ( T  x,
U  a,
T  y,
U  b,
T  z,
U  c 
)

Maximum comparison between 3 variables and returns 3 associated variable values.

See also
GLM_GTX_associated_min_max
GLM_FUNC_DECL vecType<U, P> glm::associatedMax ( vecType< T, P > const &  x,
vecType< U, P > const &  a,
vecType< T, P > const &  y,
vecType< U, P > const &  b,
vecType< T, P > const &  z,
vecType< U, P > const &  c 
)

Maximum comparison between 3 variables and returns 3 associated variable values.

See also
GLM_GTX_associated_min_max
GLM_FUNC_DECL vecType<T, P> glm::associatedMax ( T  x,
vecType< U, P > const &  a,
T  y,
vecType< U, P > const &  b,
T  z,
vecType< U, P > const &  c 
)

Maximum comparison between 3 variables and returns 3 associated variable values.

See also
GLM_GTX_associated_min_max
GLM_FUNC_DECL vecType<U, P> glm::associatedMax ( vecType< T, P > const &  x,
U  a,
vecType< T, P > const &  y,
U  b,
vecType< T, P > const &  z,
U  c 
)

Maximum comparison between 3 variables and returns 3 associated variable values.

See also
GLM_GTX_associated_min_max
GLM_FUNC_DECL U glm::associatedMax ( T  x,
U  a,
T  y,
U  b,
T  z,
U  c,
T  w,
U  d 
)

Maximum comparison between 4 variables and returns 4 associated variable values.

See also
GLM_GTX_associated_min_max
GLM_FUNC_DECL vecType<U, P> glm::associatedMax ( vecType< T, P > const &  x,
vecType< U, P > const &  a,
vecType< T, P > const &  y,
vecType< U, P > const &  b,
vecType< T, P > const &  z,
vecType< U, P > const &  c,
vecType< T, P > const &  w,
vecType< U, P > const &  d 
)

Maximum comparison between 4 variables and returns 4 associated variable values.

See also
GLM_GTX_associated_min_max
GLM_FUNC_DECL vecType<U, P> glm::associatedMax ( T  x,
vecType< U, P > const &  a,
T  y,
vecType< U, P > const &  b,
T  z,
vecType< U, P > const &  c,
T  w,
vecType< U, P > const &  d 
)

Maximum comparison between 4 variables and returns 4 associated variable values.

See also
GLM_GTX_associated_min_max
GLM_FUNC_DECL vecType<U, P> glm::associatedMax ( vecType< T, P > const &  x,
U  a,
vecType< T, P > const &  y,
U  b,
vecType< T, P > const &  z,
U  c,
vecType< T, P > const &  w,
U  d 
)

Maximum comparison between 4 variables and returns 4 associated variable values.

See also
GLM_GTX_associated_min_max
GLM_FUNC_DECL U glm::associatedMin ( T  x,
U  a,
T  y,
U  b 
)

Minimum comparison between 2 variables and returns 2 associated variable values.

See also
GLM_GTX_associated_min_max
GLM_FUNC_DECL tvec2<U, P> glm::associatedMin ( vecType< T, P > const &  x,
vecType< U, P > const &  a,
vecType< T, P > const &  y,
vecType< U, P > const &  b 
)

Minimum comparison between 2 variables and returns 2 associated variable values.

See also
GLM_GTX_associated_min_max
GLM_FUNC_DECL vecType<U, P> glm::associatedMin ( T  x,
const vecType< U, P > &  a,
T  y,
const vecType< U, P > &  b 
)

Minimum comparison between 2 variables and returns 2 associated variable values.

See also
GLM_GTX_associated_min_max
GLM_FUNC_DECL vecType<U, P> glm::associatedMin ( vecType< T, P > const &  x,
U  a,
vecType< T, P > const &  y,
U  b 
)

Minimum comparison between 2 variables and returns 2 associated variable values.

See also
GLM_GTX_associated_min_max
GLM_FUNC_DECL U glm::associatedMin ( T  x,
U  a,
T  y,
U  b,
T  z,
U  c 
)

Minimum comparison between 3 variables and returns 3 associated variable values.

See also
GLM_GTX_associated_min_max
GLM_FUNC_DECL vecType<U, P> glm::associatedMin ( vecType< T, P > const &  x,
vecType< U, P > const &  a,
vecType< T, P > const &  y,
vecType< U, P > const &  b,
vecType< T, P > const &  z,
vecType< U, P > const &  c 
)

Minimum comparison between 3 variables and returns 3 associated variable values.

See also
GLM_GTX_associated_min_max
GLM_FUNC_DECL U glm::associatedMin ( T  x,
U  a,
T  y,
U  b,
T  z,
U  c,
T  w,
U  d 
)

Minimum comparison between 4 variables and returns 4 associated variable values.

See also
GLM_GTX_associated_min_max
GLM_FUNC_DECL vecType<U, P> glm::associatedMin ( vecType< T, P > const &  x,
vecType< U, P > const &  a,
vecType< T, P > const &  y,
vecType< U, P > const &  b,
vecType< T, P > const &  z,
vecType< U, P > const &  c,
vecType< T, P > const &  w,
vecType< U, P > const &  d 
)

Minimum comparison between 4 variables and returns 4 associated variable values.

See also
GLM_GTX_associated_min_max
GLM_FUNC_DECL vecType<U, P> glm::associatedMin ( T  x,
vecType< U, P > const &  a,
T  y,
vecType< U, P > const &  b,
T  z,
vecType< U, P > const &  c,
T  w,
vecType< U, P > const &  d 
)

Minimum comparison between 4 variables and returns 4 associated variable values.

See also
GLM_GTX_associated_min_max
GLM_FUNC_DECL vecType<U, P> glm::associatedMin ( vecType< T, P > const &  x,
U  a,
vecType< T, P > const &  y,
U  b,
vecType< T, P > const &  z,
U  c,
vecType< T, P > const &  w,
U  d 
)

Minimum comparison between 4 variables and returns 4 associated variable values.

See also
GLM_GTX_associated_min_max
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00186.html000066400000000000000000000335601356361734700216600ustar00rootroot00000000000000 0.9.7: GLM_GTX_bit
Functions
GLM_GTX_bit
GTX Extensions (Experimental)

Functions

template<typename genIUType >
GLM_FUNC_DECL genIUType highestBitValue (genIUType Value)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > highestBitValue (vecType< T, P > const &value)
 
template<typename genIUType >
GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoAbove (genIUType Value)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_DEPRECATED GLM_FUNC_DECL vecType< T, P > powerOfTwoAbove (vecType< T, P > const &value)
 
template<typename genIUType >
GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoBelow (genIUType Value)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_DEPRECATED GLM_FUNC_DECL vecType< T, P > powerOfTwoBelow (vecType< T, P > const &value)
 
template<typename genIUType >
GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoNearest (genIUType Value)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_DEPRECATED GLM_FUNC_DECL vecType< T, P > powerOfTwoNearest (vecType< T, P > const &value)
 

Detailed Description

Allow to perform bit operations on integer values.

<glm/gtx/bit.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL genIUType glm::highestBitValue ( genIUType  Value)
See also
GLM_GTX_bit
GLM_FUNC_DECL vecType<T, P> glm::highestBitValue ( vecType< T, P > const &  value)

Find the highest bit set to 1 in a integer variable and return its value.

See also
GLM_GTX_bit
GLM_DEPRECATED GLM_FUNC_DECL genIUType glm::powerOfTwoAbove ( genIUType  Value)

Return the power of two number which value is just higher the input value.

Deprecated, use ceilPowerOfTwo from GTC_round instead

See also
GLM_GTC_round
GLM_GTX_bit
GLM_DEPRECATED GLM_FUNC_DECL vecType<T, P> glm::powerOfTwoAbove ( vecType< T, P > const &  value)

Return the power of two number which value is just higher the input value.

Deprecated, use ceilPowerOfTwo from GTC_round instead

See also
GLM_GTC_round
GLM_GTX_bit
GLM_DEPRECATED GLM_FUNC_DECL genIUType glm::powerOfTwoBelow ( genIUType  Value)

Return the power of two number which value is just lower the input value.

Deprecated, use floorPowerOfTwo from GTC_round instead

See also
GLM_GTC_round
GLM_GTX_bit
GLM_DEPRECATED GLM_FUNC_DECL vecType<T, P> glm::powerOfTwoBelow ( vecType< T, P > const &  value)

Return the power of two number which value is just lower the input value.

Deprecated, use floorPowerOfTwo from GTC_round instead

See also
GLM_GTC_round
GLM_GTX_bit
GLM_DEPRECATED GLM_FUNC_DECL genIUType glm::powerOfTwoNearest ( genIUType  Value)

Return the power of two number which value is the closet to the input value.

Deprecated, use roundPowerOfTwo from GTC_round instead

See also
GLM_GTC_round
GLM_GTX_bit
GLM_DEPRECATED GLM_FUNC_DECL vecType<T, P> glm::powerOfTwoNearest ( vecType< T, P > const &  value)

Return the power of two number which value is the closet to the input value.

Deprecated, use roundPowerOfTwo from GTC_round instead

See also
GLM_GTC_round
GLM_GTX_bit
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00187.html000066400000000000000000000117711356361734700216610ustar00rootroot00000000000000 0.9.7: GLM_GTX_closest_point
Functions
GLM_GTX_closest_point
GTX Extensions (Experimental)

Functions

template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > closestPointOnLine (tvec3< T, P > const &point, tvec3< T, P > const &a, tvec3< T, P > const &b)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec2< T, P > closestPointOnLine (tvec2< T, P > const &point, tvec2< T, P > const &a, tvec2< T, P > const &b)
 

Detailed Description

Find the point on a straight line which is the closet of a point.

<glm/gtx/closest_point.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL tvec3<T, P> glm::closestPointOnLine ( tvec3< T, P > const &  point,
tvec3< T, P > const &  a,
tvec3< T, P > const &  b 
)

Find the point on a straight line which is the closet of a point.

See also
GLM_GTX_closest_point
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00188.html000066400000000000000000000247771356361734700216740ustar00rootroot00000000000000 0.9.7: GLM_GTX_color_space
Functions
GLM_GTX_color_space
GTX Extensions (Experimental)

Functions

template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > hsvColor (tvec3< T, P > const &rgbValue)
 
template<typename T , precision P>
GLM_FUNC_DECL T luminosity (tvec3< T, P > const &color)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > rgbColor (tvec3< T, P > const &hsvValue)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > saturation (T const s)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > saturation (T const s, tvec3< T, P > const &color)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< T, P > saturation (T const s, tvec4< T, P > const &color)
 

Detailed Description

Related to RGB to HSV conversions and operations.

<glm/gtx/color_space.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL tvec3<T, P> glm::hsvColor ( tvec3< T, P > const &  rgbValue)

Converts a color from RGB color space to its color in HSV color space.

See also
GLM_GTX_color_space
GLM_FUNC_DECL T glm::luminosity ( tvec3< T, P > const &  color)

Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals.

See also
GLM_GTX_color_space
GLM_FUNC_DECL tvec3<T, P> glm::rgbColor ( tvec3< T, P > const &  hsvValue)

Converts a color from HSV color space to its color in RGB color space.

See also
GLM_GTX_color_space
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::saturation ( T const  s)

Build a saturation matrix.

See also
GLM_GTX_color_space
GLM_FUNC_DECL tvec3<T, P> glm::saturation ( T const  s,
tvec3< T, P > const &  color 
)

Modify the saturation of a color.

See also
GLM_GTX_color_space
GLM_FUNC_DECL tvec4<T, P> glm::saturation ( T const  s,
tvec4< T, P > const &  color 
)

Modify the saturation of a color.

See also
GLM_GTX_color_space
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00189.html000066400000000000000000000173251356361734700216640ustar00rootroot00000000000000 0.9.7: GLM_GTX_color_space_YCoCg
Functions
GLM_GTX_color_space_YCoCg
GTX Extensions (Experimental)

Functions

template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > rgb2YCoCg (tvec3< T, P > const &rgbColor)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > rgb2YCoCgR (tvec3< T, P > const &rgbColor)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > YCoCg2rgb (tvec3< T, P > const &YCoCgColor)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > YCoCgR2rgb (tvec3< T, P > const &YCoCgColor)
 

Detailed Description

RGB to YCoCg conversions and operations.

<glm/gtx/color_space_YCoCg.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL tvec3<T, P> glm::rgb2YCoCg ( tvec3< T, P > const &  rgbColor)

Convert a color from RGB color space to YCoCg color space.

See also
GLM_GTX_color_space_YCoCg
GLM_FUNC_DECL tvec3<T, P> glm::rgb2YCoCgR ( tvec3< T, P > const &  rgbColor)

Convert a color from RGB color space to YCoCgR color space.

See also
"YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
GLM_GTX_color_space_YCoCg
GLM_FUNC_DECL tvec3<T, P> glm::YCoCg2rgb ( tvec3< T, P > const &  YCoCgColor)

Convert a color from YCoCg color space to RGB color space.

See also
GLM_GTX_color_space_YCoCg
GLM_FUNC_DECL tvec3<T, P> glm::YCoCgR2rgb ( tvec3< T, P > const &  YCoCgColor)

Convert a color from YCoCgR color space to RGB color space.

See also
"YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
GLM_GTX_color_space_YCoCg
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00190.html000066400000000000000000000131721356361734700216500ustar00rootroot00000000000000 0.9.7: GLM_GTX_common
Functions
GLM_GTX_common
GTX Extensions (Experimental)

Functions

template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > fmod (vecType< T, P > const &v)
 
template<typename genType >
GLM_FUNC_DECL genType::bool_type isdenormal (genType const &x)
 

Detailed Description

Provide functions to increase the compatibility with Cg and HLSL languages.

<glm/gtx/common.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL vecType<T, P> glm::fmod ( vecType< T, P > const &  v)

Similiar to 'mod' but with a different rounding and integer support.

Returns 'x - y * trunc(x/y)' instead of 'x - y * floor(x/y)'

See also
GLSL mod vs HLSL fmod
GLSL mod man page
GLM_FUNC_DECL genType::bool_type glm::isdenormal ( genType const &  x)

Returns true if x is a denormalized number Numbers whose absolute value is too small to be represented in the normal format are represented in an alternate, denormalized format.

This format is less precise but can represent values closer to zero.

Template Parameters
genTypeFloating-point scalar or vector types.
See also
GLSL isnan man page
GLSL 4.20.8 specification, section 8.3 Common Functions
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00191.html000066400000000000000000001205471356361734700216560ustar00rootroot00000000000000 0.9.7: GLM_GTX_compatibility
Typedefs | Functions
GLM_GTX_compatibility
GTX Extensions (Experimental)

Typedefs

typedef bool bool1
 
typedef bool bool1x1
 
typedef tvec2< bool, highp > bool2
 
typedef tmat2x2< bool, highp > bool2x2
 
typedef tmat2x3< bool, highp > bool2x3
 
typedef tmat2x4< bool, highp > bool2x4
 
typedef tvec3< bool, highp > bool3
 
typedef tmat3x2< bool, highp > bool3x2
 
typedef tmat3x3< bool, highp > bool3x3
 
typedef tmat3x4< bool, highp > bool3x4
 
typedef tvec4< bool, highp > bool4
 
typedef tmat4x2< bool, highp > bool4x2
 
typedef tmat4x3< bool, highp > bool4x3
 
typedef tmat4x4< bool, highp > bool4x4
 
typedef double double1
 
typedef double double1x1
 
typedef tvec2< double, highp > double2
 
typedef tmat2x2< double, highp > double2x2
 
typedef tmat2x3< double, highp > double2x3
 
typedef tmat2x4< double, highp > double2x4
 
typedef tvec3< double, highp > double3
 
typedef tmat3x2< double, highp > double3x2
 
typedef tmat3x3< double, highp > double3x3
 
typedef tmat3x4< double, highp > double3x4
 
typedef tvec4< double, highp > double4
 
typedef tmat4x2< double, highp > double4x2
 
typedef tmat4x3< double, highp > double4x3
 
typedef tmat4x4< double, highp > double4x4
 
typedef float float1
 
typedef float float1x1
 
typedef tvec2< float, highp > float2
 
typedef tmat2x2< float, highp > float2x2
 
typedef tmat2x3< float, highp > float2x3
 
typedef tmat2x4< float, highp > float2x4
 
typedef tvec3< float, highp > float3
 
typedef tmat3x2< float, highp > float3x2
 
typedef tmat3x3< float, highp > float3x3
 
typedef tmat3x4< float, highp > float3x4
 
typedef tvec4< float, highp > float4
 
typedef tmat4x2< float, highp > float4x2
 
typedef tmat4x3< float, highp > float4x3
 
typedef tmat4x4< float, highp > float4x4
 
typedef int int1
 
typedef int int1x1
 
typedef tvec2< int, highp > int2
 
typedef tmat2x2< int, highp > int2x2
 
typedef tmat2x3< int, highp > int2x3
 
typedef tmat2x4< int, highp > int2x4
 
typedef tvec3< int, highp > int3
 
typedef tmat3x2< int, highp > int3x2
 
typedef tmat3x3< int, highp > int3x3
 
typedef tmat3x4< int, highp > int3x4
 
typedef tvec4< int, highp > int4
 
typedef tmat4x2< int, highp > int4x2
 
typedef tmat4x3< int, highp > int4x3
 
typedef tmat4x4< int, highp > int4x4
 

Functions

template<typename T , precision P>
GLM_FUNC_QUALIFIER T atan2 (T x, T y)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec2< T, P > atan2 (const tvec2< T, P > &x, const tvec2< T, P > &y)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec3< T, P > atan2 (const tvec3< T, P > &x, const tvec3< T, P > &y)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec4< T, P > atan2 (const tvec4< T, P > &x, const tvec4< T, P > &y)
 
template<typename genType >
GLM_FUNC_DECL bool isfinite (genType const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec1< bool, P > isfinite (const tvec1< T, P > &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec2< bool, P > isfinite (const tvec2< T, P > &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< bool, P > isfinite (const tvec3< T, P > &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< bool, P > isfinite (const tvec4< T, P > &x)
 
template<typename T >
GLM_FUNC_QUALIFIER T lerp (T x, T y, T a)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec2< T, P > lerp (const tvec2< T, P > &x, const tvec2< T, P > &y, T a)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec3< T, P > lerp (const tvec3< T, P > &x, const tvec3< T, P > &y, T a)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec4< T, P > lerp (const tvec4< T, P > &x, const tvec4< T, P > &y, T a)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec2< T, P > lerp (const tvec2< T, P > &x, const tvec2< T, P > &y, const tvec2< T, P > &a)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec3< T, P > lerp (const tvec3< T, P > &x, const tvec3< T, P > &y, const tvec3< T, P > &a)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec4< T, P > lerp (const tvec4< T, P > &x, const tvec4< T, P > &y, const tvec4< T, P > &a)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER T saturate (T x)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec2< T, P > saturate (const tvec2< T, P > &x)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec3< T, P > saturate (const tvec3< T, P > &x)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tvec4< T, P > saturate (const tvec4< T, P > &x)
 

Detailed Description

Provide functions to increase the compatibility with Cg and HLSL languages.

<glm/gtx/compatibility.hpp> need to be included to use these functionalities.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00192.html000066400000000000000000000164471356361734700216620ustar00rootroot00000000000000 0.9.7: GLM_GTX_component_wise
Functions
GLM_GTX_component_wise
GTX Extensions (Experimental)

Functions

template<typename genType >
GLM_FUNC_DECL genType::value_type compAdd (genType const &v)
 
template<typename genType >
GLM_FUNC_DECL genType::value_type compMax (genType const &v)
 
template<typename genType >
GLM_FUNC_DECL genType::value_type compMin (genType const &v)
 
template<typename genType >
GLM_FUNC_DECL genType::value_type compMul (genType const &v)
 

Detailed Description

Operations between components of a type.

<glm/gtx/component_wise.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL genType::value_type glm::compAdd ( genType const &  v)

Add all vector components together.

See also
GLM_GTX_component_wise
GLM_FUNC_DECL genType::value_type glm::compMax ( genType const &  v)

Find the maximum value between single vector components.

See also
GLM_GTX_component_wise
GLM_FUNC_DECL genType::value_type glm::compMin ( genType const &  v)

Find the minimum value between single vector components.

See also
GLM_GTX_component_wise
GLM_FUNC_DECL genType::value_type glm::compMul ( genType const &  v)

Multiply all vector components together.

See also
GLM_GTX_component_wise
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00193.html000066400000000000000000000632331356361734700216560ustar00rootroot00000000000000 0.9.7: GLM_GTX_dual_quaternion
Typedefs | Functions
GLM_GTX_dual_quaternion
GTX Extensions (Experimental)

Typedefs

typedef highp_ddualquat ddualquat
 
typedef highp_fdualquat dualquat
 
typedef highp_fdualquat fdualquat
 
typedef tdualquat< double, highp > highp_ddualquat
 
typedef tdualquat< float, highp > highp_dualquat
 
typedef tdualquat< float, highp > highp_fdualquat
 
typedef tdualquat< double, lowp > lowp_ddualquat
 
typedef tdualquat< float, lowp > lowp_dualquat
 
typedef tdualquat< float, lowp > lowp_fdualquat
 
typedef tdualquat< double, mediump > mediump_ddualquat
 
typedef tdualquat< float, mediump > mediump_dualquat
 
typedef tdualquat< float, mediump > mediump_fdualquat
 

Functions

template<typename T , precision P>
GLM_FUNC_DECL tdualquat< T, P > dualquat_cast (tmat2x4< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tdualquat< T, P > dualquat_cast (tmat3x4< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tdualquat< T, P > inverse (tdualquat< T, P > const &q)
 
template<typename T , precision P>
GLM_FUNC_DECL tdualquat< T, P > lerp (tdualquat< T, P > const &x, tdualquat< T, P > const &y, T const &a)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat2x4< T, P > mat2x4_cast (tdualquat< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x4< T, P > mat3x4_cast (tdualquat< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tdualquat< T, P > normalize (tdualquat< T, P > const &q)
 

Detailed Description

Defines a templated dual-quaternion type and several dual-quaternion operations.

<glm/gtx/dual_quaternion.hpp> need to be included to use these functionalities.

Typedef Documentation

typedef highp_ddualquat ddualquat

Dual-quaternion of default double-precision floating-point numbers.

See also
GLM_GTX_dual_quaternion

Definition at line 283 of file dual_quaternion.hpp.

typedef highp_fdualquat dualquat

Dual-quaternion of floating-point numbers.

See also
GLM_GTX_dual_quaternion

Definition at line 259 of file dual_quaternion.hpp.

typedef highp_fdualquat fdualquat

Dual-quaternion of single-precision floating-point numbers.

See also
GLM_GTX_dual_quaternion

Definition at line 264 of file dual_quaternion.hpp.

typedef tdualquat<double, highp> highp_ddualquat

Dual-quaternion of high double-precision floating-point numbers.

See also
GLM_GTX_dual_quaternion

Definition at line 252 of file dual_quaternion.hpp.

typedef tdualquat<float, highp> highp_dualquat

Dual-quaternion of high single-precision floating-point numbers.

See also
GLM_GTX_dual_quaternion

Definition at line 220 of file dual_quaternion.hpp.

typedef tdualquat<float, highp> highp_fdualquat

Dual-quaternion of high single-precision floating-point numbers.

See also
GLM_GTX_dual_quaternion

Definition at line 236 of file dual_quaternion.hpp.

typedef tdualquat<double, lowp> lowp_ddualquat

Dual-quaternion of low double-precision floating-point numbers.

See also
GLM_GTX_dual_quaternion

Definition at line 242 of file dual_quaternion.hpp.

typedef tdualquat<float, lowp> lowp_dualquat

Dual-quaternion of low single-precision floating-point numbers.

See also
GLM_GTX_dual_quaternion

Definition at line 210 of file dual_quaternion.hpp.

typedef tdualquat<float, lowp> lowp_fdualquat

Dual-quaternion of low single-precision floating-point numbers.

See also
GLM_GTX_dual_quaternion

Definition at line 226 of file dual_quaternion.hpp.

typedef tdualquat<double, mediump> mediump_ddualquat

Dual-quaternion of medium double-precision floating-point numbers.

See also
GLM_GTX_dual_quaternion

Definition at line 247 of file dual_quaternion.hpp.

typedef tdualquat<float, mediump> mediump_dualquat

Dual-quaternion of medium single-precision floating-point numbers.

See also
GLM_GTX_dual_quaternion

Definition at line 215 of file dual_quaternion.hpp.

typedef tdualquat<float, mediump> mediump_fdualquat

Dual-quaternion of medium single-precision floating-point numbers.

See also
GLM_GTX_dual_quaternion

Definition at line 231 of file dual_quaternion.hpp.

Function Documentation

GLM_FUNC_DECL tdualquat<T, P> glm::dualquat_cast ( tmat2x4< T, P > const &  x)

Converts a 2 * 4 matrix (matrix which holds real and dual parts) to a quaternion.

See also
GLM_GTX_dual_quaternion
GLM_FUNC_DECL tdualquat<T, P> glm::dualquat_cast ( tmat3x4< T, P > const &  x)

Converts a 3 * 4 matrix (augmented matrix rotation + translation) to a quaternion.

See also
GLM_GTX_dual_quaternion
GLM_FUNC_DECL tdualquat<T, P> glm::inverse ( tdualquat< T, P > const &  q)

Returns the q inverse.

See also
GLM_GTX_dual_quaternion
GLM_FUNC_DECL tdualquat<T, P> glm::lerp ( tdualquat< T, P > const &  x,
tdualquat< T, P > const &  y,
T const &  a 
)

Returns the linear interpolation of two dual quaternion.

See also
gtc_dual_quaternion
GLM_FUNC_DECL tmat2x4<T, P> glm::mat2x4_cast ( tdualquat< T, P > const &  x)

Converts a quaternion to a 2 * 4 matrix.

See also
GLM_GTX_dual_quaternion
GLM_FUNC_DECL tmat3x4<T, P> glm::mat3x4_cast ( tdualquat< T, P > const &  x)

Converts a quaternion to a 3 * 4 matrix.

See also
GLM_GTX_dual_quaternion
GLM_FUNC_DECL tdualquat<T, P> glm::normalize ( tdualquat< T, P > const &  q)

Returns the normalized quaternion.

See also
GLM_GTX_dual_quaternion
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00194.html000066400000000000000000000671151356361734700216620ustar00rootroot00000000000000 0.9.7: GLM_GTX_euler_angles
Functions
GLM_GTX_euler_angles
GTX Extensions (Experimental)

Functions

template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleX (T const &angleX)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleXY (T const &angleX, T const &angleY)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleXYZ (T const &t1, T const &t2, T const &t3)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleXZ (T const &angleX, T const &angleZ)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleY (T const &angleY)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleYX (T const &angleY, T const &angleX)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleYXZ (T const &yaw, T const &pitch, T const &roll)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleYZ (T const &angleY, T const &angleZ)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleZ (T const &angleZ)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleZX (T const &angle, T const &angleX)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > eulerAngleZY (T const &angleZ, T const &angleY)
 
template<typename T >
GLM_FUNC_DECL void extractEulerAngleXYZ (tmat4x4< T, defaultp > &M, T &t1, T &t2, T &t3)
 
template<typename T >
GLM_FUNC_DECL tmat2x2< T, defaultp > orientate2 (T const &angle)
 
template<typename T >
GLM_FUNC_DECL tmat3x3< T, defaultp > orientate3 (T const &angle)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > orientate3 (tvec3< T, P > const &angles)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > orientate4 (tvec3< T, P > const &angles)
 
template<typename T >
GLM_FUNC_DECL tmat4x4< T, defaultp > yawPitchRoll (T const &yaw, T const &pitch, T const &roll)
 

Detailed Description

Build matrices from Euler angles.

<glm/gtx/euler_angles.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL tmat4x4<T, defaultp> glm::eulerAngleX ( T const &  angleX)

Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X.

See also
GLM_GTX_euler_angles
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::eulerAngleXY ( T const &  angleX,
T const &  angleY 
)

Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y).

See also
GLM_GTX_euler_angles
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::eulerAngleXYZ ( T const &  t1,
T const &  t2,
T const &  t3 
)

Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y * Z).

See also
GLM_GTX_euler_angles
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::eulerAngleXZ ( T const &  angleX,
T const &  angleZ 
)

Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z).

See also
GLM_GTX_euler_angles
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::eulerAngleY ( T const &  angleY)

Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Y.

See also
GLM_GTX_euler_angles
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::eulerAngleYX ( T const &  angleY,
T const &  angleX 
)

Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X).

See also
GLM_GTX_euler_angles
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::eulerAngleYXZ ( T const &  yaw,
T const &  pitch,
T const &  roll 
)

Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).

See also
GLM_GTX_euler_angles
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::eulerAngleYZ ( T const &  angleY,
T const &  angleZ 
)

Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z).

See also
GLM_GTX_euler_angles
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::eulerAngleZ ( T const &  angleZ)

Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Z.

See also
GLM_GTX_euler_angles
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::eulerAngleZX ( T const &  angle,
T const &  angleX 
)

Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X).

See also
GLM_GTX_euler_angles
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::eulerAngleZY ( T const &  angleZ,
T const &  angleY 
)

Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y).

See also
GLM_GTX_euler_angles
GLM_FUNC_DECL void glm::extractEulerAngleXYZ ( tmat4x4< T, defaultp > &  M,
T &  t1,
T &  t2,
T &  t3 
)

Extracts the (X * Y * Z) Euler angles from the rotation matrix M.

See also
GLM_GTX_euler_angles
GLM_FUNC_DECL tmat2x2<T, defaultp> glm::orientate2 ( T const &  angle)

Creates a 2D 2 * 2 rotation matrix from an euler angle.

See also
GLM_GTX_euler_angles
GLM_FUNC_DECL tmat3x3<T, defaultp> glm::orientate3 ( T const &  angle)

Creates a 2D 4 * 4 homogeneous rotation matrix from an euler angle.

See also
GLM_GTX_euler_angles
GLM_FUNC_DECL tmat3x3<T, P> glm::orientate3 ( tvec3< T, P > const &  angles)

Creates a 3D 3 * 3 rotation matrix from euler angles (Y * X * Z).

See also
GLM_GTX_euler_angles
GLM_FUNC_DECL tmat4x4<T, P> glm::orientate4 ( tvec3< T, P > const &  angles)

Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).

See also
GLM_GTX_euler_angles
GLM_FUNC_DECL tmat4x4<T, defaultp> glm::yawPitchRoll ( T const &  yaw,
T const &  pitch,
T const &  roll 
)

Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).

See also
GLM_GTX_euler_angles
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00195.html000066400000000000000000000103111356361734700216450ustar00rootroot00000000000000 0.9.7: GLM_GTX_extend
Functions
GLM_GTX_extend
GTX Extensions (Experimental)

Functions

template<typename genType >
GLM_FUNC_DECL genType extend (genType const &Origin, genType const &Source, typename genType::value_type const Length)
 

Detailed Description

Extend a position from a source to a position at a defined length.

<glm/gtx/extend.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL genType glm::extend ( genType const &  Origin,
genType const &  Source,
typename genType::value_type const  Length 
)

Extends of Length the Origin position using the (Source - Origin) direction.

See also
GLM_GTX_extend
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00196.html000066400000000000000000000613201356361734700216540ustar00rootroot00000000000000 0.9.7: GLM_GTX_extented_min_max
Functions
GLM_GTX_extented_min_max
GTX Extensions (Experimental)

Functions

template<typename T >
GLM_FUNC_DECL T max (T const &x, T const &y, T const &z)
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > max (C< T > const &x, typename C< T >::T const &y, typename C< T >::T const &z)
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > max (C< T > const &x, C< T > const &y, C< T > const &z)
 
template<typename T >
GLM_FUNC_DECL T max (T const &x, T const &y, T const &z, T const &w)
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > max (C< T > const &x, typename C< T >::T const &y, typename C< T >::T const &z, typename C< T >::T const &w)
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > max (C< T > const &x, C< T > const &y, C< T > const &z, C< T > const &w)
 
template<typename T >
GLM_FUNC_DECL T min (T const &x, T const &y, T const &z)
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > min (C< T > const &x, typename C< T >::T const &y, typename C< T >::T const &z)
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > min (C< T > const &x, C< T > const &y, C< T > const &z)
 
template<typename T >
GLM_FUNC_DECL T min (T const &x, T const &y, T const &z, T const &w)
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > min (C< T > const &x, typename C< T >::T const &y, typename C< T >::T const &z, typename C< T >::T const &w)
 
template<typename T , template< typename > class C>
GLM_FUNC_DECL C< T > min (C< T > const &x, C< T > const &y, C< T > const &z, C< T > const &w)
 

Detailed Description

Min and max functions for 3 to 4 parameters.

<glm/gtx/extented_min_max.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL T glm::max ( T const &  x,
T const &  y,
T const &  z 
)

Return the maximum component-wise values of 3 inputs.

See also
GLM_GTX_extented_min_max
GLM_FUNC_DECL C<T> glm::max ( C< T > const &  x,
typename C< T >::T const &  y,
typename C< T >::T const &  z 
)

Return the maximum component-wise values of 3 inputs.

See also
GLM_GTX_extented_min_max
GLM_FUNC_DECL C<T> glm::max ( C< T > const &  x,
C< T > const &  y,
C< T > const &  z 
)

Return the maximum component-wise values of 3 inputs.

See also
GLM_GTX_extented_min_max
GLM_FUNC_DECL T glm::max ( T const &  x,
T const &  y,
T const &  z,
T const &  w 
)

Return the maximum component-wise values of 4 inputs.

See also
GLM_GTX_extented_min_max
GLM_FUNC_DECL C<T> glm::max ( C< T > const &  x,
typename C< T >::T const &  y,
typename C< T >::T const &  z,
typename C< T >::T const &  w 
)

Return the maximum component-wise values of 4 inputs.

See also
GLM_GTX_extented_min_max
GLM_FUNC_DECL C<T> glm::max ( C< T > const &  x,
C< T > const &  y,
C< T > const &  z,
C< T > const &  w 
)

Return the maximum component-wise values of 4 inputs.

See also
GLM_GTX_extented_min_max
GLM_FUNC_DECL T glm::min ( T const &  x,
T const &  y,
T const &  z 
)

Return the minimum component-wise values of 3 inputs.

See also
GLM_GTX_extented_min_max
GLM_FUNC_DECL C<T> glm::min ( C< T > const &  x,
typename C< T >::T const &  y,
typename C< T >::T const &  z 
)

Return the minimum component-wise values of 3 inputs.

See also
GLM_GTX_extented_min_max
GLM_FUNC_DECL C<T> glm::min ( C< T > const &  x,
C< T > const &  y,
C< T > const &  z 
)

Return the minimum component-wise values of 3 inputs.

See also
GLM_GTX_extented_min_max
GLM_FUNC_DECL T glm::min ( T const &  x,
T const &  y,
T const &  z,
T const &  w 
)

Return the minimum component-wise values of 4 inputs.

See also
GLM_GTX_extented_min_max
GLM_FUNC_DECL C<T> glm::min ( C< T > const &  x,
typename C< T >::T const &  y,
typename C< T >::T const &  z,
typename C< T >::T const &  w 
)

Return the minimum component-wise values of 4 inputs.

See also
GLM_GTX_extented_min_max
GLM_FUNC_DECL C<T> glm::min ( C< T > const &  x,
C< T > const &  y,
C< T > const &  z,
C< T > const &  w 
)

Return the minimum component-wise values of 4 inputs.

See also
GLM_GTX_extented_min_max
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00197.html000066400000000000000000000451341356361734700216620ustar00rootroot00000000000000 0.9.7: GLM_GTX_fast_exponential
Functions
GLM_GTX_fast_exponential
GTX Extensions (Experimental)

Functions

template<typename T >
GLM_FUNC_DECL T fastExp (T x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > fastExp (vecType< T, P > const &x)
 
template<typename T >
GLM_FUNC_DECL T fastExp2 (T x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > fastExp2 (vecType< T, P > const &x)
 
template<typename T >
GLM_FUNC_DECL T fastLog (T x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > fastLog (vecType< T, P > const &x)
 
template<typename T >
GLM_FUNC_DECL T fastLog2 (T x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > fastLog2 (vecType< T, P > const &x)
 
template<typename genType >
GLM_FUNC_DECL genType fastPow (genType x, genType y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > fastPow (vecType< T, P > const &x, vecType< T, P > const &y)
 
template<typename genTypeT , typename genTypeU >
GLM_FUNC_DECL genTypeT fastPow (genTypeT x, genTypeU y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > fastPow (vecType< T, P > const &x)
 

Detailed Description

Fast but less accurate implementations of exponential based functions.

<glm/gtx/fast_exponential.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL T glm::fastExp ( T  x)

Faster than the common exp function but less accurate.

See also
GLM_GTX_fast_exponential
GLM_FUNC_DECL vecType<T, P> glm::fastExp ( vecType< T, P > const &  x)

Faster than the common exp function but less accurate.

See also
GLM_GTX_fast_exponential
GLM_FUNC_DECL T glm::fastExp2 ( T  x)

Faster than the common exp2 function but less accurate.

See also
GLM_GTX_fast_exponential
GLM_FUNC_DECL vecType<T, P> glm::fastExp2 ( vecType< T, P > const &  x)

Faster than the common exp2 function but less accurate.

See also
GLM_GTX_fast_exponential
GLM_FUNC_DECL T glm::fastLog ( T  x)

Faster than the common log function but less accurate.

See also
GLM_GTX_fast_exponential
GLM_FUNC_DECL vecType<T, P> glm::fastLog ( vecType< T, P > const &  x)

Faster than the common exp2 function but less accurate.

See also
GLM_GTX_fast_exponential
GLM_FUNC_DECL T glm::fastLog2 ( T  x)

Faster than the common log2 function but less accurate.

See also
GLM_GTX_fast_exponential
GLM_FUNC_DECL vecType<T, P> glm::fastLog2 ( vecType< T, P > const &  x)

Faster than the common log2 function but less accurate.

See also
GLM_GTX_fast_exponential
GLM_FUNC_DECL genType glm::fastPow ( genType  x,
genType  y 
)

Faster than the common pow function but less accurate.

See also
GLM_GTX_fast_exponential
GLM_FUNC_DECL vecType<T, P> glm::fastPow ( vecType< T, P > const &  x,
vecType< T, P > const &  y 
)

Faster than the common pow function but less accurate.

See also
GLM_GTX_fast_exponential
GLM_FUNC_DECL genTypeT glm::fastPow ( genTypeT  x,
genTypeU  y 
)

Faster than the common pow function but less accurate.

See also
GLM_GTX_fast_exponential
GLM_FUNC_DECL vecType<T, P> glm::fastPow ( vecType< T, P > const &  x)

Faster than the common pow function but less accurate.

See also
GLM_GTX_fast_exponential
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00198.html000066400000000000000000000354241356361734700216640ustar00rootroot00000000000000 0.9.7: GLM_GTX_fast_square_root
Functions
GLM_GTX_fast_square_root
GTX Extensions (Experimental)

Functions

template<typename genType >
GLM_FUNC_DECL genType fastDistance (genType x, genType y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL T fastDistance (vecType< T, P > const &x, vecType< T, P > const &y)
 
template<typename genType >
GLM_FUNC_DECL genType fastInverseSqrt (genType x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > fastInverseSqrt (vecType< T, P > const &x)
 
template<typename genType >
GLM_FUNC_DECL genType fastLength (genType x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL T fastLength (vecType< T, P > const &x)
 
template<typename genType >
GLM_FUNC_DECL genType fastNormalize (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL genType fastSqrt (genType x)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > fastSqrt (vecType< T, P > const &x)
 

Detailed Description

Fast but less accurate implementations of square root based functions.

  • Sqrt optimisation based on Newton's method, www.gamedev.net/community/forums/topic.asp?topic id=139956

<glm/gtx/fast_square_root.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL genType glm::fastDistance ( genType  x,
genType  y 
)

Faster than the common distance function but less accurate.

See also
GLM_GTX_fast_square_root extension.
GLM_FUNC_DECL T glm::fastDistance ( vecType< T, P > const &  x,
vecType< T, P > const &  y 
)

Faster than the common distance function but less accurate.

See also
GLM_GTX_fast_square_root extension.
GLM_FUNC_DECL genType glm::fastInverseSqrt ( genType  x)

Faster than the common inversesqrt function but less accurate.

See also
GLM_GTX_fast_square_root extension.
GLM_FUNC_DECL vecType<T, P> glm::fastInverseSqrt ( vecType< T, P > const &  x)

Faster than the common inversesqrt function but less accurate.

See also
GLM_GTX_fast_square_root extension.
GLM_FUNC_DECL genType glm::fastLength ( genType  x)

Faster than the common length function but less accurate.

See also
GLM_GTX_fast_square_root extension.
GLM_FUNC_DECL T glm::fastLength ( vecType< T, P > const &  x)

Faster than the common length function but less accurate.

See also
GLM_GTX_fast_square_root extension.
GLM_FUNC_DECL genType glm::fastNormalize ( genType const &  x)

Faster than the common normalize function but less accurate.

See also
GLM_GTX_fast_square_root extension.
GLM_FUNC_DECL genType glm::fastSqrt ( genType  x)

Faster than the common sqrt function but less accurate.

See also
GLM_GTX_fast_square_root extension.
GLM_FUNC_DECL vecType<T, P> glm::fastSqrt ( vecType< T, P > const &  x)

Faster than the common sqrt function but less accurate.

See also
GLM_GTX_fast_square_root extension.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00199.html000066400000000000000000000263141356361734700216630ustar00rootroot00000000000000 0.9.7: GLM_GTX_fast_trigonometry
Functions
GLM_GTX_fast_trigonometry
GTX Extensions (Experimental)

Functions

template<typename T >
GLM_FUNC_DECL T fastAcos (T angle)
 
template<typename T >
GLM_FUNC_DECL T fastAsin (T angle)
 
template<typename T >
GLM_FUNC_DECL T fastAtan (T y, T x)
 
template<typename T >
GLM_FUNC_DECL T fastAtan (T angle)
 
template<typename T >
GLM_FUNC_DECL T fastCos (T angle)
 
template<typename T >
GLM_FUNC_DECL T fastSin (T angle)
 
template<typename T >
GLM_FUNC_DECL T fastTan (T angle)
 
template<typename T >
GLM_FUNC_DECL T wrapAngle (T angle)
 

Detailed Description

Fast but less accurate implementations of trigonometric functions.

<glm/gtx/fast_trigonometry.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL T glm::fastAcos ( T  angle)

Faster than the common acos function but less accurate.

Defined between -2pi and 2pi. From GLM_GTX_fast_trigonometry extension.

GLM_FUNC_DECL T glm::fastAsin ( T  angle)

Faster than the common asin function but less accurate.

Defined between -2pi and 2pi. From GLM_GTX_fast_trigonometry extension.

GLM_FUNC_DECL T glm::fastAtan ( T  y,
T  x 
)

Faster than the common atan function but less accurate.

Defined between -2pi and 2pi. From GLM_GTX_fast_trigonometry extension.

GLM_FUNC_DECL T glm::fastAtan ( T  angle)

Faster than the common atan function but less accurate.

Defined between -2pi and 2pi. From GLM_GTX_fast_trigonometry extension.

GLM_FUNC_DECL T glm::fastCos ( T  angle)

Faster than the common cos function but less accurate.

From GLM_GTX_fast_trigonometry extension.

GLM_FUNC_DECL T glm::fastSin ( T  angle)

Faster than the common sin function but less accurate.

From GLM_GTX_fast_trigonometry extension.

GLM_FUNC_DECL T glm::fastTan ( T  angle)

Faster than the common tan function but less accurate.

Defined between -2pi and 2pi. From GLM_GTX_fast_trigonometry extension.

GLM_FUNC_DECL T glm::wrapAngle ( T  angle)

Wrap an angle to [0 2pi[ From GLM_GTX_fast_trigonometry extension.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00200.html000066400000000000000000000145211356361734700216370ustar00rootroot00000000000000 0.9.7: GLM_GTX_gradient_paint
Functions
GLM_GTX_gradient_paint
GTX Extensions (Experimental)

Functions

template<typename T , precision P>
GLM_FUNC_DECL T linearGradient (tvec2< T, P > const &Point0, tvec2< T, P > const &Point1, tvec2< T, P > const &Position)
 
template<typename T , precision P>
GLM_FUNC_DECL T radialGradient (tvec2< T, P > const &Center, T const &Radius, tvec2< T, P > const &Focal, tvec2< T, P > const &Position)
 

Detailed Description

Functions that return the color of procedural gradient for specific coordinates.

<glm/gtx/gradient_paint.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL T glm::linearGradient ( tvec2< T, P > const &  Point0,
tvec2< T, P > const &  Point1,
tvec2< T, P > const &  Position 
)

Return a color from a linear gradient.

See also
- GLM_GTX_gradient_paint
GLM_FUNC_DECL T glm::radialGradient ( tvec2< T, P > const &  Center,
T const &  Radius,
tvec2< T, P > const &  Focal,
tvec2< T, P > const &  Position 
)

Return a color from a radial gradient.

See also
- GLM_GTX_gradient_paint
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00201.html000066400000000000000000000134461356361734700216450ustar00rootroot00000000000000 0.9.7: GLM_GTX_handed_coordinate_space
Functions
GLM_GTX_handed_coordinate_space
GTX Extensions (Experimental)

Functions

template<typename T , precision P>
GLM_FUNC_DECL bool leftHanded (tvec3< T, P > const &tangent, tvec3< T, P > const &binormal, tvec3< T, P > const &normal)
 
template<typename T , precision P>
GLM_FUNC_DECL bool rightHanded (tvec3< T, P > const &tangent, tvec3< T, P > const &binormal, tvec3< T, P > const &normal)
 

Detailed Description

To know if a set of three basis vectors defines a right or left-handed coordinate system.

<glm/gtx/handed_coordinate_system.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL bool glm::leftHanded ( tvec3< T, P > const &  tangent,
tvec3< T, P > const &  binormal,
tvec3< T, P > const &  normal 
)

Return if a trihedron left handed or not.

From GLM_GTX_handed_coordinate_space extension.

GLM_FUNC_DECL bool glm::rightHanded ( tvec3< T, P > const &  tangent,
tvec3< T, P > const &  binormal,
tvec3< T, P > const &  normal 
)

Return if a trihedron right handed or not.

From GLM_GTX_handed_coordinate_space extension.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00202.html000066400000000000000000000040111356361734700216320ustar00rootroot00000000000000 0.9.7: GLM_GTX_hash
GLM_GTX_hash
GTX Extensions (Experimental)

Add std::hash support for glm types.

<glm/gtx/hash.hpp> need to be included to use these functionalities.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00203.html000066400000000000000000000322761356361734700216510ustar00rootroot00000000000000 0.9.7: GLM_GTX_integer
Typedefs | Functions
GLM_GTX_integer
GTX Extensions (Experimental)

Typedefs

typedef signed int sint
 

Functions

template<typename genType >
GLM_FUNC_DECL genType factorial (genType const &x)
 
GLM_FUNC_DECL unsigned int floor_log2 (unsigned int x)
 
GLM_FUNC_DECL int mod (int x, int y)
 
GLM_FUNC_DECL uint mod (uint x, uint y)
 
GLM_FUNC_DECL uint nlz (uint x)
 
GLM_FUNC_DECL int pow (int x, int y)
 
GLM_FUNC_DECL uint pow (uint x, uint y)
 
GLM_FUNC_DECL int sqrt (int x)
 
GLM_FUNC_DECL uint sqrt (uint x)
 

Detailed Description

Add support for integer for core functions.

<glm/gtx/integer.hpp> need to be included to use these functionalities.

Typedef Documentation

typedef signed int sint

32bit signed integer.

From GLM_GTX_integer extension.

Definition at line 80 of file gtx/integer.hpp.

Function Documentation

GLM_FUNC_DECL genType glm::factorial ( genType const &  x)

Return the factorial value of a number (!12 max, integer only) From GLM_GTX_integer extension.

GLM_FUNC_DECL unsigned int glm::floor_log2 ( unsigned int  x)

Returns the floor log2 of x.

From GLM_GTX_integer extension.

GLM_FUNC_DECL int glm::mod ( int  x,
int  y 
)

Modulus.

Returns x - y * floor(x / y) for each component in x using the floating point value y. From GLM_GTX_integer extension.

GLM_FUNC_DECL uint glm::mod ( uint  x,
uint  y 
)

Modulus.

Returns x - y * floor(x / y) for each component in x using the floating point value y. From GLM_GTX_integer extension.

GLM_FUNC_DECL uint glm::nlz ( uint  x)

Returns the number of leading zeros.

From GLM_GTX_integer extension.

GLM_FUNC_DECL int glm::pow ( int  x,
int  y 
)

Returns x raised to the y power.

From GLM_GTX_integer extension.

GLM_FUNC_DECL uint glm::pow ( uint  x,
uint  y 
)

Returns x raised to the y power.

From GLM_GTX_integer extension.

GLM_FUNC_DECL int glm::sqrt ( int  x)

Returns the positive square root of x.

From GLM_GTX_integer extension.

GLM_FUNC_DECL uint glm::sqrt ( uint  x)

Returns the positive square root of x.

From GLM_GTX_integer extension.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00204.html000066400000000000000000000413531356361734700216460ustar00rootroot00000000000000 0.9.7: GLM_GTX_intersect
Functions
GLM_GTX_intersect
GTX Extensions (Experimental)

Functions

template<typename genType >
GLM_FUNC_DECL bool intersectLineSphere (genType const &point0, genType const &point1, genType const &sphereCenter, typename genType::value_type sphereRadius, genType &intersectionPosition1, genType &intersectionNormal1, genType &intersectionPosition2=genType(), genType &intersectionNormal2=genType())
 
template<typename genType >
GLM_FUNC_DECL bool intersectLineTriangle (genType const &orig, genType const &dir, genType const &vert0, genType const &vert1, genType const &vert2, genType &position)
 
template<typename genType >
GLM_FUNC_DECL bool intersectRayPlane (genType const &orig, genType const &dir, genType const &planeOrig, genType const &planeNormal, typename genType::value_type &intersectionDistance)
 
template<typename genType >
GLM_FUNC_DECL bool intersectRaySphere (genType const &rayStarting, genType const &rayNormalizedDirection, genType const &sphereCenter, typename genType::value_type const sphereRadiusSquered, typename genType::value_type &intersectionDistance)
 
template<typename genType >
GLM_FUNC_DECL bool intersectRaySphere (genType const &rayStarting, genType const &rayNormalizedDirection, genType const &sphereCenter, const typename genType::value_type sphereRadius, genType &intersectionPosition, genType &intersectionNormal)
 
template<typename genType >
GLM_FUNC_DECL bool intersectRayTriangle (genType const &orig, genType const &dir, genType const &vert0, genType const &vert1, genType const &vert2, genType &baryPosition)
 

Detailed Description

Add intersection functions.

<glm/gtx/intersect.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL bool glm::intersectLineSphere ( genType const &  point0,
genType const &  point1,
genType const &  sphereCenter,
typename genType::value_type  sphereRadius,
genType &  intersectionPosition1,
genType &  intersectionNormal1,
genType &  intersectionPosition2 = genType(),
genType &  intersectionNormal2 = genType() 
)

Compute the intersection of a line and a sphere.

From GLM_GTX_intersect extension

GLM_FUNC_DECL bool glm::intersectLineTriangle ( genType const &  orig,
genType const &  dir,
genType const &  vert0,
genType const &  vert1,
genType const &  vert2,
genType &  position 
)

Compute the intersection of a line and a triangle.

From GLM_GTX_intersect extension.

GLM_FUNC_DECL bool glm::intersectRayPlane ( genType const &  orig,
genType const &  dir,
genType const &  planeOrig,
genType const &  planeNormal,
typename genType::value_type &  intersectionDistance 
)

Compute the intersection of a ray and a plane.

Ray direction and plane normal must be unit length. From GLM_GTX_intersect extension.

GLM_FUNC_DECL bool glm::intersectRaySphere ( genType const &  rayStarting,
genType const &  rayNormalizedDirection,
genType const &  sphereCenter,
typename genType::value_type const  sphereRadiusSquered,
typename genType::value_type &  intersectionDistance 
)

Compute the intersection distance of a ray and a sphere.

The ray direction vector is unit length. From GLM_GTX_intersect extension.

GLM_FUNC_DECL bool glm::intersectRaySphere ( genType const &  rayStarting,
genType const &  rayNormalizedDirection,
genType const &  sphereCenter,
const typename genType::value_type  sphereRadius,
genType &  intersectionPosition,
genType &  intersectionNormal 
)

Compute the intersection of a ray and a sphere.

From GLM_GTX_intersect extension.

GLM_FUNC_DECL bool glm::intersectRayTriangle ( genType const &  orig,
genType const &  dir,
genType const &  vert0,
genType const &  vert1,
genType const &  vert2,
genType &  baryPosition 
)

Compute the intersection of a ray and a triangle.

From GLM_GTX_intersect extension.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00205.html000066400000000000000000000045531356361734700216500ustar00rootroot00000000000000 0.9.7: GLM_GTX_io
GLM_GTX_io
GTX Extensions (Experimental)

Detailed Description

std::[w]ostream support for glm types

std::[w]ostream support for glm types + precision/width/etc. manipulators based on howard hinnant's std::chrono io proposal [http://home.roadrunner.com/~hinnant/bloomington/chrono_io.html]

<glm/gtx/io.hpp> needs to be included to use these functionalities.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00206.html000066400000000000000000000122321356361734700216420ustar00rootroot00000000000000 0.9.7: GLM_GTX_log_base
Functions
GLM_GTX_log_base
GTX Extensions (Experimental)

Functions

template<typename genType >
GLM_FUNC_DECL genType log (genType x, genType base)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< T, P > sign (vecType< T, P > const &x, vecType< T, P > const &base)
 

Detailed Description

Logarithm for any base.

base can be a vector or a scalar.

<glm/gtx/log_base.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL genType glm::log ( genType  x,
genType  base 
)

Logarithm for any base.

From GLM_GTX_log_base.

GLM_FUNC_DECL vecType<T, P> glm::sign ( vecType< T, P > const &  x,
vecType< T, P > const &  base 
)

Logarithm for any base.

From GLM_GTX_log_base.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00207.html000066400000000000000000000112631356361734700216460ustar00rootroot00000000000000 0.9.7: GLM_GTX_matrix_cross_product
Functions
GLM_GTX_matrix_cross_product
GTX Extensions (Experimental)

Functions

template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > matrixCross3 (tvec3< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > matrixCross4 (tvec3< T, P > const &x)
 

Detailed Description

Build cross product matrices.

<glm/gtx/matrix_cross_product.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL tmat3x3<T, P> glm::matrixCross3 ( tvec3< T, P > const &  x)

Build a cross product matrix.

From GLM_GTX_matrix_cross_product extension.

GLM_FUNC_DECL tmat4x4<T, P> glm::matrixCross4 ( tvec3< T, P > const &  x)

Build a cross product matrix.

From GLM_GTX_matrix_cross_product extension.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00208.html000066400000000000000000000116701356361734700216510ustar00rootroot00000000000000 0.9.7: GLM_GTX_matrix_decompose
Functions
GLM_GTX_matrix_decompose
GTX Extensions (Experimental)

Functions

template<typename T , precision P>
GLM_FUNC_DECL bool decompose (tmat4x4< T, P > const &modelMatrix, tvec3< T, P > &scale, tquat< T, P > &orientation, tvec3< T, P > &translation, tvec3< T, P > &skew, tvec4< T, P > &perspective)
 

Detailed Description

Decomposes a model matrix to translations, rotation and scale components.

<glm/gtx/decomposition.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL bool glm::decompose ( tmat4x4< T, P > const &  modelMatrix,
tvec3< T, P > &  scale,
tquat< T, P > &  orientation,
tvec3< T, P > &  translation,
tvec3< T, P > &  skew,
tvec4< T, P > &  perspective 
)

Decomposes a model matrix to translations, rotation and scale components.

See also
GLM_GTX_matrix_decompose
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00209.html000066400000000000000000000206621356361734700216530ustar00rootroot00000000000000 0.9.7: GLM_GTX_matrix_interpolation
Functions
GLM_GTX_matrix_interpolation
GTX Extensions (Experimental)

Functions

template<typename T , precision P>
GLM_FUNC_DECL void axisAngle (tmat4x4< T, P > const &mat, tvec3< T, P > &axis, T &angle)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > axisAngleMatrix (tvec3< T, P > const &axis, T const angle)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > extractMatrixRotation (tmat4x4< T, P > const &mat)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > interpolate (tmat4x4< T, P > const &m1, tmat4x4< T, P > const &m2, T const delta)
 

Detailed Description

Allows to directly interpolate two exiciting matrices.

<glm/gtx/matrix_interpolation.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL void glm::axisAngle ( tmat4x4< T, P > const &  mat,
tvec3< T, P > &  axis,
T &  angle 
)

Get the axis and angle of the rotation from a matrix.

From GLM_GTX_matrix_interpolation extension.

GLM_FUNC_DECL tmat4x4<T, P> glm::axisAngleMatrix ( tvec3< T, P > const &  axis,
T const  angle 
)

Build a matrix from axis and angle.

From GLM_GTX_matrix_interpolation extension.

GLM_FUNC_DECL tmat4x4<T, P> glm::extractMatrixRotation ( tmat4x4< T, P > const &  mat)

Extracts the rotation part of a matrix.

From GLM_GTX_matrix_interpolation extension.

GLM_FUNC_DECL tmat4x4<T, P> glm::interpolate ( tmat4x4< T, P > const &  m1,
tmat4x4< T, P > const &  m2,
T const  delta 
)

Build a interpolation of 4 * 4 matrixes.

From GLM_GTX_matrix_interpolation extension. Warning! works only with rotation and/or translation matrixes, scale will generate unexpected results.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00210.html000066400000000000000000000470461356361734700216500ustar00rootroot00000000000000 0.9.7: GLM_GTX_matrix_major_storage
Functions
GLM_GTX_matrix_major_storage
GTX Extensions (Experimental)

Functions

template<typename T , precision P>
GLM_FUNC_DECL tmat2x2< T, P > colMajor2 (tvec2< T, P > const &v1, tvec2< T, P > const &v2)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat2x2< T, P > colMajor2 (tmat2x2< T, P > const &m)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > colMajor3 (tvec3< T, P > const &v1, tvec3< T, P > const &v2, tvec3< T, P > const &v3)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > colMajor3 (tmat3x3< T, P > const &m)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > colMajor4 (tvec4< T, P > const &v1, tvec4< T, P > const &v2, tvec4< T, P > const &v3, tvec4< T, P > const &v4)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > colMajor4 (tmat4x4< T, P > const &m)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat2x2< T, P > rowMajor2 (tvec2< T, P > const &v1, tvec2< T, P > const &v2)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat2x2< T, P > rowMajor2 (tmat2x2< T, P > const &m)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > rowMajor3 (tvec3< T, P > const &v1, tvec3< T, P > const &v2, tvec3< T, P > const &v3)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > rowMajor3 (tmat3x3< T, P > const &m)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > rowMajor4 (tvec4< T, P > const &v1, tvec4< T, P > const &v2, tvec4< T, P > const &v3, tvec4< T, P > const &v4)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > rowMajor4 (tmat4x4< T, P > const &m)
 

Detailed Description

Build matrices with specific matrix order, row or column.

<glm/gtx/matrix_major_storage.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL tmat2x2<T, P> glm::colMajor2 ( tvec2< T, P > const &  v1,
tvec2< T, P > const &  v2 
)

Build a column major matrix from column vectors.

From GLM_GTX_matrix_major_storage extension.

GLM_FUNC_DECL tmat2x2<T, P> glm::colMajor2 ( tmat2x2< T, P > const &  m)

Build a column major matrix from other matrix.

From GLM_GTX_matrix_major_storage extension.

GLM_FUNC_DECL tmat3x3<T, P> glm::colMajor3 ( tvec3< T, P > const &  v1,
tvec3< T, P > const &  v2,
tvec3< T, P > const &  v3 
)

Build a column major matrix from column vectors.

From GLM_GTX_matrix_major_storage extension.

GLM_FUNC_DECL tmat3x3<T, P> glm::colMajor3 ( tmat3x3< T, P > const &  m)

Build a column major matrix from other matrix.

From GLM_GTX_matrix_major_storage extension.

GLM_FUNC_DECL tmat4x4<T, P> glm::colMajor4 ( tvec4< T, P > const &  v1,
tvec4< T, P > const &  v2,
tvec4< T, P > const &  v3,
tvec4< T, P > const &  v4 
)

Build a column major matrix from column vectors.

From GLM_GTX_matrix_major_storage extension.

GLM_FUNC_DECL tmat4x4<T, P> glm::colMajor4 ( tmat4x4< T, P > const &  m)

Build a column major matrix from other matrix.

From GLM_GTX_matrix_major_storage extension.

GLM_FUNC_DECL tmat2x2<T, P> glm::rowMajor2 ( tvec2< T, P > const &  v1,
tvec2< T, P > const &  v2 
)

Build a row major matrix from row vectors.

From GLM_GTX_matrix_major_storage extension.

GLM_FUNC_DECL tmat2x2<T, P> glm::rowMajor2 ( tmat2x2< T, P > const &  m)

Build a row major matrix from other matrix.

From GLM_GTX_matrix_major_storage extension.

GLM_FUNC_DECL tmat3x3<T, P> glm::rowMajor3 ( tvec3< T, P > const &  v1,
tvec3< T, P > const &  v2,
tvec3< T, P > const &  v3 
)

Build a row major matrix from row vectors.

From GLM_GTX_matrix_major_storage extension.

GLM_FUNC_DECL tmat3x3<T, P> glm::rowMajor3 ( tmat3x3< T, P > const &  m)

Build a row major matrix from other matrix.

From GLM_GTX_matrix_major_storage extension.

GLM_FUNC_DECL tmat4x4<T, P> glm::rowMajor4 ( tvec4< T, P > const &  v1,
tvec4< T, P > const &  v2,
tvec4< T, P > const &  v3,
tvec4< T, P > const &  v4 
)

Build a row major matrix from row vectors.

From GLM_GTX_matrix_major_storage extension.

GLM_FUNC_DECL tmat4x4<T, P> glm::rowMajor4 ( tmat4x4< T, P > const &  m)

Build a row major matrix from other matrix.

From GLM_GTX_matrix_major_storage extension.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00211.html000066400000000000000000000310561356361734700216430ustar00rootroot00000000000000 0.9.7: GLM_GTX_matrix_operation
Functions
GLM_GTX_matrix_operation
GTX Extensions (Experimental)

Functions

template<typename T , precision P>
GLM_FUNC_DECL tmat2x2< T, P > diagonal2x2 (tvec2< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat2x3< T, P > diagonal2x3 (tvec2< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat2x4< T, P > diagonal2x4 (tvec2< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x2< T, P > diagonal3x2 (tvec2< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > diagonal3x3 (tvec3< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x4< T, P > diagonal3x4 (tvec3< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x2< T, P > diagonal4x2 (tvec2< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x3< T, P > diagonal4x3 (tvec3< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > diagonal4x4 (tvec4< T, P > const &v)
 

Detailed Description

Build diagonal matrices from vectors.

<glm/gtx/matrix_operation.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL tmat2x2<T, P> glm::diagonal2x2 ( tvec2< T, P > const &  v)

Build a diagonal matrix.

From GLM_GTX_matrix_operation extension.

GLM_FUNC_DECL tmat2x3<T, P> glm::diagonal2x3 ( tvec2< T, P > const &  v)

Build a diagonal matrix.

From GLM_GTX_matrix_operation extension.

GLM_FUNC_DECL tmat2x4<T, P> glm::diagonal2x4 ( tvec2< T, P > const &  v)

Build a diagonal matrix.

From GLM_GTX_matrix_operation extension.

GLM_FUNC_DECL tmat3x2<T, P> glm::diagonal3x2 ( tvec2< T, P > const &  v)

Build a diagonal matrix.

From GLM_GTX_matrix_operation extension.

GLM_FUNC_DECL tmat3x3<T, P> glm::diagonal3x3 ( tvec3< T, P > const &  v)

Build a diagonal matrix.

From GLM_GTX_matrix_operation extension.

GLM_FUNC_DECL tmat3x4<T, P> glm::diagonal3x4 ( tvec3< T, P > const &  v)

Build a diagonal matrix.

From GLM_GTX_matrix_operation extension.

GLM_FUNC_DECL tmat4x2<T, P> glm::diagonal4x2 ( tvec2< T, P > const &  v)

Build a diagonal matrix.

From GLM_GTX_matrix_operation extension.

GLM_FUNC_DECL tmat4x3<T, P> glm::diagonal4x3 ( tvec3< T, P > const &  v)

Build a diagonal matrix.

From GLM_GTX_matrix_operation extension.

GLM_FUNC_DECL tmat4x4<T, P> glm::diagonal4x4 ( tvec4< T, P > const &  v)

Build a diagonal matrix.

From GLM_GTX_matrix_operation extension.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00212.html000066400000000000000000000332651356361734700216500ustar00rootroot00000000000000 0.9.7: GLM_GTX_matrix_query
Functions
GLM_GTX_matrix_query
GTX Extensions (Experimental)

Functions

template<typename T , precision P, template< typename, precision > class matType>
GLM_FUNC_DECL bool isIdentity (matType< T, P > const &m, T const &epsilon)
 
template<typename T , precision P>
GLM_FUNC_DECL bool isNormalized (tmat2x2< T, P > const &m, T const &epsilon)
 
template<typename T , precision P>
GLM_FUNC_DECL bool isNormalized (tmat3x3< T, P > const &m, T const &epsilon)
 
template<typename T , precision P>
GLM_FUNC_DECL bool isNormalized (tmat4x4< T, P > const &m, T const &epsilon)
 
template<typename T , precision P>
GLM_FUNC_DECL bool isNull (tmat2x2< T, P > const &m, T const &epsilon)
 
template<typename T , precision P>
GLM_FUNC_DECL bool isNull (tmat3x3< T, P > const &m, T const &epsilon)
 
template<typename T , precision P>
GLM_FUNC_DECL bool isNull (tmat4x4< T, P > const &m, T const &epsilon)
 
template<typename T , precision P, template< typename, precision > class matType>
GLM_FUNC_DECL bool isOrthogonal (matType< T, P > const &m, T const &epsilon)
 

Detailed Description

Query to evaluate matrix properties.

<glm/gtx/matrix_query.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL bool glm::isIdentity ( matType< T, P > const &  m,
T const &  epsilon 
)

Return whether a matrix is an identity matrix.

From GLM_GTX_matrix_query extension.

GLM_FUNC_DECL bool glm::isNormalized ( tmat2x2< T, P > const &  m,
T const &  epsilon 
)

Return whether a matrix is a normalized matrix.

From GLM_GTX_matrix_query extension.

GLM_FUNC_DECL bool glm::isNormalized ( tmat3x3< T, P > const &  m,
T const &  epsilon 
)

Return whether a matrix is a normalized matrix.

From GLM_GTX_matrix_query extension.

GLM_FUNC_DECL bool glm::isNormalized ( tmat4x4< T, P > const &  m,
T const &  epsilon 
)

Return whether a matrix is a normalized matrix.

From GLM_GTX_matrix_query extension.

GLM_FUNC_DECL bool glm::isNull ( tmat2x2< T, P > const &  m,
T const &  epsilon 
)

Return whether a matrix a null matrix.

From GLM_GTX_matrix_query extension.

GLM_FUNC_DECL bool glm::isNull ( tmat3x3< T, P > const &  m,
T const &  epsilon 
)

Return whether a matrix a null matrix.

From GLM_GTX_matrix_query extension.

GLM_FUNC_DECL bool glm::isNull ( tmat4x4< T, P > const &  m,
T const &  epsilon 
)

Return whether a matrix is a null matrix.

From GLM_GTX_matrix_query extension.

GLM_FUNC_DECL bool glm::isOrthogonal ( matType< T, P > const &  m,
T const &  epsilon 
)

Return whether a matrix is an orthonormalized matrix.

From GLM_GTX_matrix_query extension.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00213.html000066400000000000000000000255051356361734700216470ustar00rootroot00000000000000 0.9.7: GLM_GTX_matrix_transform_2d
Functions
GLM_GTX_matrix_transform_2d
GTX Extensions (Experimental)

Functions

template<typename T , precision P>
GLM_FUNC_QUALIFIER tmat3x3< T, P > rotate (tmat3x3< T, P > const &m, T angle)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tmat3x3< T, P > scale (tmat3x3< T, P > const &m, tvec2< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tmat3x3< T, P > shearX (tmat3x3< T, P > const &m, T y)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tmat3x3< T, P > shearY (tmat3x3< T, P > const &m, T x)
 
template<typename T , precision P>
GLM_FUNC_QUALIFIER tmat3x3< T, P > translate (tmat3x3< T, P > const &m, tvec2< T, P > const &v)
 

Detailed Description

Defines functions that generate common 2d transformation matrices.

<glm/gtx/matrix_transform_2d.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_QUALIFIER tmat3x3<T, P> glm::rotate ( tmat3x3< T, P > const &  m,
T  angle 
)

Builds a rotation 3 * 3 matrix created from an angle.

Parameters
mInput matrix multiplied by this translation matrix.
angleRotation angle expressed in radians if GLM_FORCE_RADIANS is defined or degrees otherwise.
GLM_FUNC_QUALIFIER tmat3x3<T, P> glm::scale ( tmat3x3< T, P > const &  m,
tvec2< T, P > const &  v 
)

Builds a scale 3 * 3 matrix created from a vector of 2 components.

Parameters
mInput matrix multiplied by this translation matrix.
vCoordinates of a scale vector.
GLM_FUNC_QUALIFIER tmat3x3<T, P> glm::shearX ( tmat3x3< T, P > const &  m,
T  y 
)

Builds an horizontal (parallel to the x axis) shear 3 * 3 matrix.

Parameters
mInput matrix multiplied by this translation matrix.
yShear factor.
GLM_FUNC_QUALIFIER tmat3x3<T, P> glm::shearY ( tmat3x3< T, P > const &  m,
T  x 
)

Builds a vertical (parallel to the y axis) shear 3 * 3 matrix.

Parameters
mInput matrix multiplied by this translation matrix.
xShear factor.
GLM_FUNC_QUALIFIER tmat3x3<T, P> glm::translate ( tmat3x3< T, P > const &  m,
tvec2< T, P > const &  v 
)

Builds a translation 3 * 3 matrix created from a vector of 2 components.

Parameters
mInput matrix multiplied by this translation matrix.
vCoordinates of a translation vector.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00214.html000066400000000000000000000060161356361734700216440ustar00rootroot00000000000000 0.9.7: GLM_GTX_mixed_producte
Functions
GLM_GTX_mixed_producte
GTX Extensions (Experimental)

Functions

template<typename T , precision P>
GLM_FUNC_DECL T mixedProduct (tvec3< T, P > const &v1, tvec3< T, P > const &v2, tvec3< T, P > const &v3)
 

Detailed Description

Mixed product of 3 vectors.

<glm/gtx/mixed_product.hpp> need to be included to use these functionalities.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00215.html000066400000000000000000000361551356361734700216540ustar00rootroot00000000000000 0.9.7: GLM_GTX_norm
Functions
GLM_GTX_norm
GTX Extensions (Experimental)

Functions

template<typename T >
GLM_FUNC_DECL T distance2 (T const &p0, T const &p1)
 
template<typename genType >
GLM_FUNC_DECL genType::value_type distance2 (genType const &p0, genType const &p1)
 
template<typename T , precision P>
GLM_FUNC_DECL T l1Norm (tvec3< T, P > const &x, tvec3< T, P > const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL T l1Norm (tvec3< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL T l2Norm (tvec3< T, P > const &x, tvec3< T, P > const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL T l2Norm (tvec3< T, P > const &x)
 
template<typename T >
GLM_FUNC_DECL T length2 (T const &x)
 
template<typename genType >
GLM_FUNC_DECL genType::value_type length2 (genType const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL T lxNorm (tvec3< T, P > const &x, tvec3< T, P > const &y, unsigned int Depth)
 
template<typename T , precision P>
GLM_FUNC_DECL T lxNorm (tvec3< T, P > const &x, unsigned int Depth)
 

Detailed Description

Various ways to compute vector norms.

<glm/gtx/norm.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL T glm::distance2 ( T const &  p0,
T const &  p1 
)

Returns the squared distance between p0 and p1, i.e., length2(p0 - p1).

From GLM_GTX_norm extension.

GLM_FUNC_DECL genType::value_type glm::distance2 ( genType const &  p0,
genType const &  p1 
)

Returns the squared distance between p0 and p1, i.e., length2(p0 - p1).

From GLM_GTX_norm extension.

GLM_FUNC_DECL T glm::l1Norm ( tvec3< T, P > const &  x,
tvec3< T, P > const &  y 
)

Returns the L1 norm between x and y.

From GLM_GTX_norm extension.

GLM_FUNC_DECL T glm::l1Norm ( tvec3< T, P > const &  v)

Returns the L1 norm of v.

From GLM_GTX_norm extension.

GLM_FUNC_DECL T glm::l2Norm ( tvec3< T, P > const &  x,
tvec3< T, P > const &  y 
)

Returns the L2 norm between x and y.

From GLM_GTX_norm extension.

GLM_FUNC_DECL T glm::l2Norm ( tvec3< T, P > const &  x)

Returns the L2 norm of v.

From GLM_GTX_norm extension.

GLM_FUNC_DECL T glm::length2 ( T const &  x)

Returns the squared length of x.

From GLM_GTX_norm extension.

GLM_FUNC_DECL genType::value_type glm::length2 ( genType const &  x)

Returns the squared length of x.

From GLM_GTX_norm extension.

GLM_FUNC_DECL T glm::lxNorm ( tvec3< T, P > const &  x,
tvec3< T, P > const &  y,
unsigned int  Depth 
)

Returns the L norm between x and y.

From GLM_GTX_norm extension.

GLM_FUNC_DECL T glm::lxNorm ( tvec3< T, P > const &  x,
unsigned int  Depth 
)

Returns the L norm of v.

From GLM_GTX_norm extension.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00216.html000066400000000000000000000100671356361734700216470ustar00rootroot00000000000000 0.9.7: GLM_GTX_normal
Functions
GLM_GTX_normal
GTX Extensions (Experimental)

Functions

template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > triangleNormal (tvec3< T, P > const &p1, tvec3< T, P > const &p2, tvec3< T, P > const &p3)
 

Detailed Description

Compute the normal of a triangle.

<glm/gtx/normal.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL tvec3<T, P> glm::triangleNormal ( tvec3< T, P > const &  p1,
tvec3< T, P > const &  p2,
tvec3< T, P > const &  p3 
)

Computes triangle normal from triangle points.

From GLM_GTX_normal extension.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00217.html000066400000000000000000000134301356361734700216450ustar00rootroot00000000000000 0.9.7: GLM_GTX_normalize_dot
Functions
GLM_GTX_normalize_dot
GTX Extensions (Experimental)

Functions

template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL T fastNormalizeDot (vecType< T, P > const &x, vecType< T, P > const &y)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL T normalizeDot (vecType< T, P > const &x, vecType< T, P > const &y)
 

Detailed Description

Dot product of vectors that need to be normalize with a single square root.

<glm/gtx/normalized_dot.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL T glm::fastNormalizeDot ( vecType< T, P > const &  x,
vecType< T, P > const &  y 
)

Normalize parameters and returns the dot product of x and y.

Faster that dot(fastNormalize(x), fastNormalize(y)).

See also
GLM_GTX_normalize_dot extension.
GLM_FUNC_DECL T glm::normalizeDot ( vecType< T, P > const &  x,
vecType< T, P > const &  y 
)

Normalize parameters and returns the dot product of x and y.

It's faster that dot(normalize(x), normalize(y)).

See also
GLM_GTX_normalize_dot extension.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00218.html000066400000000000000000000150751356361734700216550ustar00rootroot00000000000000 0.9.7: GLM_GTX_number_precision
Typedefs
GLM_GTX_number_precision
GTX Extensions (Experimental)

Typedefs

typedef f32 f32mat1
 
typedef f32 f32mat1x1
 
typedef f32 f32vec1
 
typedef f64 f64mat1
 
typedef f64 f64mat1x1
 
typedef f64 f64vec1
 
typedef u16 u16vec1
 
typedef u32 u32vec1
 
typedef u64 u64vec1
 
typedef u8 u8vec1
 

Detailed Description

Defined size types.

<glm/gtx/number_precision.hpp> need to be included to use these functionalities.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00219.html000066400000000000000000000137111356361734700216510ustar00rootroot00000000000000 0.9.7: GLM_GTX_optimum_pow
Functions
GLM_GTX_optimum_pow
GTX Extensions (Experimental)

Functions

template<typename genType >
GLM_FUNC_DECL genType pow2 (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL genType pow3 (genType const &x)
 
template<typename genType >
GLM_FUNC_DECL genType pow4 (genType const &x)
 

Detailed Description

Integer exponentiation of power functions.

<glm/gtx/optimum_pow.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL genType glm::gtx::pow2 ( genType const &  x)

Returns x raised to the power of 2.

See also
GLM_GTX_optimum_pow
GLM_FUNC_DECL genType glm::gtx::pow3 ( genType const &  x)

Returns x raised to the power of 3.

See also
GLM_GTX_optimum_pow
GLM_FUNC_DECL genType glm::gtx::pow4 ( genType const &  x)

Returns x raised to the power of 4.

See also
GLM_GTX_optimum_pow
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00220.html000066400000000000000000000122561356361734700216440ustar00rootroot00000000000000 0.9.7: GLM_GTX_orthonormalize
Functions
GLM_GTX_orthonormalize
GTX Extensions (Experimental)

Functions

template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > orthonormalize (tmat3x3< T, P > const &m)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > orthonormalize (tvec3< T, P > const &x, tvec3< T, P > const &y)
 

Detailed Description

Orthonormalize matrices.

<glm/gtx/orthonormalize.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL tmat3x3<T, P> glm::orthonormalize ( tmat3x3< T, P > const &  m)

Returns the orthonormalized matrix of m.

See also
GLM_GTX_orthonormalize
GLM_FUNC_DECL tvec3<T, P> glm::orthonormalize ( tvec3< T, P > const &  x,
tvec3< T, P > const &  y 
)

Orthonormalizes x according y.

See also
GLM_GTX_orthonormalize
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00221.html000066400000000000000000000074071356361734700216470ustar00rootroot00000000000000 0.9.7: GLM_GTX_perpendicular
Functions
GLM_GTX_perpendicular
GTX Extensions (Experimental)

Functions

template<typename vecType >
GLM_FUNC_DECL vecType perp (vecType const &x, vecType const &Normal)
 

Detailed Description

Perpendicular of a vector from other one.

<glm/gtx/perpendicular.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL vecType glm::perp ( vecType const &  x,
vecType const &  Normal 
)

Projects x a perpendicular axis of Normal.

From GLM_GTX_perpendicular extension.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00222.html000066400000000000000000000120361356361734700216420ustar00rootroot00000000000000 0.9.7: GLM_GTX_polar_coordinates
Functions
GLM_GTX_polar_coordinates
GTX Extensions (Experimental)

Functions

template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > euclidean (tvec2< T, P > const &polar)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > polar (tvec3< T, P > const &euclidean)
 

Detailed Description

Conversion from Euclidean space to polar space and revert.

<glm/gtx/polar_coordinates.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL tvec3<T, P> glm::euclidean ( tvec2< T, P > const &  polar)

Convert Polar to Euclidean coordinates.

See also
GLM_GTX_polar_coordinates
GLM_FUNC_DECL tvec3<T, P> glm::polar ( tvec3< T, P > const &  euclidean)

Convert Euclidean to Polar coordinates, x is the xz distance, y, the latitude and z the longitude.

See also
GLM_GTX_polar_coordinates
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00223.html000066400000000000000000000075241356361734700216510ustar00rootroot00000000000000 0.9.7: GLM_GTX_projection
Functions
GLM_GTX_projection
GTX Extensions (Experimental)

Functions

template<typename vecType >
GLM_FUNC_DECL vecType proj (vecType const &x, vecType const &Normal)
 

Detailed Description

Projection of a vector to other one.

<glm/gtx/projection.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL vecType glm::proj ( vecType const &  x,
vecType const &  Normal 
)

Projects x on Normal.

See also
GLM_GTX_projection
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00224.html000066400000000000000000000747671356361734700216670ustar00rootroot00000000000000 0.9.7: GLM_GTX_quaternion
Functions
GLM_GTX_quaternion
GTX Extensions (Experimental)

Functions

template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > cross (tquat< T, P > const &q, tvec3< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > cross (tvec3< T, P > const &v, tquat< T, P > const &q)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > exp (tquat< T, P > const &q)
 
template<typename T , precision P>
GLM_FUNC_DECL T extractRealComponent (tquat< T, P > const &q)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > fastMix (tquat< T, P > const &x, tquat< T, P > const &y, T const &a)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > intermediate (tquat< T, P > const &prev, tquat< T, P > const &curr, tquat< T, P > const &next)
 
template<typename T , precision P>
GLM_FUNC_DECL T length2 (tquat< T, P > const &q)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > log (tquat< T, P > const &q)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > pow (tquat< T, P > const &x, T const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > rotate (tquat< T, P > const &q, tvec3< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< T, P > rotate (tquat< T, P > const &q, tvec4< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > rotation (tvec3< T, P > const &orig, tvec3< T, P > const &dest)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > shortMix (tquat< T, P > const &x, tquat< T, P > const &y, T const &a)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > squad (tquat< T, P > const &q1, tquat< T, P > const &q2, tquat< T, P > const &s1, tquat< T, P > const &s2, T const &h)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > toMat3 (tquat< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > toMat4 (tquat< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > toQuat (tmat3x3< T, P > const &x)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > toQuat (tmat4x4< T, P > const &x)
 

Detailed Description

Extented quaternion types and functions.

<glm/gtx/quaternion.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL tvec3<T, P> glm::cross ( tquat< T, P > const &  q,
tvec3< T, P > const &  v 
)

Compute a cross product between a quaternion and a vector.

See also
GLM_GTX_quaternion
GLM_FUNC_DECL tvec3<T, P> glm::cross ( tvec3< T, P > const &  v,
tquat< T, P > const &  q 
)

Compute a cross product between a vector and a quaternion.

See also
GLM_GTX_quaternion
GLM_FUNC_DECL tquat<T, P> glm::exp ( tquat< T, P > const &  q)

Returns a exp of a quaternion.

See also
GLM_GTX_quaternion
GLM_FUNC_DECL T glm::extractRealComponent ( tquat< T, P > const &  q)

Extract the real component of a quaternion.

See also
GLM_GTX_quaternion
GLM_FUNC_DECL tquat<T, P> glm::fastMix ( tquat< T, P > const &  x,
tquat< T, P > const &  y,
T const &  a 
)

Quaternion normalized linear interpolation.

See also
GLM_GTX_quaternion
GLM_FUNC_DECL tquat<T, P> glm::intermediate ( tquat< T, P > const &  prev,
tquat< T, P > const &  curr,
tquat< T, P > const &  next 
)

Returns an intermediate control point for squad interpolation.

See also
GLM_GTX_quaternion
GLM_FUNC_DECL T glm::length2 ( tquat< T, P > const &  q)

Returns the squared length of x.

See also
GLM_GTX_quaternion
GLM_FUNC_DECL tquat<T, P> glm::log ( tquat< T, P > const &  q)

Returns a log of a quaternion.

See also
GLM_GTX_quaternion
GLM_FUNC_DECL tquat<T, P> glm::pow ( tquat< T, P > const &  x,
T const &  y 
)

Returns x raised to the y power.

See also
GLM_GTX_quaternion
GLM_FUNC_DECL tvec3<T, P> glm::rotate ( tquat< T, P > const &  q,
tvec3< T, P > const &  v 
)

Returns quarternion square root.

See also
GLM_GTX_quaternion Rotates a 3 components vector by a quaternion.
GLM_GTX_quaternion
GLM_FUNC_DECL tvec4<T, P> glm::rotate ( tquat< T, P > const &  q,
tvec4< T, P > const &  v 
)

Rotates a 4 components vector by a quaternion.

See also
GLM_GTX_quaternion
GLM_FUNC_DECL tquat<T, P> glm::rotation ( tvec3< T, P > const &  orig,
tvec3< T, P > const &  dest 
)

Compute the rotation between two vectors.

param orig vector, needs to be normalized param dest vector, needs to be normalized

See also
GLM_GTX_quaternion
GLM_FUNC_DECL tquat<T, P> glm::shortMix ( tquat< T, P > const &  x,
tquat< T, P > const &  y,
T const &  a 
)

Quaternion interpolation using the rotation short path.

See also
GLM_GTX_quaternion
GLM_FUNC_DECL tquat<T, P> glm::squad ( tquat< T, P > const &  q1,
tquat< T, P > const &  q2,
tquat< T, P > const &  s1,
tquat< T, P > const &  s2,
T const &  h 
)

Compute a point on a path according squad equation.

q1 and q2 are control points; s1 and s2 are intermediate control points.

See also
GLM_GTX_quaternion
GLM_FUNC_DECL tmat3x3<T, P> glm::toMat3 ( tquat< T, P > const &  x)

Converts a quaternion to a 3 * 3 matrix.

See also
GLM_GTX_quaternion

Definition at line 153 of file gtx/quaternion.hpp.

References glm::mat3_cast().

GLM_FUNC_DECL tmat4x4<T, P> glm::toMat4 ( tquat< T, P > const &  x)

Converts a quaternion to a 4 * 4 matrix.

See also
GLM_GTX_quaternion

Definition at line 160 of file gtx/quaternion.hpp.

References glm::mat4_cast().

GLM_FUNC_DECL tquat<T, P> glm::toQuat ( tmat3x3< T, P > const &  x)

Converts a 3 * 3 matrix to a quaternion.

See also
GLM_GTX_quaternion

Definition at line 167 of file gtx/quaternion.hpp.

References glm::quat_cast().

GLM_FUNC_DECL tquat<T, P> glm::toQuat ( tmat4x4< T, P > const &  x)

Converts a 4 * 4 matrix to a quaternion.

See also
GLM_GTX_quaternion

Definition at line 174 of file gtx/quaternion.hpp.

References glm::quat_cast().

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00225.html000066400000000000000000000043621356361734700216500ustar00rootroot00000000000000 0.9.7: GLM_GTX_range
GLM_GTX_range
GTX Extensions (Experimental)

Detailed Description

Defines begin and end for vectors and matrices.

Useful for range-based for loop. The range is defined over the elements, not over columns or rows (e.g. mat4 has 16 elements).

<glm/gtx/range.hpp> need to be included to use these functionalities.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00226.html000066400000000000000000000135151356361734700216510ustar00rootroot00000000000000 0.9.7: GLM_GTX_raw_data
Typedefs
GLM_GTX_raw_data
GTX Extensions (Experimental)

Typedefs

typedef detail::uint8 byte
 
typedef detail::uint32 dword
 
typedef detail::uint64 qword
 
typedef detail::uint16 word
 

Detailed Description

Projection of a vector to other one.

<glm/gtx/raw_data.hpp> need to be included to use these functionalities.

Typedef Documentation

typedef detail::uint8 byte

Type for byte numbers.

From GLM_GTX_raw_data extension.

Definition at line 59 of file raw_data.hpp.

typedef detail::uint32 dword

Type for dword numbers.

From GLM_GTX_raw_data extension.

Definition at line 67 of file raw_data.hpp.

typedef detail::uint64 qword

Type for qword numbers.

From GLM_GTX_raw_data extension.

Definition at line 71 of file raw_data.hpp.

typedef detail::uint16 word

Type for word numbers.

From GLM_GTX_raw_data extension.

Definition at line 63 of file raw_data.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00227.html000066400000000000000000000166231356361734700216550ustar00rootroot00000000000000 0.9.7: GLM_GTX_rotate_normalized_axis
Functions
GLM_GTX_rotate_normalized_axis
GTX Extensions (Experimental)

Functions

template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > rotateNormalizedAxis (tmat4x4< T, P > const &m, T const &angle, tvec3< T, P > const &axis)
 
template<typename T , precision P>
GLM_FUNC_DECL tquat< T, P > rotateNormalizedAxis (tquat< T, P > const &q, T const &angle, tvec3< T, P > const &axis)
 

Detailed Description

Quaternions and matrices rotations around normalized axis.

<glm/gtx/rotate_normalized_axis.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL tmat4x4<T, P> glm::rotateNormalizedAxis ( tmat4x4< T, P > const &  m,
T const &  angle,
tvec3< T, P > const &  axis 
)

Builds a rotation 4 * 4 matrix created from a normalized axis and an angle.

Parameters
mInput matrix multiplied by this rotation matrix.
angleRotation angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
axisRotation axis, must be normalized.
Template Parameters
TValue type used to build the matrix. Currently supported: half (not recommanded), float or double.
See also
GLM_GTX_rotate_normalized_axis
- rotate(T angle, T x, T y, T z)
- rotate(tmat4x4<T, P> const & m, T angle, T x, T y, T z)
- rotate(T angle, tvec3<T, P> const & v)
GLM_FUNC_DECL tquat<T, P> glm::rotateNormalizedAxis ( tquat< T, P > const &  q,
T const &  angle,
tvec3< T, P > const &  axis 
)

Rotates a quaternion from a vector of 3 components normalized axis and an angle.

Parameters
qSource orientation
angleAngle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
axisNormalized axis of the rotation, must be normalized.
See also
GLM_GTX_rotate_normalized_axis
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00228.html000066400000000000000000000463431356361734700216600ustar00rootroot00000000000000 0.9.7: GLM_GTX_rotate_vector
Functions
GLM_GTX_rotate_vector
GTX Extensions (Experimental)

Functions

template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > orientation (tvec3< T, P > const &Normal, tvec3< T, P > const &Up)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec2< T, P > rotate (tvec2< T, P > const &v, T const &angle)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > rotate (tvec3< T, P > const &v, T const &angle, tvec3< T, P > const &normal)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< T, P > rotate (tvec4< T, P > const &v, T const &angle, tvec3< T, P > const &normal)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > rotateX (tvec3< T, P > const &v, T const &angle)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< T, P > rotateX (tvec4< T, P > const &v, T const &angle)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > rotateY (tvec3< T, P > const &v, T const &angle)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< T, P > rotateY (tvec4< T, P > const &v, T const &angle)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > rotateZ (tvec3< T, P > const &v, T const &angle)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec4< T, P > rotateZ (tvec4< T, P > const &v, T const &angle)
 
template<typename T , precision P>
GLM_FUNC_DECL tvec3< T, P > slerp (tvec3< T, P > const &x, tvec3< T, P > const &y, T const &a)
 

Detailed Description

Function to directly rotate a vector.

<glm/gtx/rotate_vector.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL tmat4x4<T, P> glm::orientation ( tvec3< T, P > const &  Normal,
tvec3< T, P > const &  Up 
)

Build a rotation matrix from a normal and a up vector.

From GLM_GTX_rotate_vector extension.

GLM_FUNC_DECL tvec2<T, P> glm::rotate ( tvec2< T, P > const &  v,
T const &  angle 
)

Rotate a two dimensional vector.

From GLM_GTX_rotate_vector extension.

GLM_FUNC_DECL tvec3<T, P> glm::rotate ( tvec3< T, P > const &  v,
T const &  angle,
tvec3< T, P > const &  normal 
)

Rotate a three dimensional vector around an axis.

From GLM_GTX_rotate_vector extension.

GLM_FUNC_DECL tvec4<T, P> glm::rotate ( tvec4< T, P > const &  v,
T const &  angle,
tvec3< T, P > const &  normal 
)

Rotate a four dimensional vector around an axis.

From GLM_GTX_rotate_vector extension.

GLM_FUNC_DECL tvec3<T, P> glm::rotateX ( tvec3< T, P > const &  v,
T const &  angle 
)

Rotate a three dimensional vector around the X axis.

From GLM_GTX_rotate_vector extension.

GLM_FUNC_DECL tvec4<T, P> glm::rotateX ( tvec4< T, P > const &  v,
T const &  angle 
)

Rotate a four dimentionnals vector around the X axis.

From GLM_GTX_rotate_vector extension.

GLM_FUNC_DECL tvec3<T, P> glm::rotateY ( tvec3< T, P > const &  v,
T const &  angle 
)

Rotate a three dimensional vector around the Y axis.

From GLM_GTX_rotate_vector extension.

GLM_FUNC_DECL tvec4<T, P> glm::rotateY ( tvec4< T, P > const &  v,
T const &  angle 
)

Rotate a four dimensional vector around the X axis.

From GLM_GTX_rotate_vector extension.

GLM_FUNC_DECL tvec3<T, P> glm::rotateZ ( tvec3< T, P > const &  v,
T const &  angle 
)

Rotate a three dimensional vector around the Z axis.

From GLM_GTX_rotate_vector extension.

GLM_FUNC_DECL tvec4<T, P> glm::rotateZ ( tvec4< T, P > const &  v,
T const &  angle 
)

Rotate a four dimensional vector around the X axis.

From GLM_GTX_rotate_vector extension.

GLM_FUNC_DECL tvec3<T, P> glm::slerp ( tvec3< T, P > const &  x,
tvec3< T, P > const &  y,
T const &  a 
)

Returns Spherical interpolation between two vectors.

Parameters
xA first vector
yA second vector
aInterpolation factor. The interpolation is defined beyond the range [0, 1].
See also
GLM_GTX_rotate_vector
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00229.html000066400000000000000000000041161356361734700216510ustar00rootroot00000000000000 0.9.7: GLM_GTX_scalar_relational
GLM_GTX_scalar_relational
GTX Extensions (Experimental)

Extend a position from a source to a position at a defined length.

<glm/gtx/scalar_relational.hpp> need to be included to use these functionalities.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00230.html000066400000000000000000000040251356361734700216400ustar00rootroot00000000000000 0.9.7: GLM_GTX_simd_mat4
GLM_GTX_simd_mat4
GTX Extensions (Experimental)

SIMD implementation of mat4 type.

<glm/gtx/simd_mat4.hpp> need to be included to use these functionalities.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00231.html000066400000000000000000000040251356361734700216410ustar00rootroot00000000000000 0.9.7: GLM_GTX_simd_quat
GLM_GTX_simd_quat
GTX Extensions (Experimental)

SIMD implementation of quat type.

<glm/gtx/simd_quat.hpp> need to be included to use these functionalities.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00232.html000066400000000000000000000040251356361734700216420ustar00rootroot00000000000000 0.9.7: GLM_GTX_simd_vec4
GLM_GTX_simd_vec4
GTX Extensions (Experimental)

SIMD implementation of vec4 type.

<glm/gtx/simd_vec4.hpp> need to be included to use these functionalities.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00233.html000066400000000000000000000214471356361734700216520ustar00rootroot00000000000000 0.9.7: GLM_GTX_spline
Functions
GLM_GTX_spline
GTX Extensions (Experimental)

Functions

template<typename genType >
GLM_FUNC_DECL genType catmullRom (genType const &v1, genType const &v2, genType const &v3, genType const &v4, typename genType::value_type const &s)
 
template<typename genType >
GLM_FUNC_DECL genType cubic (genType const &v1, genType const &v2, genType const &v3, genType const &v4, typename genType::value_type const &s)
 
template<typename genType >
GLM_FUNC_DECL genType hermite (genType const &v1, genType const &t1, genType const &v2, genType const &t2, typename genType::value_type const &s)
 

Detailed Description

Spline functions.

<glm/gtx/spline.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL genType glm::catmullRom ( genType const &  v1,
genType const &  v2,
genType const &  v3,
genType const &  v4,
typename genType::value_type const &  s 
)

Return a point from a catmull rom curve.

See also
GLM_GTX_spline extension.
GLM_FUNC_DECL genType glm::cubic ( genType const &  v1,
genType const &  v2,
genType const &  v3,
genType const &  v4,
typename genType::value_type const &  s 
)

Return a point from a cubic curve.

See also
GLM_GTX_spline extension.
GLM_FUNC_DECL genType glm::hermite ( genType const &  v1,
genType const &  t1,
genType const &  v2,
genType const &  t2,
typename genType::value_type const &  s 
)

Return a point from a hermite curve.

See also
GLM_GTX_spline extension.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00234.html000066400000000000000000000243221356361734700216460ustar00rootroot00000000000000 0.9.7: GLM_GTX_std_based_type
Typedefs
GLM_GTX_std_based_type
GTX Extensions (Experimental)

Typedefs

typedef tvec1< std::size_t, defaultp > size1
 
typedef tvec1< std::size_t, defaultp > size1_t
 
typedef tvec2< std::size_t, defaultp > size2
 
typedef tvec2< std::size_t, defaultp > size2_t
 
typedef tvec3< std::size_t, defaultp > size3
 
typedef tvec3< std::size_t, defaultp > size3_t
 
typedef tvec4< std::size_t, defaultp > size4
 
typedef tvec4< std::size_t, defaultp > size4_t
 

Detailed Description

Adds vector types based on STL value types.

<glm/gtx/std_based_type.hpp> need to be included to use these functionalities.

Typedef Documentation

typedef tvec1<std::size_t, defaultp> size1

Vector type based of one std::size_t component.

See also
GLM_GTX_std_based_type

Definition at line 59 of file std_based_type.hpp.

typedef tvec1<std::size_t, defaultp> size1_t

Vector type based of one std::size_t component.

See also
GLM_GTX_std_based_type

Definition at line 75 of file std_based_type.hpp.

typedef tvec2<std::size_t, defaultp> size2

Vector type based of two std::size_t components.

See also
GLM_GTX_std_based_type

Definition at line 63 of file std_based_type.hpp.

typedef tvec2<std::size_t, defaultp> size2_t

Vector type based of two std::size_t components.

See also
GLM_GTX_std_based_type

Definition at line 79 of file std_based_type.hpp.

typedef tvec3<std::size_t, defaultp> size3

Vector type based of three std::size_t components.

See also
GLM_GTX_std_based_type

Definition at line 67 of file std_based_type.hpp.

typedef tvec3<std::size_t, defaultp> size3_t

Vector type based of three std::size_t components.

See also
GLM_GTX_std_based_type

Definition at line 83 of file std_based_type.hpp.

typedef tvec4<std::size_t, defaultp> size4

Vector type based of four std::size_t components.

See also
GLM_GTX_std_based_type

Definition at line 71 of file std_based_type.hpp.

typedef tvec4<std::size_t, defaultp> size4_t

Vector type based of four std::size_t components.

See also
GLM_GTX_std_based_type

Definition at line 87 of file std_based_type.hpp.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00235.html000066400000000000000000000073531356361734700216540ustar00rootroot00000000000000 0.9.7: GLM_GTX_string_cast
Functions
GLM_GTX_string_cast
GTX Extensions (Experimental)

Functions

template<template< typename, precision > class matType, typename T , precision P>
GLM_FUNC_DECL std::string to_string (matType< T, P > const &x)
 

Detailed Description

Setup strings for GLM type values.

<glm/gtx/string_cast.hpp> need to be included to use these functionalities. This extension is not supported with CUDA

Function Documentation

GLM_FUNC_DECL std::string glm::to_string ( matType< T, P > const &  x)

Create a string from a GLM vector or matrix typed variable.

See also
GLM_GTX_string_cast extension.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00236.html000066400000000000000000000156111356361734700216510ustar00rootroot00000000000000 0.9.7: GLM_GTX_transform
Functions
GLM_GTX_transform
GTX Extensions (Experimental)

Functions

template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > rotate (T angle, tvec3< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > scale (tvec3< T, P > const &v)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > translate (tvec3< T, P > const &v)
 

Detailed Description

Add transformation matrices.

<glm/gtx/transform.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL tmat4x4<T, P> glm::rotate ( T  angle,
tvec3< T, P > const &  v 
)

Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in degrees.

See also
GLM_GTC_matrix_transform
GLM_GTX_transform
GLM_FUNC_DECL tmat4x4<T, P> glm::scale ( tvec3< T, P > const &  v)

Transforms a matrix with a scale 4 * 4 matrix created from a vector of 3 components.

See also
GLM_GTC_matrix_transform
GLM_GTX_transform
GLM_FUNC_DECL tmat4x4<T, P> glm::translate ( tvec3< T, P > const &  v)

Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars.

See also
GLM_GTC_matrix_transform
GLM_GTX_transform
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00237.html000066400000000000000000000374301356361734700216550ustar00rootroot00000000000000 0.9.7: GLM_GTX_transform2
Functions
GLM_GTX_transform2
GTX Extensions (Experimental)

Functions

template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > proj2D (const tmat3x3< T, P > &m, const tvec3< T, P > &normal)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > proj3D (const tmat4x4< T, P > &m, const tvec3< T, P > &normal)
 
template<typename valType , precision P>
GLM_FUNC_DECL tmat4x4< valType, P > scaleBias (valType scale, valType bias)
 
template<typename valType , precision P>
GLM_FUNC_DECL tmat4x4< valType, P > scaleBias (tmat4x4< valType, P > const &m, valType scale, valType bias)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > shearX2D (tmat3x3< T, P > const &m, T y)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > shearX3D (const tmat4x4< T, P > &m, T y, T z)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat3x3< T, P > shearY2D (tmat3x3< T, P > const &m, T x)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > shearY3D (const tmat4x4< T, P > &m, T x, T z)
 
template<typename T , precision P>
GLM_FUNC_DECL tmat4x4< T, P > shearZ3D (const tmat4x4< T, P > &m, T x, T y)
 

Detailed Description

Add extra transformation matrices.

<glm/gtx/transform2.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL tmat3x3<T, P> glm::proj2D ( const tmat3x3< T, P > &  m,
const tvec3< T, P > &  normal 
)

Build planar projection matrix along normal axis.

From GLM_GTX_transform2 extension.

GLM_FUNC_DECL tmat4x4<T, P> glm::proj3D ( const tmat4x4< T, P > &  m,
const tvec3< T, P > &  normal 
)

Build planar projection matrix along normal axis.

From GLM_GTX_transform2 extension.

GLM_FUNC_DECL tmat4x4<valType, P> glm::scaleBias ( valType  scale,
valType  bias 
)

Build a scale bias matrix.

From GLM_GTX_transform2 extension.

GLM_FUNC_DECL tmat4x4<valType, P> glm::scaleBias ( tmat4x4< valType, P > const &  m,
valType  scale,
valType  bias 
)

Build a scale bias matrix.

From GLM_GTX_transform2 extension.

GLM_FUNC_DECL tmat3x3<T, P> glm::shearX2D ( tmat3x3< T, P > const &  m,
T  y 
)

Transforms a matrix with a shearing on X axis.

From GLM_GTX_transform2 extension.

GLM_FUNC_DECL tmat4x4<T, P> glm::shearX3D ( const tmat4x4< T, P > &  m,
T  y,
T  z 
)

Transforms a matrix with a shearing on X axis From GLM_GTX_transform2 extension.

GLM_FUNC_DECL tmat3x3<T, P> glm::shearY2D ( tmat3x3< T, P > const &  m,
T  x 
)

Transforms a matrix with a shearing on Y axis.

From GLM_GTX_transform2 extension.

GLM_FUNC_DECL tmat4x4<T, P> glm::shearY3D ( const tmat4x4< T, P > &  m,
T  x,
T  z 
)

Transforms a matrix with a shearing on Y axis.

From GLM_GTX_transform2 extension.

GLM_FUNC_DECL tmat4x4<T, P> glm::shearZ3D ( const tmat4x4< T, P > &  m,
T  x,
T  y 
)

Transforms a matrix with a shearing on Z axis.

From GLM_GTX_transform2 extension.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00238.html000066400000000000000000011736621356361734700216670ustar00rootroot00000000000000 0.9.7: GLM_GTX_type_aligned
Functions
GLM_GTX_type_aligned
GTX Extensions (Experimental)

Functions

 GLM_ALIGNED_TYPEDEF (lowp_int8, aligned_lowp_int8, 1)
 
 GLM_ALIGNED_TYPEDEF (lowp_int16, aligned_lowp_int16, 2)
 
 GLM_ALIGNED_TYPEDEF (lowp_int32, aligned_lowp_int32, 4)
 
 GLM_ALIGNED_TYPEDEF (lowp_int64, aligned_lowp_int64, 8)
 
 GLM_ALIGNED_TYPEDEF (lowp_int8_t, aligned_lowp_int8_t, 1)
 
 GLM_ALIGNED_TYPEDEF (lowp_int16_t, aligned_lowp_int16_t, 2)
 
 GLM_ALIGNED_TYPEDEF (lowp_int32_t, aligned_lowp_int32_t, 4)
 
 GLM_ALIGNED_TYPEDEF (lowp_int64_t, aligned_lowp_int64_t, 8)
 
 GLM_ALIGNED_TYPEDEF (lowp_i8, aligned_lowp_i8, 1)
 
 GLM_ALIGNED_TYPEDEF (lowp_i16, aligned_lowp_i16, 2)
 
 GLM_ALIGNED_TYPEDEF (lowp_i32, aligned_lowp_i32, 4)
 
 GLM_ALIGNED_TYPEDEF (lowp_i64, aligned_lowp_i64, 8)
 
 GLM_ALIGNED_TYPEDEF (mediump_int8, aligned_mediump_int8, 1)
 
 GLM_ALIGNED_TYPEDEF (mediump_int16, aligned_mediump_int16, 2)
 
 GLM_ALIGNED_TYPEDEF (mediump_int32, aligned_mediump_int32, 4)
 
 GLM_ALIGNED_TYPEDEF (mediump_int64, aligned_mediump_int64, 8)
 
 GLM_ALIGNED_TYPEDEF (mediump_int8_t, aligned_mediump_int8_t, 1)
 
 GLM_ALIGNED_TYPEDEF (mediump_int16_t, aligned_mediump_int16_t, 2)
 
 GLM_ALIGNED_TYPEDEF (mediump_int32_t, aligned_mediump_int32_t, 4)
 
 GLM_ALIGNED_TYPEDEF (mediump_int64_t, aligned_mediump_int64_t, 8)
 
 GLM_ALIGNED_TYPEDEF (mediump_i8, aligned_mediump_i8, 1)
 
 GLM_ALIGNED_TYPEDEF (mediump_i16, aligned_mediump_i16, 2)
 
 GLM_ALIGNED_TYPEDEF (mediump_i32, aligned_mediump_i32, 4)
 
 GLM_ALIGNED_TYPEDEF (mediump_i64, aligned_mediump_i64, 8)
 
 GLM_ALIGNED_TYPEDEF (highp_int8, aligned_highp_int8, 1)
 
 GLM_ALIGNED_TYPEDEF (highp_int16, aligned_highp_int16, 2)
 
 GLM_ALIGNED_TYPEDEF (highp_int32, aligned_highp_int32, 4)
 
 GLM_ALIGNED_TYPEDEF (highp_int64, aligned_highp_int64, 8)
 
 GLM_ALIGNED_TYPEDEF (highp_int8_t, aligned_highp_int8_t, 1)
 
 GLM_ALIGNED_TYPEDEF (highp_int16_t, aligned_highp_int16_t, 2)
 
 GLM_ALIGNED_TYPEDEF (highp_int32_t, aligned_highp_int32_t, 4)
 
 GLM_ALIGNED_TYPEDEF (highp_int64_t, aligned_highp_int64_t, 8)
 
 GLM_ALIGNED_TYPEDEF (highp_i8, aligned_highp_i8, 1)
 
 GLM_ALIGNED_TYPEDEF (highp_i16, aligned_highp_i16, 2)
 
 GLM_ALIGNED_TYPEDEF (highp_i32, aligned_highp_i32, 4)
 
 GLM_ALIGNED_TYPEDEF (highp_i64, aligned_highp_i64, 8)
 
 GLM_ALIGNED_TYPEDEF (int8, aligned_int8, 1)
 
 GLM_ALIGNED_TYPEDEF (int16, aligned_int16, 2)
 
 GLM_ALIGNED_TYPEDEF (int32, aligned_int32, 4)
 
 GLM_ALIGNED_TYPEDEF (int64, aligned_int64, 8)
 
 GLM_ALIGNED_TYPEDEF (int8_t, aligned_int8_t, 1)
 
 GLM_ALIGNED_TYPEDEF (int16_t, aligned_int16_t, 2)
 
 GLM_ALIGNED_TYPEDEF (int32_t, aligned_int32_t, 4)
 
 GLM_ALIGNED_TYPEDEF (int64_t, aligned_int64_t, 8)
 
 GLM_ALIGNED_TYPEDEF (i8, aligned_i8, 1)
 
 GLM_ALIGNED_TYPEDEF (i16, aligned_i16, 2)
 
 GLM_ALIGNED_TYPEDEF (i32, aligned_i32, 4)
 
 GLM_ALIGNED_TYPEDEF (i64, aligned_i64, 8)
 
 GLM_ALIGNED_TYPEDEF (ivec1, aligned_ivec1, 4)
 
 GLM_ALIGNED_TYPEDEF (ivec2, aligned_ivec2, 8)
 
 GLM_ALIGNED_TYPEDEF (ivec3, aligned_ivec3, 16)
 
 GLM_ALIGNED_TYPEDEF (ivec4, aligned_ivec4, 16)
 
 GLM_ALIGNED_TYPEDEF (i8vec1, aligned_i8vec1, 1)
 
 GLM_ALIGNED_TYPEDEF (i8vec2, aligned_i8vec2, 2)
 
 GLM_ALIGNED_TYPEDEF (i8vec3, aligned_i8vec3, 4)
 
 GLM_ALIGNED_TYPEDEF (i8vec4, aligned_i8vec4, 4)
 
 GLM_ALIGNED_TYPEDEF (i16vec1, aligned_i16vec1, 2)
 
 GLM_ALIGNED_TYPEDEF (i16vec2, aligned_i16vec2, 4)
 
 GLM_ALIGNED_TYPEDEF (i16vec3, aligned_i16vec3, 8)
 
 GLM_ALIGNED_TYPEDEF (i16vec4, aligned_i16vec4, 8)
 
 GLM_ALIGNED_TYPEDEF (i32vec1, aligned_i32vec1, 4)
 
 GLM_ALIGNED_TYPEDEF (i32vec2, aligned_i32vec2, 8)
 
 GLM_ALIGNED_TYPEDEF (i32vec3, aligned_i32vec3, 16)
 
 GLM_ALIGNED_TYPEDEF (i32vec4, aligned_i32vec4, 16)
 
 GLM_ALIGNED_TYPEDEF (i64vec1, aligned_i64vec1, 8)
 
 GLM_ALIGNED_TYPEDEF (i64vec2, aligned_i64vec2, 16)
 
 GLM_ALIGNED_TYPEDEF (i64vec3, aligned_i64vec3, 32)
 
 GLM_ALIGNED_TYPEDEF (i64vec4, aligned_i64vec4, 32)
 
 GLM_ALIGNED_TYPEDEF (lowp_uint8, aligned_lowp_uint8, 1)
 
 GLM_ALIGNED_TYPEDEF (lowp_uint16, aligned_lowp_uint16, 2)
 
 GLM_ALIGNED_TYPEDEF (lowp_uint32, aligned_lowp_uint32, 4)
 
 GLM_ALIGNED_TYPEDEF (lowp_uint64, aligned_lowp_uint64, 8)
 
 GLM_ALIGNED_TYPEDEF (lowp_uint8_t, aligned_lowp_uint8_t, 1)
 
 GLM_ALIGNED_TYPEDEF (lowp_uint16_t, aligned_lowp_uint16_t, 2)
 
 GLM_ALIGNED_TYPEDEF (lowp_uint32_t, aligned_lowp_uint32_t, 4)
 
 GLM_ALIGNED_TYPEDEF (lowp_uint64_t, aligned_lowp_uint64_t, 8)
 
 GLM_ALIGNED_TYPEDEF (lowp_u8, aligned_lowp_u8, 1)
 
 GLM_ALIGNED_TYPEDEF (lowp_u16, aligned_lowp_u16, 2)
 
 GLM_ALIGNED_TYPEDEF (lowp_u32, aligned_lowp_u32, 4)
 
 GLM_ALIGNED_TYPEDEF (lowp_u64, aligned_lowp_u64, 8)
 
 GLM_ALIGNED_TYPEDEF (mediump_uint8, aligned_mediump_uint8, 1)
 
 GLM_ALIGNED_TYPEDEF (mediump_uint16, aligned_mediump_uint16, 2)
 
 GLM_ALIGNED_TYPEDEF (mediump_uint32, aligned_mediump_uint32, 4)
 
 GLM_ALIGNED_TYPEDEF (mediump_uint64, aligned_mediump_uint64, 8)
 
 GLM_ALIGNED_TYPEDEF (mediump_uint8_t, aligned_mediump_uint8_t, 1)
 
 GLM_ALIGNED_TYPEDEF (mediump_uint16_t, aligned_mediump_uint16_t, 2)
 
 GLM_ALIGNED_TYPEDEF (mediump_uint32_t, aligned_mediump_uint32_t, 4)
 
 GLM_ALIGNED_TYPEDEF (mediump_uint64_t, aligned_mediump_uint64_t, 8)
 
 GLM_ALIGNED_TYPEDEF (mediump_u8, aligned_mediump_u8, 1)
 
 GLM_ALIGNED_TYPEDEF (mediump_u16, aligned_mediump_u16, 2)
 
 GLM_ALIGNED_TYPEDEF (mediump_u32, aligned_mediump_u32, 4)
 
 GLM_ALIGNED_TYPEDEF (mediump_u64, aligned_mediump_u64, 8)
 
 GLM_ALIGNED_TYPEDEF (highp_uint8, aligned_highp_uint8, 1)
 
 GLM_ALIGNED_TYPEDEF (highp_uint16, aligned_highp_uint16, 2)
 
 GLM_ALIGNED_TYPEDEF (highp_uint32, aligned_highp_uint32, 4)
 
 GLM_ALIGNED_TYPEDEF (highp_uint64, aligned_highp_uint64, 8)
 
 GLM_ALIGNED_TYPEDEF (highp_uint8_t, aligned_highp_uint8_t, 1)
 
 GLM_ALIGNED_TYPEDEF (highp_uint16_t, aligned_highp_uint16_t, 2)
 
 GLM_ALIGNED_TYPEDEF (highp_uint32_t, aligned_highp_uint32_t, 4)
 
 GLM_ALIGNED_TYPEDEF (highp_uint64_t, aligned_highp_uint64_t, 8)
 
 GLM_ALIGNED_TYPEDEF (highp_u8, aligned_highp_u8, 1)
 
 GLM_ALIGNED_TYPEDEF (highp_u16, aligned_highp_u16, 2)
 
 GLM_ALIGNED_TYPEDEF (highp_u32, aligned_highp_u32, 4)
 
 GLM_ALIGNED_TYPEDEF (highp_u64, aligned_highp_u64, 8)
 
 GLM_ALIGNED_TYPEDEF (uint8, aligned_uint8, 1)
 
 GLM_ALIGNED_TYPEDEF (uint16, aligned_uint16, 2)
 
 GLM_ALIGNED_TYPEDEF (uint32, aligned_uint32, 4)
 
 GLM_ALIGNED_TYPEDEF (uint64, aligned_uint64, 8)
 
 GLM_ALIGNED_TYPEDEF (uint8_t, aligned_uint8_t, 1)
 
 GLM_ALIGNED_TYPEDEF (uint16_t, aligned_uint16_t, 2)
 
 GLM_ALIGNED_TYPEDEF (uint32_t, aligned_uint32_t, 4)
 
 GLM_ALIGNED_TYPEDEF (uint64_t, aligned_uint64_t, 8)
 
 GLM_ALIGNED_TYPEDEF (u8, aligned_u8, 1)
 
 GLM_ALIGNED_TYPEDEF (u16, aligned_u16, 2)
 
 GLM_ALIGNED_TYPEDEF (u32, aligned_u32, 4)
 
 GLM_ALIGNED_TYPEDEF (u64, aligned_u64, 8)
 
 GLM_ALIGNED_TYPEDEF (uvec1, aligned_uvec1, 4)
 
 GLM_ALIGNED_TYPEDEF (uvec2, aligned_uvec2, 8)
 
 GLM_ALIGNED_TYPEDEF (uvec3, aligned_uvec3, 16)
 
 GLM_ALIGNED_TYPEDEF (uvec4, aligned_uvec4, 16)
 
 GLM_ALIGNED_TYPEDEF (u8vec1, aligned_u8vec1, 1)
 
 GLM_ALIGNED_TYPEDEF (u8vec2, aligned_u8vec2, 2)
 
 GLM_ALIGNED_TYPEDEF (u8vec3, aligned_u8vec3, 4)
 
 GLM_ALIGNED_TYPEDEF (u8vec4, aligned_u8vec4, 4)
 
 GLM_ALIGNED_TYPEDEF (u16vec1, aligned_u16vec1, 2)
 
 GLM_ALIGNED_TYPEDEF (u16vec2, aligned_u16vec2, 4)
 
 GLM_ALIGNED_TYPEDEF (u16vec3, aligned_u16vec3, 8)
 
 GLM_ALIGNED_TYPEDEF (u16vec4, aligned_u16vec4, 8)
 
 GLM_ALIGNED_TYPEDEF (u32vec1, aligned_u32vec1, 4)
 
 GLM_ALIGNED_TYPEDEF (u32vec2, aligned_u32vec2, 8)
 
 GLM_ALIGNED_TYPEDEF (u32vec3, aligned_u32vec3, 16)
 
 GLM_ALIGNED_TYPEDEF (u32vec4, aligned_u32vec4, 16)
 
 GLM_ALIGNED_TYPEDEF (u64vec1, aligned_u64vec1, 8)
 
 GLM_ALIGNED_TYPEDEF (u64vec2, aligned_u64vec2, 16)
 
 GLM_ALIGNED_TYPEDEF (u64vec3, aligned_u64vec3, 32)
 
 GLM_ALIGNED_TYPEDEF (u64vec4, aligned_u64vec4, 32)
 
 GLM_ALIGNED_TYPEDEF (float32, aligned_float32, 4)
 
 GLM_ALIGNED_TYPEDEF (float64, aligned_float64, 8)
 
 GLM_ALIGNED_TYPEDEF (float32_t, aligned_float32_t, 4)
 
 GLM_ALIGNED_TYPEDEF (float64_t, aligned_float64_t, 8)
 
 GLM_ALIGNED_TYPEDEF (float32, aligned_f32, 4)
 
 GLM_ALIGNED_TYPEDEF (float64, aligned_f64, 8)
 
 GLM_ALIGNED_TYPEDEF (vec1, aligned_vec1, 4)
 
 GLM_ALIGNED_TYPEDEF (vec2, aligned_vec2, 8)
 
 GLM_ALIGNED_TYPEDEF (vec3, aligned_vec3, 16)
 
 GLM_ALIGNED_TYPEDEF (vec4, aligned_vec4, 16)
 
 GLM_ALIGNED_TYPEDEF (fvec1, aligned_fvec1, 4)
 
 GLM_ALIGNED_TYPEDEF (fvec2, aligned_fvec2, 8)
 
 GLM_ALIGNED_TYPEDEF (fvec3, aligned_fvec3, 16)
 
 GLM_ALIGNED_TYPEDEF (fvec4, aligned_fvec4, 16)
 
 GLM_ALIGNED_TYPEDEF (f32vec1, aligned_f32vec1, 4)
 
 GLM_ALIGNED_TYPEDEF (f32vec2, aligned_f32vec2, 8)
 
 GLM_ALIGNED_TYPEDEF (f32vec3, aligned_f32vec3, 16)
 
 GLM_ALIGNED_TYPEDEF (f32vec4, aligned_f32vec4, 16)
 
 GLM_ALIGNED_TYPEDEF (dvec1, aligned_dvec1, 8)
 
 GLM_ALIGNED_TYPEDEF (dvec2, aligned_dvec2, 16)
 
 GLM_ALIGNED_TYPEDEF (dvec3, aligned_dvec3, 32)
 
 GLM_ALIGNED_TYPEDEF (dvec4, aligned_dvec4, 32)
 
 GLM_ALIGNED_TYPEDEF (f64vec1, aligned_f64vec1, 8)
 
 GLM_ALIGNED_TYPEDEF (f64vec2, aligned_f64vec2, 16)
 
 GLM_ALIGNED_TYPEDEF (f64vec3, aligned_f64vec3, 32)
 
 GLM_ALIGNED_TYPEDEF (f64vec4, aligned_f64vec4, 32)
 
 GLM_ALIGNED_TYPEDEF (mat2, aligned_mat2, 16)
 
 GLM_ALIGNED_TYPEDEF (mat3, aligned_mat3, 16)
 
 GLM_ALIGNED_TYPEDEF (mat4, aligned_mat4, 16)
 
 GLM_ALIGNED_TYPEDEF (mat2x2, aligned_mat2x2, 16)
 
 GLM_ALIGNED_TYPEDEF (mat3x3, aligned_mat3x3, 16)
 
 GLM_ALIGNED_TYPEDEF (mat4x4, aligned_mat4x4, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat2x2, aligned_fmat2, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat3x3, aligned_fmat3, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat4x4, aligned_fmat4, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat2x2, aligned_fmat2x2, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat2x3, aligned_fmat2x3, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat2x4, aligned_fmat2x4, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat3x2, aligned_fmat3x2, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat3x3, aligned_fmat3x3, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat3x4, aligned_fmat3x4, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat4x2, aligned_fmat4x2, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat4x3, aligned_fmat4x3, 16)
 
 GLM_ALIGNED_TYPEDEF (fmat4x4, aligned_fmat4x4, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat2x2, aligned_f32mat2, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat3x3, aligned_f32mat3, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat4x4, aligned_f32mat4, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat2x2, aligned_f32mat2x2, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat2x3, aligned_f32mat2x3, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat2x4, aligned_f32mat2x4, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat3x2, aligned_f32mat3x2, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat3x3, aligned_f32mat3x3, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat3x4, aligned_f32mat3x4, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat4x2, aligned_f32mat4x2, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat4x3, aligned_f32mat4x3, 16)
 
 GLM_ALIGNED_TYPEDEF (f32mat4x4, aligned_f32mat4x4, 16)
 
 GLM_ALIGNED_TYPEDEF (f64mat2x2, aligned_f64mat2, 32)
 
 GLM_ALIGNED_TYPEDEF (f64mat3x3, aligned_f64mat3, 32)
 
 GLM_ALIGNED_TYPEDEF (f64mat4x4, aligned_f64mat4, 32)
 
 GLM_ALIGNED_TYPEDEF (f64mat2x2, aligned_f64mat2x2, 32)
 
 GLM_ALIGNED_TYPEDEF (f64mat2x3, aligned_f64mat2x3, 32)
 
 GLM_ALIGNED_TYPEDEF (f64mat2x4, aligned_f64mat2x4, 32)
 
 GLM_ALIGNED_TYPEDEF (f64mat3x2, aligned_f64mat3x2, 32)
 
 GLM_ALIGNED_TYPEDEF (f64mat3x3, aligned_f64mat3x3, 32)
 
 GLM_ALIGNED_TYPEDEF (f64mat3x4, aligned_f64mat3x4, 32)
 
 GLM_ALIGNED_TYPEDEF (f64mat4x2, aligned_f64mat4x2, 32)
 
 GLM_ALIGNED_TYPEDEF (f64mat4x3, aligned_f64mat4x3, 32)
 
 GLM_ALIGNED_TYPEDEF (f64mat4x4, aligned_f64mat4x4, 32)
 
 GLM_ALIGNED_TYPEDEF (quat, aligned_quat, 16)
 
 GLM_ALIGNED_TYPEDEF (fquat, aligned_fquat, 16)
 
 GLM_ALIGNED_TYPEDEF (dquat, aligned_dquat, 32)
 
 GLM_ALIGNED_TYPEDEF (f32quat, aligned_f32quat, 16)
 
 GLM_ALIGNED_TYPEDEF (f64quat, aligned_f64quat, 32)
 

Detailed Description

Defines aligned types.

Precision types defines aligned types.

<glm/gtx/type_aligned.hpp> need to be included to use these functionalities.

Function Documentation

glm::GLM_ALIGNED_TYPEDEF ( lowp_int8  ,
aligned_lowp_int8  ,
1   
)

Low precision 8 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_int16  ,
aligned_lowp_int16  ,
2   
)

Low precision 16 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_int32  ,
aligned_lowp_int32  ,
4   
)

Low precision 32 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_int64  ,
aligned_lowp_int64  ,
8   
)

Low precision 64 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_int8_t  ,
aligned_lowp_int8_t  ,
1   
)

Low precision 8 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_int16_t  ,
aligned_lowp_int16_t  ,
2   
)

Low precision 16 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_int32_t  ,
aligned_lowp_int32_t  ,
4   
)

Low precision 32 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_int64_t  ,
aligned_lowp_int64_t  ,
8   
)

Low precision 64 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_i8  ,
aligned_lowp_i8  ,
1   
)

Low precision 8 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_i16  ,
aligned_lowp_i16  ,
2   
)

Low precision 16 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_i32  ,
aligned_lowp_i32  ,
4   
)

Low precision 32 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_i64  ,
aligned_lowp_i64  ,
8   
)

Low precision 64 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_int8  ,
aligned_mediump_int8  ,
1   
)

Medium precision 8 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_int16  ,
aligned_mediump_int16  ,
2   
)

Medium precision 16 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_int32  ,
aligned_mediump_int32  ,
4   
)

Medium precision 32 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_int64  ,
aligned_mediump_int64  ,
8   
)

Medium precision 64 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_int8_t  ,
aligned_mediump_int8_t  ,
1   
)

Medium precision 8 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_int16_t  ,
aligned_mediump_int16_t  ,
2   
)

Medium precision 16 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_int32_t  ,
aligned_mediump_int32_t  ,
4   
)

Medium precision 32 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_int64_t  ,
aligned_mediump_int64_t  ,
8   
)

Medium precision 64 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_i8  ,
aligned_mediump_i8  ,
1   
)

Medium precision 8 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_i16  ,
aligned_mediump_i16  ,
2   
)

Medium precision 16 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_i32  ,
aligned_mediump_i32  ,
4   
)

Medium precision 32 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_i64  ,
aligned_mediump_i64  ,
8   
)

Medium precision 64 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_int8  ,
aligned_highp_int8  ,
1   
)

High precision 8 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_int16  ,
aligned_highp_int16  ,
2   
)

High precision 16 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_int32  ,
aligned_highp_int32  ,
4   
)

High precision 32 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_int64  ,
aligned_highp_int64  ,
8   
)

High precision 64 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_int8_t  ,
aligned_highp_int8_t  ,
1   
)

High precision 8 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_int16_t  ,
aligned_highp_int16_t  ,
2   
)

High precision 16 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_int32_t  ,
aligned_highp_int32_t  ,
4   
)

High precision 32 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_int64_t  ,
aligned_highp_int64_t  ,
8   
)

High precision 64 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_i8  ,
aligned_highp_i8  ,
1   
)

High precision 8 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_i16  ,
aligned_highp_i16  ,
2   
)

High precision 16 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_i32  ,
aligned_highp_i32  ,
4   
)

High precision 32 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_i64  ,
aligned_highp_i64  ,
8   
)

High precision 64 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( int8  ,
aligned_int8  ,
1   
)

Default precision 8 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( int16  ,
aligned_int16  ,
2   
)

Default precision 16 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( int32  ,
aligned_int32  ,
4   
)

Default precision 32 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( int64  ,
aligned_int64  ,
8   
)

Default precision 64 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( int8_t  ,
aligned_int8_t  ,
1   
)

Default precision 8 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( int16_t  ,
aligned_int16_t  ,
2   
)

Default precision 16 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( int32_t  ,
aligned_int32_t  ,
4   
)

Default precision 32 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( int64_t  ,
aligned_int64_t  ,
8   
)

Default precision 64 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( i8  ,
aligned_i8  ,
1   
)

Default precision 8 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( i16  ,
aligned_i16  ,
2   
)

Default precision 16 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( i32  ,
aligned_i32  ,
4   
)

Default precision 32 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( i64  ,
aligned_i64  ,
8   
)

Default precision 64 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( ivec1  ,
aligned_ivec1  ,
4   
)

Default precision 32 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( ivec2  ,
aligned_ivec2  ,
8   
)

Default precision 32 bit signed integer aligned vector of 2 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( ivec3  ,
aligned_ivec3  ,
16   
)

Default precision 32 bit signed integer aligned vector of 3 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( ivec4  ,
aligned_ivec4  ,
16   
)

Default precision 32 bit signed integer aligned vector of 4 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( i8vec1  ,
aligned_i8vec1  ,
1   
)

Default precision 8 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( i8vec2  ,
aligned_i8vec2  ,
2   
)

Default precision 8 bit signed integer aligned vector of 2 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( i8vec3  ,
aligned_i8vec3  ,
4   
)

Default precision 8 bit signed integer aligned vector of 3 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( i8vec4  ,
aligned_i8vec4  ,
4   
)

Default precision 8 bit signed integer aligned vector of 4 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( i16vec1  ,
aligned_i16vec1  ,
2   
)

Default precision 16 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( i16vec2  ,
aligned_i16vec2  ,
4   
)

Default precision 16 bit signed integer aligned vector of 2 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( i16vec3  ,
aligned_i16vec3  ,
8   
)

Default precision 16 bit signed integer aligned vector of 3 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( i16vec4  ,
aligned_i16vec4  ,
8   
)

Default precision 16 bit signed integer aligned vector of 4 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( i32vec1  ,
aligned_i32vec1  ,
4   
)

Default precision 32 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( i32vec2  ,
aligned_i32vec2  ,
8   
)

Default precision 32 bit signed integer aligned vector of 2 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( i32vec3  ,
aligned_i32vec3  ,
16   
)

Default precision 32 bit signed integer aligned vector of 3 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( i32vec4  ,
aligned_i32vec4  ,
16   
)

Default precision 32 bit signed integer aligned vector of 4 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( i64vec1  ,
aligned_i64vec1  ,
8   
)

Default precision 64 bit signed integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( i64vec2  ,
aligned_i64vec2  ,
16   
)

Default precision 64 bit signed integer aligned vector of 2 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( i64vec3  ,
aligned_i64vec3  ,
32   
)

Default precision 64 bit signed integer aligned vector of 3 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( i64vec4  ,
aligned_i64vec4  ,
32   
)

Default precision 64 bit signed integer aligned vector of 4 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_uint8  ,
aligned_lowp_uint8  ,
1   
)

Low precision 8 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_uint16  ,
aligned_lowp_uint16  ,
2   
)

Low precision 16 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_uint32  ,
aligned_lowp_uint32  ,
4   
)

Low precision 32 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_uint64  ,
aligned_lowp_uint64  ,
8   
)

Low precision 64 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_uint8_t  ,
aligned_lowp_uint8_t  ,
1   
)

Low precision 8 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_uint16_t  ,
aligned_lowp_uint16_t  ,
2   
)

Low precision 16 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_uint32_t  ,
aligned_lowp_uint32_t  ,
4   
)

Low precision 32 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_uint64_t  ,
aligned_lowp_uint64_t  ,
8   
)

Low precision 64 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_u8  ,
aligned_lowp_u8  ,
1   
)

Low precision 8 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_u16  ,
aligned_lowp_u16  ,
2   
)

Low precision 16 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_u32  ,
aligned_lowp_u32  ,
4   
)

Low precision 32 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( lowp_u64  ,
aligned_lowp_u64  ,
8   
)

Low precision 64 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_uint8  ,
aligned_mediump_uint8  ,
1   
)

Medium precision 8 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_uint16  ,
aligned_mediump_uint16  ,
2   
)

Medium precision 16 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_uint32  ,
aligned_mediump_uint32  ,
4   
)

Medium precision 32 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_uint64  ,
aligned_mediump_uint64  ,
8   
)

Medium precision 64 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_uint8_t  ,
aligned_mediump_uint8_t  ,
1   
)

Medium precision 8 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_uint16_t  ,
aligned_mediump_uint16_t  ,
2   
)

Medium precision 16 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_uint32_t  ,
aligned_mediump_uint32_t  ,
4   
)

Medium precision 32 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_uint64_t  ,
aligned_mediump_uint64_t  ,
8   
)

Medium precision 64 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_u8  ,
aligned_mediump_u8  ,
1   
)

Medium precision 8 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_u16  ,
aligned_mediump_u16  ,
2   
)

Medium precision 16 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_u32  ,
aligned_mediump_u32  ,
4   
)

Medium precision 32 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mediump_u64  ,
aligned_mediump_u64  ,
8   
)

Medium precision 64 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_uint8  ,
aligned_highp_uint8  ,
1   
)

High precision 8 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_uint16  ,
aligned_highp_uint16  ,
2   
)

High precision 16 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_uint32  ,
aligned_highp_uint32  ,
4   
)

High precision 32 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_uint64  ,
aligned_highp_uint64  ,
8   
)

High precision 64 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_uint8_t  ,
aligned_highp_uint8_t  ,
1   
)

High precision 8 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_uint16_t  ,
aligned_highp_uint16_t  ,
2   
)

High precision 16 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_uint32_t  ,
aligned_highp_uint32_t  ,
4   
)

High precision 32 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_uint64_t  ,
aligned_highp_uint64_t  ,
8   
)

High precision 64 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_u8  ,
aligned_highp_u8  ,
1   
)

High precision 8 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_u16  ,
aligned_highp_u16  ,
2   
)

High precision 16 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_u32  ,
aligned_highp_u32  ,
4   
)

High precision 32 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( highp_u64  ,
aligned_highp_u64  ,
8   
)

High precision 64 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( uint8  ,
aligned_uint8  ,
1   
)

Default precision 8 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( uint16  ,
aligned_uint16  ,
2   
)

Default precision 16 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( uint32  ,
aligned_uint32  ,
4   
)

Default precision 32 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( uint64  ,
aligned_uint64  ,
8   
)

Default precision 64 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( uint8_t  ,
aligned_uint8_t  ,
1   
)

Default precision 8 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( uint16_t  ,
aligned_uint16_t  ,
2   
)

Default precision 16 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( uint32_t  ,
aligned_uint32_t  ,
4   
)

Default precision 32 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( uint64_t  ,
aligned_uint64_t  ,
8   
)

Default precision 64 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( u8  ,
aligned_u8  ,
1   
)

Default precision 8 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( u16  ,
aligned_u16  ,
2   
)

Default precision 16 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( u32  ,
aligned_u32  ,
4   
)

Default precision 32 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( u64  ,
aligned_u64  ,
8   
)

Default precision 64 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( uvec1  ,
aligned_uvec1  ,
4   
)

Default precision 32 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( uvec2  ,
aligned_uvec2  ,
8   
)

Default precision 32 bit unsigned integer aligned vector of 2 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( uvec3  ,
aligned_uvec3  ,
16   
)

Default precision 32 bit unsigned integer aligned vector of 3 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( uvec4  ,
aligned_uvec4  ,
16   
)

Default precision 32 bit unsigned integer aligned vector of 4 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( u8vec1  ,
aligned_u8vec1  ,
1   
)

Default precision 8 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( u8vec2  ,
aligned_u8vec2  ,
2   
)

Default precision 8 bit unsigned integer aligned vector of 2 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( u8vec3  ,
aligned_u8vec3  ,
4   
)

Default precision 8 bit unsigned integer aligned vector of 3 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( u8vec4  ,
aligned_u8vec4  ,
4   
)

Default precision 8 bit unsigned integer aligned vector of 4 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( u16vec1  ,
aligned_u16vec1  ,
2   
)

Default precision 16 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( u16vec2  ,
aligned_u16vec2  ,
4   
)

Default precision 16 bit unsigned integer aligned vector of 2 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( u16vec3  ,
aligned_u16vec3  ,
8   
)

Default precision 16 bit unsigned integer aligned vector of 3 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( u16vec4  ,
aligned_u16vec4  ,
8   
)

Default precision 16 bit unsigned integer aligned vector of 4 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( u32vec1  ,
aligned_u32vec1  ,
4   
)

Default precision 32 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( u32vec2  ,
aligned_u32vec2  ,
8   
)

Default precision 32 bit unsigned integer aligned vector of 2 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( u32vec3  ,
aligned_u32vec3  ,
16   
)

Default precision 32 bit unsigned integer aligned vector of 3 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( u32vec4  ,
aligned_u32vec4  ,
16   
)

Default precision 32 bit unsigned integer aligned vector of 4 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( u64vec1  ,
aligned_u64vec1  ,
8   
)

Default precision 64 bit unsigned integer aligned scalar type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( u64vec2  ,
aligned_u64vec2  ,
16   
)

Default precision 64 bit unsigned integer aligned vector of 2 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( u64vec3  ,
aligned_u64vec3  ,
32   
)

Default precision 64 bit unsigned integer aligned vector of 3 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( u64vec4  ,
aligned_u64vec4  ,
32   
)

Default precision 64 bit unsigned integer aligned vector of 4 components type.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( float32  ,
aligned_float32  ,
4   
)

32 bit single-precision floating-point aligned scalar.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( float64  ,
aligned_float64  ,
8   
)

64 bit double-precision floating-point aligned scalar.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( float32_t  ,
aligned_float32_t  ,
4   
)

32 bit single-precision floating-point aligned scalar.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( float64_t  ,
aligned_float64_t  ,
8   
)

64 bit double-precision floating-point aligned scalar.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( float32  ,
aligned_f32  ,
4   
)

32 bit single-precision floating-point aligned scalar.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( float64  ,
aligned_f64  ,
8   
)

64 bit double-precision floating-point aligned scalar.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( vec1  ,
aligned_vec1  ,
4   
)

Single-precision floating-point aligned vector of 1 component.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( vec2  ,
aligned_vec2  ,
8   
)

Single-precision floating-point aligned vector of 2 components.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( vec3  ,
aligned_vec3  ,
16   
)

Single-precision floating-point aligned vector of 3 components.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( vec4  ,
aligned_vec4  ,
16   
)

Single-precision floating-point aligned vector of 4 components.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( fvec1  ,
aligned_fvec1  ,
4   
)

Single-precision floating-point aligned vector of 1 component.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( fvec2  ,
aligned_fvec2  ,
8   
)

Single-precision floating-point aligned vector of 2 components.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( fvec3  ,
aligned_fvec3  ,
16   
)

Single-precision floating-point aligned vector of 3 components.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( fvec4  ,
aligned_fvec4  ,
16   
)

Single-precision floating-point aligned vector of 4 components.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f32vec1  ,
aligned_f32vec1  ,
4   
)

Single-precision floating-point aligned vector of 1 component.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f32vec2  ,
aligned_f32vec2  ,
8   
)

Single-precision floating-point aligned vector of 2 components.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f32vec3  ,
aligned_f32vec3  ,
16   
)

Single-precision floating-point aligned vector of 3 components.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f32vec4  ,
aligned_f32vec4  ,
16   
)

Single-precision floating-point aligned vector of 4 components.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( dvec1  ,
aligned_dvec1  ,
8   
)

Double-precision floating-point aligned vector of 1 component.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( dvec2  ,
aligned_dvec2  ,
16   
)

Double-precision floating-point aligned vector of 2 components.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( dvec3  ,
aligned_dvec3  ,
32   
)

Double-precision floating-point aligned vector of 3 components.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( dvec4  ,
aligned_dvec4  ,
32   
)

Double-precision floating-point aligned vector of 4 components.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f64vec1  ,
aligned_f64vec1  ,
8   
)

Double-precision floating-point aligned vector of 1 component.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f64vec2  ,
aligned_f64vec2  ,
16   
)

Double-precision floating-point aligned vector of 2 components.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f64vec3  ,
aligned_f64vec3  ,
32   
)

Double-precision floating-point aligned vector of 3 components.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f64vec4  ,
aligned_f64vec4  ,
32   
)

Double-precision floating-point aligned vector of 4 components.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mat2  ,
aligned_mat2  ,
16   
)

Single-precision floating-point aligned 1x1 matrix.

See also
GLM_GTX_type_aligned Single-precision floating-point aligned 2x2 matrix.
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mat3  ,
aligned_mat3  ,
16   
)

Single-precision floating-point aligned 3x3 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mat4  ,
aligned_mat4  ,
16   
)

Single-precision floating-point aligned 4x4 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mat2x2  ,
aligned_mat2x2  ,
16   
)

Single-precision floating-point aligned 1x1 matrix.

See also
GLM_GTX_type_aligned Single-precision floating-point aligned 2x2 matrix.
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mat3x3  ,
aligned_mat3x3  ,
16   
)

Single-precision floating-point aligned 3x3 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( mat4x4  ,
aligned_mat4x4  ,
16   
)

Single-precision floating-point aligned 4x4 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( fmat2x2  ,
aligned_fmat2  ,
16   
)

Single-precision floating-point aligned 1x1 matrix.

See also
GLM_GTX_type_aligned Single-precision floating-point aligned 2x2 matrix.
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( fmat3x3  ,
aligned_fmat3  ,
16   
)

Single-precision floating-point aligned 3x3 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( fmat4x4  ,
aligned_fmat4  ,
16   
)

Single-precision floating-point aligned 4x4 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( fmat2x2  ,
aligned_fmat2x2  ,
16   
)

Single-precision floating-point aligned 1x1 matrix.

See also
GLM_GTX_type_aligned Single-precision floating-point aligned 2x2 matrix.
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( fmat2x3  ,
aligned_fmat2x3  ,
16   
)

Single-precision floating-point aligned 2x3 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( fmat2x4  ,
aligned_fmat2x4  ,
16   
)

Single-precision floating-point aligned 2x4 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( fmat3x2  ,
aligned_fmat3x2  ,
16   
)

Single-precision floating-point aligned 3x2 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( fmat3x3  ,
aligned_fmat3x3  ,
16   
)

Single-precision floating-point aligned 3x3 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( fmat3x4  ,
aligned_fmat3x4  ,
16   
)

Single-precision floating-point aligned 3x4 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( fmat4x2  ,
aligned_fmat4x2  ,
16   
)

Single-precision floating-point aligned 4x2 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( fmat4x3  ,
aligned_fmat4x3  ,
16   
)

Single-precision floating-point aligned 4x3 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( fmat4x4  ,
aligned_fmat4x4  ,
16   
)

Single-precision floating-point aligned 4x4 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f32mat2x2  ,
aligned_f32mat2  ,
16   
)

Single-precision floating-point aligned 1x1 matrix.

See also
GLM_GTX_type_aligned Single-precision floating-point aligned 2x2 matrix.
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f32mat3x3  ,
aligned_f32mat3  ,
16   
)

Single-precision floating-point aligned 3x3 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f32mat4x4  ,
aligned_f32mat4  ,
16   
)

Single-precision floating-point aligned 4x4 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f32mat2x2  ,
aligned_f32mat2x2  ,
16   
)

Single-precision floating-point aligned 1x1 matrix.

See also
GLM_GTX_type_aligned Single-precision floating-point aligned 2x2 matrix.
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f32mat2x3  ,
aligned_f32mat2x3  ,
16   
)

Single-precision floating-point aligned 2x3 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f32mat2x4  ,
aligned_f32mat2x4  ,
16   
)

Single-precision floating-point aligned 2x4 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f32mat3x2  ,
aligned_f32mat3x2  ,
16   
)

Single-precision floating-point aligned 3x2 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f32mat3x3  ,
aligned_f32mat3x3  ,
16   
)

Single-precision floating-point aligned 3x3 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f32mat3x4  ,
aligned_f32mat3x4  ,
16   
)

Single-precision floating-point aligned 3x4 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f32mat4x2  ,
aligned_f32mat4x2  ,
16   
)

Single-precision floating-point aligned 4x2 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f32mat4x3  ,
aligned_f32mat4x3  ,
16   
)

Single-precision floating-point aligned 4x3 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f32mat4x4  ,
aligned_f32mat4x4  ,
16   
)

Single-precision floating-point aligned 4x4 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f64mat2x2  ,
aligned_f64mat2  ,
32   
)

Double-precision floating-point aligned 1x1 matrix.

See also
GLM_GTX_type_aligned Double-precision floating-point aligned 2x2 matrix.
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f64mat3x3  ,
aligned_f64mat3  ,
32   
)

Double-precision floating-point aligned 3x3 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f64mat4x4  ,
aligned_f64mat4  ,
32   
)

Double-precision floating-point aligned 4x4 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f64mat2x2  ,
aligned_f64mat2x2  ,
32   
)

Double-precision floating-point aligned 1x1 matrix.

See also
GLM_GTX_type_aligned Double-precision floating-point aligned 2x2 matrix.
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f64mat2x3  ,
aligned_f64mat2x3  ,
32   
)

Double-precision floating-point aligned 2x3 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f64mat2x4  ,
aligned_f64mat2x4  ,
32   
)

Double-precision floating-point aligned 2x4 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f64mat3x2  ,
aligned_f64mat3x2  ,
32   
)

Double-precision floating-point aligned 3x2 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f64mat3x3  ,
aligned_f64mat3x3  ,
32   
)

Double-precision floating-point aligned 3x3 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f64mat3x4  ,
aligned_f64mat3x4  ,
32   
)

Double-precision floating-point aligned 3x4 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f64mat4x2  ,
aligned_f64mat4x2  ,
32   
)

Double-precision floating-point aligned 4x2 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f64mat4x3  ,
aligned_f64mat4x3  ,
32   
)

Double-precision floating-point aligned 4x3 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f64mat4x4  ,
aligned_f64mat4x4  ,
32   
)

Double-precision floating-point aligned 4x4 matrix.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( quat  ,
aligned_quat  ,
16   
)

Single-precision floating-point aligned quaternion.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( fquat  ,
aligned_fquat  ,
16   
)

Single-precision floating-point aligned quaternion.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( dquat  ,
aligned_dquat  ,
32   
)

Double-precision floating-point aligned quaternion.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f32quat  ,
aligned_f32quat  ,
16   
)

Single-precision floating-point aligned quaternion.

See also
GLM_GTX_type_aligned
glm::GLM_ALIGNED_TYPEDEF ( f64quat  ,
aligned_f64quat  ,
32   
)

Double-precision floating-point aligned quaternion.

See also
GLM_GTX_type_aligned
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00239.html000066400000000000000000000165301356361734700216550ustar00rootroot00000000000000 0.9.7: GLM_GTX_vector_angle
Functions
GLM_GTX_vector_angle
GTX Extensions (Experimental)

Functions

template<typename vecType >
GLM_FUNC_DECL vecType::value_type angle (vecType const &x, vecType const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL T orientedAngle (tvec2< T, P > const &x, tvec2< T, P > const &y)
 
template<typename T , precision P>
GLM_FUNC_DECL T orientedAngle (tvec3< T, P > const &x, tvec3< T, P > const &y, tvec3< T, P > const &ref)
 

Detailed Description

Compute angle between vectors.

<glm/gtx/vector_angle.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL vecType::value_type glm::angle ( vecType const &  x,
vecType const &  y 
)

Returns the absolute angle between two vectors Parameters need to be normalized.

See also
GLM_GTX_vector_angle extension
GLM_FUNC_DECL T glm::orientedAngle ( tvec2< T, P > const &  x,
tvec2< T, P > const &  y 
)

Returns the oriented angle between two 2d vectors Parameters need to be normalized.

See also
GLM_GTX_vector_angle extension.
GLM_FUNC_DECL T glm::orientedAngle ( tvec3< T, P > const &  x,
tvec3< T, P > const &  y,
tvec3< T, P > const &  ref 
)

Returns the oriented angle between two 3d vectors based from a reference axis.

Parameters need to be normalized.

See also
GLM_GTX_vector_angle extension.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00240.html000066400000000000000000000311361356361734700216440ustar00rootroot00000000000000 0.9.7: GLM_GTX_vector_query
Functions
GLM_GTX_vector_query
GTX Extensions (Experimental)

Functions

template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL bool areCollinear (vecType< T, P > const &v0, vecType< T, P > const &v1, T const &epsilon)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL bool areOrthogonal (vecType< T, P > const &v0, vecType< T, P > const &v1, T const &epsilon)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL bool areOrthonormal (vecType< T, P > const &v0, vecType< T, P > const &v1, T const &epsilon)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL vecType< bool, P > isCompNull (vecType< T, P > const &v, T const &epsilon)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL bool isNormalized (vecType< T, P > const &v, T const &epsilon)
 
template<typename T , precision P, template< typename, precision > class vecType>
GLM_FUNC_DECL bool isNull (vecType< T, P > const &v, T const &epsilon)
 

Detailed Description

Query informations of vector types.

<glm/gtx/vector_query.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL bool glm::areCollinear ( vecType< T, P > const &  v0,
vecType< T, P > const &  v1,
T const &  epsilon 
)

Check whether two vectors are collinears.

See also
GLM_GTX_vector_query extensions.
GLM_FUNC_DECL bool glm::areOrthogonal ( vecType< T, P > const &  v0,
vecType< T, P > const &  v1,
T const &  epsilon 
)

Check whether two vectors are orthogonals.

See also
GLM_GTX_vector_query extensions.
GLM_FUNC_DECL bool glm::areOrthonormal ( vecType< T, P > const &  v0,
vecType< T, P > const &  v1,
T const &  epsilon 
)

Check whether two vectors are orthonormal.

See also
GLM_GTX_vector_query extensions.
GLM_FUNC_DECL vecType<bool, P> glm::isCompNull ( vecType< T, P > const &  v,
T const &  epsilon 
)

Check whether a each component of a vector is null.

See also
GLM_GTX_vector_query extensions.
GLM_FUNC_DECL bool glm::isNormalized ( vecType< T, P > const &  v,
T const &  epsilon 
)

Check whether a vector is normalized.

See also
GLM_GTX_vector_query extensions.
GLM_FUNC_DECL bool glm::isNull ( vecType< T, P > const &  v,
T const &  epsilon 
)

Check whether a vector is null.

See also
GLM_GTX_vector_query extensions.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/a00241.html000066400000000000000000000163061356361734700216470ustar00rootroot00000000000000 0.9.7: GLM_GTX_wrap
Functions
GLM_GTX_wrap
GTX Extensions (Experimental)

Functions

template<typename genType >
GLM_FUNC_DECL genType clamp (genType const &Texcoord)
 
template<typename genType >
GLM_FUNC_DECL genType mirrorClamp (genType const &Texcoord)
 
template<typename genType >
GLM_FUNC_DECL genType mirrorRepeat (genType const &Texcoord)
 
template<typename genType >
GLM_FUNC_DECL genType repeat (genType const &Texcoord)
 

Detailed Description

Wrapping mode of texture coordinates.

<glm/gtx/wrap.hpp> need to be included to use these functionalities.

Function Documentation

GLM_FUNC_DECL genType glm::clamp ( genType const &  Texcoord)

Simulate GL_CLAMP OpenGL wrap mode.

See also
GLM_GTX_wrap extension.
GLM_FUNC_DECL genType glm::mirrorClamp ( genType const &  Texcoord)

Simulate GL_MIRRORED_REPEAT OpenGL wrap mode.

See also
GLM_GTX_wrap extension.
GLM_FUNC_DECL genType glm::mirrorRepeat ( genType const &  Texcoord)

Simulate GL_MIRROR_REPEAT OpenGL wrap mode.

See also
GLM_GTX_wrap extension.
GLM_FUNC_DECL genType glm::repeat ( genType const &  Texcoord)

Simulate GL_REPEAT OpenGL wrap mode.

See also
GLM_GTX_wrap extension.
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/arrowdown.png000066400000000000000000000003661356361734700227010ustar00rootroot00000000000000PNG  IHDRɪ|IDATx!NA\ Um@`5i`h W7] b&ofdY4 c 3v=]\B I=BB;k WN@vy4]Y|M}]x6a }dׇY>||5?>|B"'IENDB`anbox-0.0~git20191115/external/glm/doc/api/arrowright.png000066400000000000000000000003451356361734700230440ustar00rootroot00000000000000PNG  IHDRɪ|IDATx=QFDk:FPK؃=V@ճ 8SHx0bnrr{򽿾$ TP XOd6"SOB(Q)+YĈ ҪR>Vtsm9(k-@ȧ-$ b [he Kp-l|CApRG'rͭaIENDB`anbox-0.0~git20191115/external/glm/doc/api/bc_s.png000066400000000000000000000012441356361734700215610ustar00rootroot00000000000000PNG  IHDR_ kIDATxkQϝ̤I&m&156*nąܸR,4 +H(Ub1J.(EmߏhJmKS'C(х & r3g(z&_9}՟@mu ` h`ԯ &~M4%3?h)\Yi>Jb @giވkg\轭EUv+?E"pB\Y&$vM+Dn)}:Xo 3گ'.f0u9Ljf6%3Gf#sm(,k*ʒJJˢou_~ r]%%mnu]zr5[ưXeI+ Kch` ^ލnIENDB`anbox-0.0~git20191115/external/glm/doc/api/closed.png000066400000000000000000000002041356361734700221170ustar00rootroot00000000000000PNG  IHDR KIDATxm @!Gk7-`&sts@k}2 P%_N .:0Dk›x" ֛)x5IENDB`anbox-0.0~git20191115/external/glm/doc/api/dir_1f76e953200861345293ade84ac7fb6c.html000066400000000000000000000050541356361734700261220ustar00rootroot00000000000000 0.9.7: G-Truc Directory Reference
G-Truc Directory Reference

Directories

directory  glm
 
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/dir_275089585c7fc1b5fd5d7d42c69cb1da.html000066400000000000000000000045431356361734700263520ustar00rootroot00000000000000 0.9.7: D: Directory Reference
D: Directory Reference

Directories

directory  Source
 
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/dir_577c788b67d63fb3b3b5752bd495d0f2.html000066400000000000000000000057021356361734700262150ustar00rootroot00000000000000 0.9.7: doc Directory Reference
doc Directory Reference

Files

file  man.doxy [code]
 
file  pages.doxy [code]
 
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/dir_5ce58d942b2d0776e17a9a58abc01e04.html000066400000000000000000000246541356361734700262600ustar00rootroot00000000000000 0.9.7: glm Directory Reference
glm Directory Reference

Directories

directory  detail
 
directory  gtc
 
directory  gtx
 

Files

file  common.hpp [code]
 
file  exponential.hpp [code]
 
file  ext.hpp [code]
 
file  fwd.hpp [code]
 
file  geometric.hpp [code]
 
file  glm.hpp [code]
 
file  integer.hpp [code]
 
file  mat2x2.hpp [code]
 
file  mat2x3.hpp [code]
 
file  mat2x4.hpp [code]
 
file  mat3x2.hpp [code]
 
file  mat3x3.hpp [code]
 
file  mat3x4.hpp [code]
 
file  mat4x2.hpp [code]
 
file  mat4x3.hpp [code]
 
file  mat4x4.hpp [code]
 
file  matrix.hpp [code]
 
file  packing.hpp [code]
 
file  trigonometric.hpp [code]
 
file  vec2.hpp [code]
 
file  vec3.hpp [code]
 
file  vec4.hpp [code]
 
file  vector_relational.hpp [code]
 
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/dir_7b98f88bffbed4b390b5f8f520d9c08e.html000066400000000000000000000047151356361734700265300ustar00rootroot00000000000000 0.9.7: Source Directory Reference
Source Directory Reference

Directories

directory  G-Truc
 
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/dir_8d176b5b7dd0ae42ea6876078f2bde49.html000066400000000000000000000506541356361734700263570ustar00rootroot00000000000000 0.9.7: gtx Directory Reference
gtx Directory Reference

Files

file  associated_min_max.hpp [code]
 
file  bit.hpp [code]
 
file  closest_point.hpp [code]
 
file  gtx/color_space.hpp [code]
 
file  color_space_YCoCg.hpp [code]
 
file  gtx/common.hpp [code]
 
file  compatibility.hpp [code]
 
file  component_wise.hpp [code]
 
file  dual_quaternion.hpp [code]
 
file  euler_angles.hpp [code]
 
file  extend.hpp [code]
 
file  extented_min_max.hpp [code]
 
file  fast_exponential.hpp [code]
 
file  fast_square_root.hpp [code]
 
file  fast_trigonometry.hpp [code]
 
file  gradient_paint.hpp [code]
 
file  handed_coordinate_space.hpp [code]
 
file  hash.hpp [code]
 
file  gtx/integer.hpp [code]
 
file  intersect.hpp [code]
 
file  io.hpp [code]
 
file  log_base.hpp [code]
 
file  matrix_cross_product.hpp [code]
 
file  matrix_decompose.hpp [code]
 
file  matrix_interpolation.hpp [code]
 
file  matrix_major_storage.hpp [code]
 
file  matrix_operation.hpp [code]
 
file  matrix_query.hpp [code]
 
file  matrix_transform_2d.hpp [code]
 
file  mixed_product.hpp [code]
 
file  norm.hpp [code]
 
file  normal.hpp [code]
 
file  normalize_dot.hpp [code]
 
file  number_precision.hpp [code]
 
file  optimum_pow.hpp [code]
 
file  orthonormalize.hpp [code]
 
file  perpendicular.hpp [code]
 
file  polar_coordinates.hpp [code]
 
file  projection.hpp [code]
 
file  gtx/quaternion.hpp [code]
 
file  range.hpp [code]
 
file  raw_data.hpp [code]
 
file  rotate_normalized_axis.hpp [code]
 
file  rotate_vector.hpp [code]
 
file  scalar_multiplication.hpp [code]
 
file  scalar_relational.hpp [code]
 
file  simd_mat4.hpp [code]
 
file  simd_quat.hpp [code]
 
file  simd_vec4.hpp [code]
 
file  spline.hpp [code]
 
file  std_based_type.hpp [code]
 
file  string_cast.hpp [code]
 
file  transform.hpp [code]
 
file  transform2.hpp [code]
 
file  type_aligned.hpp [code]
 
file  vector_angle.hpp [code]
 
file  vector_query.hpp [code]
 
file  wrap.hpp [code]
 
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/dir_9440d7c11b99dcd7e5d369c7cf9802fe.html000066400000000000000000000204761356361734700263700ustar00rootroot00000000000000 0.9.7: gtc Directory Reference
gtc Directory Reference

Files

file  bitfield.hpp [code]
 
file  gtc/color_space.hpp [code]
 
file  constants.hpp [code]
 
file  epsilon.hpp [code]
 
file  gtc/integer.hpp [code]
 
file  matrix_access.hpp [code]
 
file  matrix_integer.hpp [code]
 
file  matrix_inverse.hpp [code]
 
file  matrix_transform.hpp [code]
 
file  noise.hpp [code]
 
file  gtc/packing.hpp [code]
 
file  gtc/quaternion.hpp [code]
 
file  random.hpp [code]
 
file  reciprocal.hpp [code]
 
file  round.hpp [code]
 
file  type_precision.hpp [code]
 
file  type_ptr.hpp [code]
 
file  ulp.hpp [code]
 
file  vec1.hpp [code]
 
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/dir_e29b03b892e0e25920d021a614d4db9b.html000066400000000000000000000057151356361734700261610ustar00rootroot00000000000000 0.9.7: glm Directory Reference
glm Directory Reference

Directories

directory  doc
 
directory  glm
 
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/dir_e529a619cfdec1fa4c331fb042fd332f.html000066400000000000000000000373671356361734700264760ustar00rootroot00000000000000 0.9.7: detail Directory Reference
detail Directory Reference

Files

file  _features.hpp [code]
 
file  _fixes.hpp [code]
 
file  _noise.hpp [code]
 
file  _swizzle.hpp [code]
 
file  _swizzle_func.hpp [code]
 
file  _vectorize.hpp [code]
 
file  func_common.hpp [code]
 
file  func_exponential.hpp [code]
 
file  func_geometric.hpp [code]
 
file  func_integer.hpp [code]
 
file  func_matrix.hpp [code]
 
file  func_noise.hpp [code]
 
file  func_packing.hpp [code]
 
file  func_trigonometric.hpp [code]
 
file  func_vector_relational.hpp [code]
 
file  intrinsic_common.hpp [code]
 
file  intrinsic_exponential.hpp [code]
 
file  intrinsic_geometric.hpp [code]
 
file  intrinsic_integer.hpp [code]
 
file  intrinsic_matrix.hpp [code]
 
file  intrinsic_trigonometric.hpp [code]
 
file  intrinsic_vector_relational.hpp [code]
 
file  precision.hpp [code]
 
file  setup.hpp [code]
 
file  type_float.hpp [code]
 
file  type_gentype.hpp [code]
 
file  type_half.hpp [code]
 
file  type_int.hpp [code]
 
file  type_mat.hpp [code]
 
file  type_mat2x2.hpp [code]
 
file  type_mat2x3.hpp [code]
 
file  type_mat2x4.hpp [code]
 
file  type_mat3x2.hpp [code]
 
file  type_mat3x3.hpp [code]
 
file  type_mat3x4.hpp [code]
 
file  type_mat4x2.hpp [code]
 
file  type_mat4x3.hpp [code]
 
file  type_mat4x4.hpp [code]
 
file  type_vec.hpp [code]
 
file  type_vec1.hpp [code]
 
file  type_vec2.hpp [code]
 
file  type_vec3.hpp [code]
 
file  type_vec4.hpp [code]
 
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/doc.png000066400000000000000000000013521356361734700214200ustar00rootroot00000000000000PNG  IHDR}\IDATxMOS[sa?-XZ(PD4 AWbu`b 77wHFCԁ/`voAPqP@ 980 +y^Z9SW\83g3'Nçl_bpV"ֆXd]3xM[1W *PGz/Eg{ aoV:这1$RW,@56-,m/蹖 r5T*S(Vf89u գwa=<{ҡUr+dDF$`zNܮ0Q3~_^N=vpTLT}kqm<?ZhX_ݥ[) `ga_*2`'=F2EP l=8Wv%THqɿ<"GxH{#֫aJmKsVءM^ T ݛr߽m_?Wİ#uIENDB`anbox-0.0~git20191115/external/glm/doc/api/doxygen.css000066400000000000000000000343001356361734700223330ustar00rootroot00000000000000/* The standard CSS for doxygen */ body, table, div, p, dl { font-family: Lucida Grande, Calibri, Verdana; font-size: 14px; } body { margin:0px; padding:0px; background-color:#bf6000; background-repeat:no-repeat; background-position:center center; background-attachment:fixed; /* background-image: -moz-linear-gradient(center top, #FFFFFF 0%, #FFF8F0 5%, #FFEEDD 95%, #FFDDBB); background-image: -webkit-gradient(linear,center top,center bottom,from(#FFFFFF), color-stop(0.05,#FFF8F0), color-stop(0.05,#FFF8F0), color-stop(0.95,#FFEEDD), to(#FFDDBB)); */ min-height:1200px; overflow:auto; } p { background-color:#FFFFFF; } /* @group Heading Levels */ h1 { color:#FF8000; font-family: Lucida Grande, Cambria, Georgia; font-size: 24px; font-weight: bold; } h2 { color:#FF8000; font-family: Lucida Grande, Cambria, Georgia; font-size: 18px; font-weight: bold; } h3 { font-family: Lucida Grande, Cambria, Georgia; font-size: 14px; font-weight: bold; } dt { font-weight: bold; } div.multicol { -moz-column-gap: 1em; -webkit-column-gap: 1em; -moz-column-count: 3; -webkit-column-count: 3; } p.startli, p.startdd, p.starttd { margin-top: 2px; } p.endli { margin-bottom: 0px; } p.enddd { margin-bottom: 4px; } p.endtd { margin-bottom: 2px; } /* @end */ caption { font-weight: bold; } span.legend { font-size: 70%; text-align: center; } h3.version { font-size: 90%; text-align: center; } div.qindex, div.navtab{ background-color: #FFF8F0; border: 0px solid #FF8000; text-align: center; margin: 2px; padding: 2px; } div.qindex, div.navpath { width: 100%; line-height: 140%; } div.navtab { margin-right: 15px; } /* @group Link Styling */ a { color: #000000; font-weight: normal; /*text-decoration: none;*/ } .contents a:visited { color: #606060; } .contents{ background-color: #FFFFFF; margin:0px; margin-left:auto; margin-right:auto; padding-top:8px; padding-bottom:8px; padding-left:32px; padding-right:32px; width:936px; } div.textblock{ background-color: #FFFFFF; padding-top: 4px; padding-bottom: 4px; padding-left: 32px; padding-right: 32px; } a:hover { text-decoration: underline; } a.qindex { font-weight: bold; } a.qindexHL { font-weight: bold; background-color: #9CAFD4; color: #ffffff; border: 0px double #869DCA; } .contents a.qindexHL:visited { color: #ffffff; } a.el { font-weight: bold; } a.elRef { } a.code { color: #4665A2; } a.codeRef { color: #4665A2; } /* @end */ dl.el { margin-left: -1cm; } .fragment { font-family: monospace, consolas, "courier new"; font-size: 12px; } pre.fragment { border: 0px solid #FF8000; background-color: #FFF8F0; padding: 4px 6px; margin: 4px 8px 4px 2px; overflow: auto; word-wrap: break-word; line-height: 125%; } div.ah { background-color: black; font-weight: bold; color: #ffffff; margin-bottom: 3px; margin-top: 3px; padding: 0.2em; border: solid thin #333; border-radius: 0.5em; -webkit-border-radius: .5em; -moz-border-radius: .5em; box-shadow: 2px 2px 3px #999; -webkit-box-shadow: 2px 2px 3px #999; -moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px; background-image: -webkit-gradient(linear, left top, left bottom, from(#eee), to(#000),color-stop(0.3, #444)); background-image: -moz-linear-gradient(center top, #eee 0%, #444 40%, #000); } div.groupHeader { margin-left: 16px; margin-top: 12px; font-weight: bold; } div.groupText { margin-left: 16px; font-style: italic; } td.indexkey { font-weight: bold; border: 0px solid #C4CFE5; margin: 2px 0px 2px 0; padding: 4px 10px; } td.indexvalue { border: 0px solid #C4CFE5; padding: 2px 10px; margin: 2px 0px; } tr.memlist { background-color: #FFF8F0; } p.formulaDsp { text-align: center; } img.formulaDsp { } img.formulaInl { vertical-align: middle; } div.center { text-align: center; margin-top: 0px; margin-bottom: 0px; padding: 0px; } div.center img { border: 0px; } address.footer { margin-left:auto; margin-right:auto; width:1000px; text-align: right; padding-right: 12px; color: #FFEEDD; } img.footer { border: 0px; vertical-align: middle; } /* @group Code Colorization */ span.keyword { color: #008000 } span.keywordtype { color: #604020 } span.keywordflow { color: #e08000 } span.comment { color: #800000 } span.preprocessor { color: #806020 } span.stringliteral { color: #002080 } span.charliteral { color: #008080 } span.vhdldigit { color: #ff00ff } span.vhdlchar { color: #000000 } span.vhdlkeyword { color: #700070 } span.vhdllogic { color: #ff0000 } /* @end */ /* .search { color: #003399; font-weight: bold; } form.search { margin-bottom: 0px; margin-top: 0px; } input.search { font-size: 75%; color: #000080; font-weight: normal; background-color: #e8eef2; } */ td.tiny { font-size: 10px; } .dirtab { padding: 4px; border-collapse: collapse; border: 0px solid #A3B4D7; } th.dirtab { background: #EBEFF6; font-weight: bold; } hr { height: 0px; border: none; border-top: 0px solid #FF8000; } hr.footer { height: 1px; margin-left:auto; margin-right:auto; width:1000px; } /* @group Member Descriptions */ table.memberdecls { border-spacing: 0px; padding: 0px; } .mdescLeft, .mdescRight, .memItemLeft, .memItemRight, .memTemplItemLeft, .memTemplItemRight, .memTemplParams { font-family: monospace, consolas, "courier new"; font-size: 12px; background-color: #FFFCF8; border: none; margin: 4px; padding: 1px 0 0 8px; } .mdescLeft, .mdescRight { padding: 0px 8px 4px 8px; color: #000000; } .memItemLeft, .memItemRight, .memTemplParams { border-top: 4px solid #FFFFFF; } .memItemLeft, .memTemplItemLeft { white-space: nowrap; } .memTemplParams { color: #404040; white-space: nowrap; } /* @end */ /* @group Member Details */ /* Styles for detailed member documentation */ .memtemplate { color: #000000; font-weight: normal; margin-left: 9px; } .memnav { background-color: #000000; border: 0px solid #A3B4D7; text-align: center; margin: 2px; margin-right: 15px; padding: 2px; } .memitem { padding: 8px; margin-bottom: 10px; } .memname { font-family: monospace, consolas, "courier new"; font-weight: bold; font-size: 12px; white-space: nowrap; margin-left: 6px; } .memproto { border-top: 0px solid #FF8000; border-left: 0px solid #FF8000; border-right: 0px solid #FF8000; padding: 6px 0px 6px 0px; color: #000000; font-weight: bold; text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9); /* opera specific markup */ box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); border-top-right-radius: 8px; border-top-left-radius: 8px; /* firefox specific markup */ -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px; -moz-border-radius-topright: 8px; -moz-border-radius-topleft: 8px; /* webkit specific markup */ -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); -webkit-border-top-right-radius: 8px; -webkit-border-top-left-radius: 8px; background-repeat:repeat-x; background-color: #FFFFFF; background-image: -moz-linear-gradient(center top, #FFF8F0 0%, #FFFFFF 60%, #FFFFFF 95%, #FFFFFF); background-image: -webkit-gradient(linear,center top,center bottom,from(#FFF8F0), color-stop(0.2,#FFFFFF), color-stop(0.60,#FFFFFF), color-stop(0.95,#FFFFFF), to(#FFFFFF)); } .memdoc { /*font-family: Lucida Grande, Calibri, Verdana;*/ border-bottom: 0px solid #FF8000; border-left: 0px solid #FF8000; border-right: 0px solid #FF8000; padding: 2px 5px; background-color: #FFFFFF; border-top-width: 0; /* opera specific markup */ border-bottom-left-radius: 8px; border-bottom-right-radius: 8px; box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); /* firefox specific markup */ -moz-border-radius-bottomleft: 8px; -moz-border-radius-bottomright: 8px; -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px; background-image: -moz-linear-gradient(center top, #FFFFFF 0%, #FFFFFF 60%, #FFF8F0 90%, #FFEEDD); /* webkit specific markup */ -webkit-border-bottom-left-radius: 8px; -webkit-border-bottom-right-radius: 8px; -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); background-image: -webkit-gradient(linear,center top,center bottom,from(#FFFFFF), color-stop(0.6,#FFFFFF), color-stop(0.60,#FFFFFF), color-stop(0.90,#FFF8F0), to(#FFEEDD)); } .paramkey { text-align: right; } .paramtype { white-space: nowrap; } .paramname { color: #FF8000; white-space: nowrap; } .paramname em { font-style: normal; } .params, .retval, .exception, .tparams { border-spacing: 6px 2px; } .params .paramname, .retval .paramname { color: #FF8000; font-family: monospace, consolas, "courier new"; font-weight: bold; font-size: 12px; vertical-align: top; } .params .paramtype { font-style: italic; vertical-align: top; } .params .paramdir { vertical-align: top; } /* @end */ /* @group Directory (tree) */ /* for the tree view */ .ftvtree { /*font-family: Lucida Grande, Calibri, Verdana;*/ margin: 0px; } /* these are for tree view when used as main index */ .directory { font-weight: bold; margin: 5px; } .directory h3 { margin: 0px; margin-top: 1em; } /* The following two styles can be used to replace the root node title with an image of your choice. Simply uncomment the next two styles, specify the name of your image and be sure to set 'height' to the proper pixel height of your image. */ /* .directory h3.swap { height: 61px; background-repeat: no-repeat; background-image: url("yourimage.gif"); } .directory h3.swap span { display: none; } */ .directory > h3 { margin-top: 0; } .directory p { margin: 0px; white-space: nowrap; } .directory div { display: none; margin: 0px; } .directory img { vertical-align: -30%; } /* these are for tree view when not used as main index */ .directory-alt { font-size: 100%; font-weight: bold; } .directory-alt h3 { margin: 0px; margin-top: 1em; } .directory-alt > h3 { margin-top: 0; } .directory-alt p { margin: 0px; white-space: nowrap; } .directory-alt div { display: none; margin: 0px; } .directory-alt img { vertical-align: -30%; } /* @end */ div.dynheader { margin-top: 8px; } address { font-style: normal; color: #804000; } table.doxtable { border-collapse:collapse; } table.doxtable td, table.doxtable th { border: 0px solid #000000; padding: 3px 7px 2px; } table.doxtable th { background-color: #000000; color: #FFFFFF; font-size: 110%; padding-bottom: 4px; padding-top: 5px; text-align:left; } .tabsearch { top: 0px; left: 10px; height: 36px; /*background-image: url('tab_b.png');*/ z-index: 101; overflow: hidden; } .navpath ul { background-color: #FFEEDD; height:30px; line-height:30px; overflow:hidden; margin:0px; padding:0px; } .navpath li { list-style-type:none; float:left; padding-left:10px; padding-right:15px; /*background-image:url('bc_s.png');*/ background-repeat:no-repeat; background-position:right; } .navpath li.navelem a { height:32px; display:block; text-decoration: none; outline: none; } .navpath li.navelem a:hover { color:#FF8000; } .navpath li.footer { list-style-type:none; float:right; padding-left:10px; padding-right:15px; background-image:none; background-repeat:no-repeat; background-position:right; color:#FFEEDD; } div.summary { float: right; font-size: 12px; padding-right: 5px; width: 160px; text-align: right; } div.summary a { white-space: nowrap; } div.ingroups { padding-left: 5px; width: 50%; text-align: left; } div.ingroups a { white-space: nowrap; } div.header { background-color:#FFEEDD; background-image: -moz-linear-gradient(center top, #FFEEDD 0%, #FFEEDD 5%, #FFEEDD 80%, #FFFFFF); background-image: -webkit-gradient(linear,center top,center bottom,from(#FFEEDD), color-stop(0.05,#FFEEDD), color-stop(0.05,#FFEEDD), color-stop(0.80,#FFEEDD), to(#FFFFFF)); padding:0px; margin:0px; margin-left:auto; margin-right:auto; width:1000px; border-bottom: 0px solid #FFC080; } div.headertitle { margin: 0px; padding: 5px; padding-bottom:10px; padding-top:10px; } div.title { font-family: Lucida Grande, Cambria, Georgia; font-size: 24px; color: #FF7F00; } dl { padding: 0 0 0 10px; } dl.note, dl.warning, dl.attention, dl.pre, dl.post, dl.invariant, dl.deprecated, dl.todo, dl.test, dl.bug { border-color: #FF7F00; border-left:4px solid; padding: 0 0 0 6px; } dl.note { border-color: #FFDDBB; } dl.warning, dl.attention { border-color: #FF0000; } dl.pre, dl.post, dl.invariant { border-color: #00D000; } dl.deprecated { border-color: #505050; } dl.todo { border-color: #00C0E0; } dl.test { border-color: #3030E0; } dl.bug { border-color: #C08050; } #projectlogo { text-align: center; vertical-align: bottom; border-collapse: separate; } #projectlogo img { border: 0px none; } #projectname { /*font-family: Lucida Grande, Cambria, Georgia;*/ font-size: 24px; margin: 0px; padding: 0px; } #projectbrief { /*font-family: Lucida Grande, Cambria, Georgia;*/ font-size: 18px; margin: 0px; padding: 0px; } #projectnumber { /*font-family: Lucida Grande, Cambria, Georgia;*/ font-size: 14px; margin: 0px; padding: 0px; } #titlearea { padding: 0px; margin: 0px; width: 100%; border-bottom: 0px solid #FF8000; background-color:#FFFFFF; } #top { margin-left:auto; margin-right:auto; width:1000px; } anbox-0.0~git20191115/external/glm/doc/api/doxygen.png000066400000000000000000000073031356361734700223320ustar00rootroot00000000000000PNG  IHDRh ;IDATx]y\պ~45%TL QPE"q11]8aw*(*" z`8 m,p$%B(8k6lk[߷;?kPx'tz3_Q4g@m ci{~4:Hc'PP7^h zbcP 3}OqNkT(?d ~z<4ǡ؞vz٦Zd,6k]Fz< Zs?sU2Sw1c`[}%ѽ.Լ6BLZ!F8[ T #g]:vu?vbR?wgb$kF~;عƕX?lNʪ,HCgAzlӺg ]jM3oҳ'=$f}GS_co.ȹ:ds:1={9?zqviDp moaEqҵw}~{j{ºFNë[OqOSXO]>muľe5{Jկ(bl}`UyacCAklysA7oJ .Be. Z'-PyF.lp&.j7rez19HG%qz׈c_k_")HJn~֘5 q5#+9T Rܸrzϴ̝ =υ{áOfwg|/$;֙ƭ]W"/< DఽB}yIEc^=[VhM$l];Kr¦* t$]M;I1!M (f<5~z mՠ>کIz;u[ie^ӳNF6B\}7+,'a -yHY,^f~?Hc{Z+4\sٷnߣFơsغD?<vkx0MlذIxdEEAMg*YE7ۙ^[uv[wG=Edn׶l'pGk+C82 dz3H BS[wŘ ~xptmţiQ歉AB1fى4uI]6% 1t.NJphz̠R1"3-"&1[:N mW0_œ 6&)ꦬ}~{m]zMP~^:eQT_*798ˍ 347E¿uSɻU_ NWeNӏ|;;d"ȉ޵ﾮ"ĴMM+bY_E]PXKНIޥoE<_(EP|m,өZߺk,kM`jzeU t36˷r}w:Χ |TܵQK_pໃYd0!a –W$$/\$ 2mLH dHV,:RZJaz*>_NT(‚^SVFU8E܈nd;8\C]=m:bDd=ߞUU5O|]Pv\]2"y[yzg{Y{Ù5;w{N3nĨwKݭ29Id y)P8ũ@mPwjl,6 hWd ump.DžtwR xBδYcxg*vo y򑕓[?V0NO난~󒯷h#Hk8kӍ^q@]ӓ,56-κUn[>]@nϜp[6# 4tn:}8T9_Y$/GK(ђM`dѺ;OB &P{qhJ+閧l2M_1ӫtlya L^y.۽[ u/]iS}N>e1qjf&iT\=kϛX-.84V5u!TE .OH4zwTr. xքHHg hT$yqzp< qrwI]I鲘s":ՖbզL69VW<;3?M3AV#ޯKUr9!qtH+6V/TS^pqgLP'5E ޺ n"2|;W"֬TwtO' +W+Z̖<&nO,I06.Z.h*INڒOegBXZ9hDSʍ A/c`A"z|ş;H#|%OOD mcƤqmu&~n πZj =_n[nN$_bE)8?6l}#bW( d-p&a"9ņ$ڛA!;{~8ޣ10`#kuN Qbh 8Mawhq(bK Z%m֍(J)@> 7% {y ohf>{p.­_%glZ\B2B #Һphݚ[<#SpA7Ht4:|gtL*($Ʃ$;b`=MM5ǾHH.HeA5}rd)T};Q5i2O00;,냔}g]79_{C>h{.II?[Kswz6u;OJa˶zvd l舊yc'rTWӰL |ʽhB T'ò]K(=Kx  L,Pʵu׈ž1ݫ;pGDxZY kf676oھH~޸ 8Up6(? K+?%ݷ/19U?B)l @=ޞkIENDB`anbox-0.0~git20191115/external/glm/doc/api/dynsections.js000066400000000000000000000065361356361734700230560ustar00rootroot00000000000000function toggleVisibility(linkObj) { var base = $(linkObj).attr('id'); var summary = $('#'+base+'-summary'); var content = $('#'+base+'-content'); var trigger = $('#'+base+'-trigger'); var src=$(trigger).attr('src'); if (content.is(':visible')===true) { content.hide(); summary.show(); $(linkObj).addClass('closed').removeClass('opened'); $(trigger).attr('src',src.substring(0,src.length-8)+'closed.png'); } else { content.show(); summary.hide(); $(linkObj).removeClass('closed').addClass('opened'); $(trigger).attr('src',src.substring(0,src.length-10)+'open.png'); } return false; } function updateStripes() { $('table.directory tr'). removeClass('even').filter(':visible:even').addClass('even'); } function toggleLevel(level) { $('table.directory tr').each(function() { var l = this.id.split('_').length-1; var i = $('#img'+this.id.substring(3)); var a = $('#arr'+this.id.substring(3)); if (l 0.9.7: File List
File List
Here is a list of all documented files with brief descriptions:
 _features.hppOpenGL Mathematics (glm.g-truc.net)
 _fixes.hppOpenGL Mathematics (glm.g-truc.net)
 _noise.hppOpenGL Mathematics (glm.g-truc.net)
 _swizzle.hppOpenGL Mathematics (glm.g-truc.net)
 _swizzle_func.hppOpenGL Mathematics (glm.g-truc.net)
 _vectorize.hppOpenGL Mathematics (glm.g-truc.net)
 associated_min_max.hppOpenGL Mathematics (glm.g-truc.net)
 bit.hppOpenGL Mathematics (glm.g-truc.net)
 bitfield.hppOpenGL Mathematics (glm.g-truc.net)
 closest_point.hppOpenGL Mathematics (glm.g-truc.net)
 gtc/color_space.hppOpenGL Mathematics (glm.g-truc.net)
 gtx/color_space.hppOpenGL Mathematics (glm.g-truc.net)
 color_space_YCoCg.hppOpenGL Mathematics (glm.g-truc.net)
 common.hppOpenGL Mathematics (glm.g-truc.net)
 gtx/common.hppOpenGL Mathematics (glm.g-truc.net)
 compatibility.hppOpenGL Mathematics (glm.g-truc.net)
 component_wise.hppOpenGL Mathematics (glm.g-truc.net)
 constants.hppOpenGL Mathematics (glm.g-truc.net)
 dual_quaternion.hppOpenGL Mathematics (glm.g-truc.net)
 epsilon.hppOpenGL Mathematics (glm.g-truc.net)
 euler_angles.hppOpenGL Mathematics (glm.g-truc.net)
 exponential.hppOpenGL Mathematics (glm.g-truc.net)
 ext.hpp
 extend.hppOpenGL Mathematics (glm.g-truc.net)
 extented_min_max.hppOpenGL Mathematics (glm.g-truc.net)
 fast_exponential.hppOpenGL Mathematics (glm.g-truc.net)
 fast_square_root.hppOpenGL Mathematics (glm.g-truc.net)
 fast_trigonometry.hppOpenGL Mathematics (glm.g-truc.net)
 func_common.hppOpenGL Mathematics (glm.g-truc.net)
 func_exponential.hppOpenGL Mathematics (glm.g-truc.net)
 func_geometric.hppOpenGL Mathematics (glm.g-truc.net)
 func_integer.hppOpenGL Mathematics (glm.g-truc.net)
 func_matrix.hppOpenGL Mathematics (glm.g-truc.net)
 func_noise.hppOpenGL Mathematics (glm.g-truc.net)
 func_packing.hppOpenGL Mathematics (glm.g-truc.net)
 func_trigonometric.hppOpenGL Mathematics (glm.g-truc.net)
 func_vector_relational.hppOpenGL Mathematics (glm.g-truc.net)
 fwd.hppOpenGL Mathematics (glm.g-truc.net)
 geometric.hppOpenGL Mathematics (glm.g-truc.net)
 glm.hppOpenGL Mathematics (glm.g-truc.net)
 gradient_paint.hppOpenGL Mathematics (glm.g-truc.net)
 handed_coordinate_space.hppOpenGL Mathematics (glm.g-truc.net)
 hash.hppOpenGL Mathematics (glm.g-truc.net)
 gtc/integer.hppOpenGL Mathematics (glm.g-truc.net)
 gtx/integer.hppOpenGL Mathematics (glm.g-truc.net)
 integer.hppOpenGL Mathematics (glm.g-truc.net)
 intersect.hppOpenGL Mathematics (glm.g-truc.net)
 intrinsic_common.hppOpenGL Mathematics (glm.g-truc.net)
 intrinsic_exponential.hppOpenGL Mathematics (glm.g-truc.net)
 intrinsic_geometric.hppOpenGL Mathematics (glm.g-truc.net)
 intrinsic_integer.hppOpenGL Mathematics (glm.g-truc.net)
 intrinsic_matrix.hpp
 intrinsic_trigonometric.hppOpenGL Mathematics (glm.g-truc.net)
 intrinsic_vector_relational.hppOpenGL Mathematics (glm.g-truc.net)
 io.hppOpenGL Mathematics (glm.g-truc.net)
 log_base.hppOpenGL Mathematics (glm.g-truc.net)
 man.doxy
 mat2x2.hppOpenGL Mathematics (glm.g-truc.net)
 mat2x3.hppOpenGL Mathematics (glm.g-truc.net)
 mat2x4.hppOpenGL Mathematics (glm.g-truc.net)
 mat3x2.hppOpenGL Mathematics (glm.g-truc.net)
 mat3x3.hppOpenGL Mathematics (glm.g-truc.net)
 mat3x4.hppOpenGL Mathematics (glm.g-truc.net)
 mat4x2.hppOpenGL Mathematics (glm.g-truc.net)
 mat4x3.hpp
 mat4x4.hppOpenGL Mathematics (glm.g-truc.net)
 matrix.hppOpenGL Mathematics (glm.g-truc.net)
 matrix_access.hppOpenGL Mathematics (glm.g-truc.net)
 matrix_cross_product.hppOpenGL Mathematics (glm.g-truc.net)
 matrix_decompose.hppOpenGL Mathematics (glm.g-truc.net)
 matrix_integer.hppOpenGL Mathematics (glm.g-truc.net)
 matrix_interpolation.hppOpenGL Mathematics (glm.g-truc.net)
 matrix_inverse.hppOpenGL Mathematics (glm.g-truc.net)
 matrix_major_storage.hppOpenGL Mathematics (glm.g-truc.net)
 matrix_operation.hppOpenGL Mathematics (glm.g-truc.net)
 matrix_query.hppOpenGL Mathematics (glm.g-truc.net)
 matrix_transform.hppOpenGL Mathematics (glm.g-truc.net)
 matrix_transform_2d.hppOpenGL Mathematics (glm.g-truc.net)
 mixed_product.hppOpenGL Mathematics (glm.g-truc.net)
 noise.hppOpenGL Mathematics (glm.g-truc.net)
 norm.hppOpenGL Mathematics (glm.g-truc.net)
 normal.hppOpenGL Mathematics (glm.g-truc.net)
 normalize_dot.hppOpenGL Mathematics (glm.g-truc.net)
 number_precision.hppOpenGL Mathematics (glm.g-truc.net)
 optimum_pow.hppOpenGL Mathematics (glm.g-truc.net)
 orthonormalize.hppOpenGL Mathematics (glm.g-truc.net)
 gtc/packing.hppOpenGL Mathematics (glm.g-truc.net)
 packing.hppOpenGL Mathematics (glm.g-truc.net)
 pages.doxy
 perpendicular.hppOpenGL Mathematics (glm.g-truc.net)
 polar_coordinates.hppOpenGL Mathematics (glm.g-truc.net)
 precision.hppOpenGL Mathematics (glm.g-truc.net)
 projection.hppOpenGL Mathematics (glm.g-truc.net)
 gtc/quaternion.hppOpenGL Mathematics (glm.g-truc.net)
 gtx/quaternion.hppOpenGL Mathematics (glm.g-truc.net)
 random.hppOpenGL Mathematics (glm.g-truc.net)
 range.hppOpenGL Mathematics (glm.g-truc.net)
 raw_data.hppOpenGL Mathematics (glm.g-truc.net)
 reciprocal.hppOpenGL Mathematics (glm.g-truc.net)
 rotate_normalized_axis.hppOpenGL Mathematics (glm.g-truc.net)
 rotate_vector.hppOpenGL Mathematics (glm.g-truc.net)
 round.hppOpenGL Mathematics (glm.g-truc.net)
 scalar_multiplication.hppOpenGL Mathematics (glm.g-truc.net)
 scalar_relational.hppOpenGL Mathematics (glm.g-truc.net)
 setup.hppOpenGL Mathematics (glm.g-truc.net)
 simd_mat4.hppOpenGL Mathematics (glm.g-truc.net)
 simd_quat.hppOpenGL Mathematics (glm.g-truc.net)
 simd_vec4.hppOpenGL Mathematics (glm.g-truc.net)
 spline.hppOpenGL Mathematics (glm.g-truc.net)
 std_based_type.hppOpenGL Mathematics (glm.g-truc.net)
 string_cast.hppOpenGL Mathematics (glm.g-truc.net)
 transform.hppOpenGL Mathematics (glm.g-truc.net)
 transform2.hppOpenGL Mathematics (glm.g-truc.net)
 trigonometric.hppOpenGL Mathematics (glm.g-truc.net)
 type_aligned.hppOpenGL Mathematics (glm.g-truc.net)
 type_float.hppOpenGL Mathematics (glm.g-truc.net)
 type_gentype.hppOpenGL Mathematics (glm.g-truc.net)
 type_half.hppOpenGL Mathematics (glm.g-truc.net)
 type_int.hppOpenGL Mathematics (glm.g-truc.net)
 type_mat.hppOpenGL Mathematics (glm.g-truc.net)
 type_mat2x2.hppOpenGL Mathematics (glm.g-truc.net)
 type_mat2x3.hppOpenGL Mathematics (glm.g-truc.net)
 type_mat2x4.hppOpenGL Mathematics (glm.g-truc.net)
 type_mat3x2.hppOpenGL Mathematics (glm.g-truc.net)
 type_mat3x3.hppOpenGL Mathematics (glm.g-truc.net)
 type_mat3x4.hppOpenGL Mathematics (glm.g-truc.net)
 type_mat4x2.hppOpenGL Mathematics (glm.g-truc.net)
 type_mat4x3.hppOpenGL Mathematics (glm.g-truc.net)
 type_mat4x4.hppOpenGL Mathematics (glm.g-truc.net)
 type_precision.hppOpenGL Mathematics (glm.g-truc.net)
 type_ptr.hppOpenGL Mathematics (glm.g-truc.net)
 type_vec.hppOpenGL Mathematics (glm.g-truc.net)
 type_vec1.hppOpenGL Mathematics (glm.g-truc.net)
 type_vec2.hppOpenGL Mathematics (glm.g-truc.net)
 type_vec3.hppOpenGL Mathematics (glm.g-truc.net)
 type_vec4.hppOpenGL Mathematics (glm.g-truc.net)
 ulp.hppOpenGL Mathematics (glm.g-truc.net)
 vec1.hppOpenGL Mathematics (glm.g-truc.net)
 vec2.hppOpenGL Mathematics (glm.g-truc.net)
 vec3.hppOpenGL Mathematics (glm.g-truc.net)
 vec4.hppOpenGL Mathematics (glm.g-truc.net)
 vector_angle.hppOpenGL Mathematics (glm.g-truc.net)
 vector_query.hppOpenGL Mathematics (glm.g-truc.net)
 vector_relational.hppOpenGL Mathematics (glm.g-truc.net)
 wrap.hppOpenGL Mathematics (glm.g-truc.net)
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/folderclosed.png000066400000000000000000000011501356361734700233140ustar00rootroot00000000000000PNG  IHDR}\/IDATx]MO@~uؐlp]#]PYEC\9y`xC &=qvZv3m؃vLN}}ޝZA@n ONp xKxj8s _[D'yye+ 7#rNlk* 0Ь_d_(Öz=xvhzP-䍒̪u$\DJcB4.:Ϗ-}LE #gN;B6䬜@p&h>p9EEάʑ"un$R"?{<%PNt$߶+^<"2Dqq\ҙaA"ԵP}#Ez{.8i p(ADwDE߂z;Kק8t q:uvvݛvEn{MFXgfZ֝*ߩ:jYq#3SWr'  IENDB`anbox-0.0~git20191115/external/glm/doc/api/folderopen.png000066400000000000000000000011251356361734700230060ustar00rootroot00000000000000PNG  IHDR}\IDATx]?oP9i4i;iiZ7`b٬,HU'$*T]TDP6w};C; aӝߟjAInS}9Hӎ|? =_Ɗue*;YEsYBėsٌ ɫYq !Gǿv̇خ F}qb]70)d-}PfY{4@}2ԗNIǃc%UImcƝ>xt9$ OVE*Û#׈r@l$PrHaa dZrqIoT\,tj2FAxv-Lp׌p TI/ \sf; jViTo^cpb]€<a՜y9:+,E f6NEKU}^;nZuUS4 ѬbN.kjT% iV )GJ@TxIENDB`anbox-0.0~git20191115/external/glm/doc/api/index.html000066400000000000000000000112231356361734700221400ustar00rootroot00000000000000 0.9.7: OpenGL Mathematics
OpenGL Mathematics

OpenGL Mathematics (GLM) is a header only C++ mathematics library for graphics software based on the OpenGL Shading Language (GLSL) specification.

GLM provides classes and functions designed and implemented with the same naming conventions and functionalities than GLSL so that when a programmer knows GLSL, he knows GLM as well which makes it really easy to use.

This project isn't limited to GLSL features. An extension system, based on the GLSL extension conventions, provides extended capabilities: matrix transformations, quaternions, half-based types, random numbers, noise, etc...

This library works perfectly with OpenGL but it also ensures interoperability with other third party libraries and SDK. It is a good candidate for software rendering (raytracing / rasterisation), image processing, physic simulations and any development context that requires a simple and convenient mathematics library.

GLM is written in C++98 but can take advantage of C++11 when supported by the compiler. It is a platform independent library with no dependence and it officially supports the following compilers:

Note
The Doxygen-generated documentation will often state that a type or function is defined in a namespace that is a child of the glm namespace. Please ignore this; All publicly available types and functions can be accessed as a direct children of the glm namespace.

The source code is licenced under the Happy Bunny License (Modified MIT) and MIT license.

These pages are the API reference only. For more information about how to use GLM, please have a look at the manual.

Thanks for contributing to the project by submitting tickets for bug reports and feature requests. Any feedback is welcome at glm@g.nosp@m.-tru.nosp@m.c.net.

Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/logo.png000066400000000000000000000204051356361734700216130ustar00rootroot00000000000000PNG  IHDR+tEXtCreation TimeThu 9 Oct 2008 20:48:19 -0000kNtIME 5KK pHYsiTSgAMA a ]IDATx ՝U]}Ŝ0p1 *"CX@ O61&캉1k=]gxq r_}8sQU]S0L3=]fϧ{Wz0R:m0fa3İFbX #1,`0H a$0fa3İFbX #1,`0H a$0fa3İFbX #1,`0H a$0fa3İlhN،P-12P4VV%Mj{@z aU/=C+ax|h  ,G[ G --W?[T車'8 NtL:򌉺&<TvLA}lFAA+0F 1uTbfWE%tj&$^fT}L`"{&rUz] _T,pWN,yM%t *+=gU&qPⲥ؀IlrmP?@Z> @p` ITj -fZBZ jFX+U6,đ&2 ~ ]DCTx);O qd#B!!]p(ΟfQ[g g$3W((V =LB:4pp9pbUTDHV3QZڧ0kA3T^m};mjwܚpu}āe JwjFE؂aUrt Ss` u",`keTX^,{`{gyo;nPQtFb걓\``!Z<RCK1kpQ70 *t'axYǶTXC yD-t "w(NCz>6j"`V)`Vkg30n3 1F~Wn-`!>z 8m׊bmZ9Y٧:'#iP<\6=P zPzPK./=&&1>n&06=!Ion۶y[Mu;?ߩ%&sHD. yMBՐh`ypT=`f/Gy@Z>=Z[mzYYⶬF7SI1jĚ$fAYQbvTtF%SgdžrzL$rebM\82+c^Z6 [ m{ElZYdre-HԴuzDP%!4PuWo1px/:;]2[v'Oً? 3@Hz?NV>ʏ cT&a67{0' '>T k޿D~hjHI`w҈G EQH&O 8miTG~b\Up`[[Z&wN1a|@Bw(!1I6?{+ 8 jN_EtzN=3i KU) x|lS%ͯ5Rt/CV'6Շsv!D !᳏V wi, {t~' ulVx\ 'N!i˅Gavq%KSoBlՓlĵ!-yc ?>xuڜ8h)ڼ1$K(KsںUy*vI{^Nnls'ĴF!^[C|==Đ3q0FԦI["εο^{u[7JTnj |PT z.;|z[J!'~١$s#? 8m$K- , \l{kqy;j/oo">C۞<=-E bRDnVD2Oe)pI_&dq*wR)y m!ƻ8ʞlGJ,mn3%WdjIwm[8M`—@VIB4g&H׈=ˀuIarpPë>րKyy^%m>dPk"~4G]kmV?LyxGP_*n5!0Lg,v-uxJ& S23z.PYjw+XHBKc it^pxRs~L݋I*]=X4jao!'vF㕛##Inid|EVLxhM섀 qwpolas\ wՈ9?u}V?Ħ? Xp,ޞP{7*=I19ul{Csi&:Ϧ p0N1`"p*JP29:[kw/pǻ@-bFןsU NԴNs]3359=bt}G!r2{aN+qYD&/vƭx4RJ.bï"/P{zaHniDNw{F9/#5;;uN:7$EN[ P_nnF"wtB@/yȼpsrد)^+O*Drz8TZ'e X~nI14r$['?jO'T Hum'UVy3~yQ[]@>?p=@BLNc Oh~vݏ8"'w~g_l?dR YYbb~oNptmCt,X]뚐F\1_:mI8 byۖ9)$<ѵmc.n>G\ "l-n@gWMF/ۃlC*%$N֥%᳸b 8mIj i 9Xn\S BJJ:'^γ*@,TEff(SKMOp"lt&\Hd-I-um./<$-:5M@cgѴ=hzliBu_6{HDbGO  |m /0ov|\ V_imF#^V6jUF3%h2BG57߯jO_1X'Cc'hUM^z+1 2LdtD\ }eZ9[^D|=D OD7A/ E]!})"uiq3,/S')W3FG6b q7ME43FԤ<ӏY? 궒G\M;m{ 7居͐r"pwRy>[7 E糳-/:m;6E)%ⴅz`[Ag>y2~+= V}xVO-cs'w=?#reN[X>|ߍx͙ ݚA<3SEu53Z"Ά`^  x-<:9;z:E&X7P|eyae& {n⮕*2 vR/`5A<7׃`32W~lFQm֗6TGiګhEH6egǛ_ .J+wxV O gt?r^oe-?\ ,Y@ɇN[9duuej7ĵE^wNmרH;P]+M+pK-^׵X >EN[taD2'& ɹ#+F+`6>Bzj~SS /?[79iY ՈoؠMlcSMa?s7J2#Š{6t1?yXO\i$i+p^ë"jʽ yD\-VF c՛h`ޣ&ً-`ρ#DOߑA,^BxtkҺCO? \7n-`$0$dDyN[u.e%c$`aF;cę@ˣZH^ўve#nzŃ̾2px: X969gU/<0vO=/I&]-<OKhH\"'%n m8[X+ɷ)nn,0:޽/I;αE2a+=0**RVrsڵ[vTHStI,%M'` [ {5jokUHDCkiILB: }y* DR"d/ 3RuV­(mKR Sy% F+?u-Ԗ%Ԧ R:e01f>̿nn[=c!+>t+GSM#!S=l3 ćV{GV7Mm-Zq/=#9? cʽ̭҇qmi(8MNolR~*O<( *tBwPN%zoRTĖuG bޯ#`Աa4)n7yQl &i |% NHIxJ'#DaL/ylӱOal[g;zD˨a*kprUSnxUµ1tIC^ˈ=-3+t\fnDU+ {B`­&/ {CwJOp3a ,`۳Vk$$d&D0b gh=c3L7cP{%؇<,$RYy_c&]AZ#TRKOpKLTR{PptJ5,8wyB=*뀡s<,2NXmcN"6mWAT>`AǦ`߫`!W9h #I Yc NMEQ!w`wi^9CtM!CU䏠{ 8D'X'>2qC>Vq栊Zz[z"얣lZ_bb =*N$Nn椁&No5pc1`ae*¦z6LÄ )mw5Q0D>あbPg 1 hJrq 3bfJVV +Mc{-)ۂ>^oF;4@YE³"9CUdW`p,cBh<W;%:1宾TLS{5$zz#B2k$fl%OU5zjw0sjiAӭH^ftfRz[,D-PAZm Y ؝Xԅ؛fyD$h=7* ZiPpk6yoŀf@+A=zl$&ʯ3fa$0fa3İFbX #1,`0H a$0fa3İFbX #1,`0H a$0fa3İFbX #1,`0H a$0fa3İFbX #1,`0H a$0fa3?I[ IENDB`anbox-0.0~git20191115/external/glm/doc/api/modules.html000066400000000000000000000646401356361734700225140ustar00rootroot00000000000000 0.9.7: Modules
Modules
Here is a list of all modules:
[detail level 123]
 ▼GTC Extensions (Stable)Functions and types that the GLSL specification doesn't define, but useful to have for a C++ program
 GLM_GTC_bitfieldAllow to perform bit operations on integer values
 GLM_GTC_color_spaceAllow to perform bit operations on integer values
 GLM_GTC_constantsProvide a list of constants and precomputed useful values
 GLM_GTC_epsilonComparison functions for a user defined epsilon values
 GLM_GTC_integerAllow to perform bit operations on integer values
 GLM_GTC_matrix_accessDefines functions to access rows or columns of a matrix easily
 GLM_GTC_matrix_integerDefines a number of matrices with integer types
 GLM_GTC_matrix_inverseDefines additional matrix inverting functions
 GLM_GTC_matrix_transformDefines functions that generate common transformation matrices
 GLM_GTC_noiseDefines 2D, 3D and 4D procedural noise functions Based on the work of Stefan Gustavson and Ashima Arts on "webgl-noise": https://github.com/ashima/webgl-noise Following Stefan Gustavson's paper "Simplex noise demystified": http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf <glm/gtc/noise.hpp> need to be included to use these functionalities
 GLM_GTC_packingThis extension provides a set of function to convert vertors to packed formats
 GLM_GTC_quaternionDefines a templated quaternion type and several quaternion operations
 GLM_GTC_randomGenerate random number from various distribution methods
 GLM_GTC_reciprocalDefine secant, cosecant and cotangent functions
 GLM_GTC_roundRounding value to specific boundings
 GLM_GTC_type_precisionDefines specific C++-based precision types
 GLM_GTC_type_ptrHandles the interaction between pointers and vector, matrix types
 GLM_GTC_ulpAllow the measurement of the accuracy of a function against a reference implementation
 GLM_GTC_vec1Add vec1, ivec1, uvec1 and bvec1 types
 ▼GTX Extensions (Experimental)Functions and types that the GLSL specification doesn't define, but useful to have for a C++ program
 GLM_GTX_associated_min_maxMin and max functions that return associated values not the compared onces
 GLM_GTX_bitAllow to perform bit operations on integer values
 GLM_GTX_closest_pointFind the point on a straight line which is the closet of a point
 GLM_GTX_color_spaceRelated to RGB to HSV conversions and operations
 GLM_GTX_color_space_YCoCgRGB to YCoCg conversions and operations
 GLM_GTX_commonProvide functions to increase the compatibility with Cg and HLSL languages
 GLM_GTX_compatibilityProvide functions to increase the compatibility with Cg and HLSL languages
 GLM_GTX_component_wiseOperations between components of a type
 GLM_GTX_dual_quaternionDefines a templated dual-quaternion type and several dual-quaternion operations
 GLM_GTX_euler_anglesBuild matrices from Euler angles
 GLM_GTX_extendExtend a position from a source to a position at a defined length
 GLM_GTX_extented_min_maxMin and max functions for 3 to 4 parameters
 GLM_GTX_fast_exponentialFast but less accurate implementations of exponential based functions
 GLM_GTX_fast_square_rootFast but less accurate implementations of square root based functions
 GLM_GTX_fast_trigonometryFast but less accurate implementations of trigonometric functions
 GLM_GTX_gradient_paintFunctions that return the color of procedural gradient for specific coordinates
 GLM_GTX_handed_coordinate_spaceTo know if a set of three basis vectors defines a right or left-handed coordinate system
 GLM_GTX_hashAdd std::hash support for glm types
 GLM_GTX_integerAdd support for integer for core functions
 GLM_GTX_intersectAdd intersection functions
 GLM_GTX_ioStd::[w]ostream support for glm types
 GLM_GTX_log_baseLogarithm for any base
 GLM_GTX_matrix_cross_productBuild cross product matrices
 GLM_GTX_matrix_decomposeDecomposes a model matrix to translations, rotation and scale components
 GLM_GTX_matrix_interpolationAllows to directly interpolate two exiciting matrices
 GLM_GTX_matrix_major_storageBuild matrices with specific matrix order, row or column
 GLM_GTX_matrix_operationBuild diagonal matrices from vectors
 GLM_GTX_matrix_queryQuery to evaluate matrix properties
 GLM_GTX_matrix_transform_2dDefines functions that generate common 2d transformation matrices
 GLM_GTX_mixed_producteMixed product of 3 vectors
 GLM_GTX_normVarious ways to compute vector norms
 GLM_GTX_normalCompute the normal of a triangle
 GLM_GTX_normalize_dotDot product of vectors that need to be normalize with a single square root
 GLM_GTX_number_precisionDefined size types
 GLM_GTX_optimum_powInteger exponentiation of power functions
 GLM_GTX_orthonormalizeOrthonormalize matrices
 GLM_GTX_perpendicularPerpendicular of a vector from other one
 GLM_GTX_polar_coordinatesConversion from Euclidean space to polar space and revert
 GLM_GTX_projectionProjection of a vector to other one
 GLM_GTX_quaternionExtented quaternion types and functions
 GLM_GTX_rangeDefines begin and end for vectors and matrices
 GLM_GTX_raw_dataProjection of a vector to other one
 GLM_GTX_rotate_normalized_axisQuaternions and matrices rotations around normalized axis
 GLM_GTX_rotate_vectorFunction to directly rotate a vector
 GLM_GTX_scalar_relationalExtend a position from a source to a position at a defined length
 GLM_GTX_simd_mat4SIMD implementation of mat4 type
 GLM_GTX_simd_quatSIMD implementation of quat type
 GLM_GTX_simd_vec4SIMD implementation of vec4 type
 GLM_GTX_splineSpline functions
 GLM_GTX_std_based_typeAdds vector types based on STL value types
 GLM_GTX_string_castSetup strings for GLM type values
 GLM_GTX_transformAdd transformation matrices
 GLM_GTX_transform2Add extra transformation matrices
 GLM_GTX_type_alignedDefines aligned types
 GLM_GTX_vector_angleCompute angle between vectors
 GLM_GTX_vector_queryQuery informations of vector types
 GLM_GTX_wrapWrapping mode of texture coordinates
 ▼GLM CoreThe core of GLM, which implements exactly and only the GLSL specification to the degree possible
 Common functionsThese all operate component-wise
 Exponential functionsThese all operate component-wise
 Geometric functionsThese operate on vectors as vectors, not component-wise
 Integer functionsThese all operate component-wise
 Matrix functionsFor each of the following built-in matrix functions, there is both a single-precision floating point version, where all arguments and return values are single precision, and a double-precision floating version, where all arguments and return values are double precision
 Noise functionsNoise functions are stochastic functions that can be used to increase visual complexity
 Floating-Point Pack and Unpack FunctionsThese functions do not operate component-wise, rather as described in each case
 Angle and Trigonometry FunctionsFunction parameters specified as angle are assumed to be in units of radians
 Vector Relational FunctionsRelational and equality operators (<, <=, >, >=, ==, !=) are defined to operate on scalars and produce scalar Boolean results
 ▼TypesThe standard types defined by the specification
 Precision typesNon-GLSL types that are used to define precision-based types
 Precision typesNon-GLSL types that are used to define precision-based types
 Template typesThe generic template types used as the basis for the core types
Generated by   doxygen 1.8.10
anbox-0.0~git20191115/external/glm/doc/api/nav_f.png000066400000000000000000000002311356361734700217370ustar00rootroot00000000000000PNG  IHDR8`IDATxK Eі[BmkHprӼ.ꎤR6Z VIE5jliIJ0/u޿6sH yIENDB`anbox-0.0~git20191115/external/glm/doc/api/nav_g.png000066400000000000000000000001371356361734700217450ustar00rootroot00000000000000PNG  IHDR1&IDATx1 OHf_ ->~M iMS<IENDB`anbox-0.0~git20191115/external/glm/doc/api/nav_h.png000066400000000000000000000001421356361734700217420ustar00rootroot00000000000000PNG  IHDR ,@)IDATxA @BQۛТ) ) aܿoRlIENDB`anbox-0.0~git20191115/external/glm/doc/api/open.png000066400000000000000000000001731356361734700216140ustar00rootroot00000000000000PNG  IHDR BIDATx 0 ׬ՙ\39b!9{|I>$#ߴ8/z/>2[giU,/~\ 9ٸIENDB`anbox-0.0~git20191115/external/glm/doc/api/splitbar.png000066400000000000000000000004721356361734700224750ustar00rootroot00000000000000PNG  IHDRMIDATxݡJCa( %4 bȘͶ3v^EL ,b;{Ï/aYկq:\IIIIIIIIIIIIIIIIII-l揊_t/ϻYQVYivk_ۣI@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$C[V=[fIENDB`anbox-0.0~git20191115/external/glm/doc/api/sync_off.png000066400000000000000000000015251356361734700224630ustar00rootroot00000000000000PNG  IHDRw=IDATxKhTW1I&38MII3b$c I1V1-(T.* t!K[čf`l(l"Y6gT}sgܹ d{8?̝;u`:!FB?Űm'y>ѝlU_?]Y(N8f1qn-etm 0}b%׌=0?1s08;_ W|%\Zð >舽lnp.a{ )t; b n652?>Oдunm`׭ZWjC~>־0+ {{fMŕټ` ݛ%uA6,]kWu]7ihu1 l Ҷ̺:\cxhRQt$ fd<4B[fd7=.M9//O a},j?.5ښm?X2#d p(?c!a1ޗةܾ7dK:)3],H+ku<|`LhC7e םt H$^2%l.aeÉ|s }D^hz~Rá]|#@חև[k<|(*ݹdtM:,]' X_n| /cfOIENDB`anbox-0.0~git20191115/external/glm/doc/api/sync_on.png000066400000000000000000000015151356361734700223240ustar00rootroot00000000000000PNG  IHDRw=IDATx_HTY8i4-g6&kQ)!0URKڅ/PE>K-+K.YdEPaAZSܝ;3wgfsWK.Da'q_k DQCg 0Y:qZ)~L0HV z-C%g68%wUϿ }? ?3 K@h aaUe s~2&&B*Alji*˨,oƣT,d[3-*> LɟfkҠw#*AEjKUy>&{8m5Ki jjD*Nigw7DmzK۾M!k?o_lX#~XӑR*EՂדE;6e"Q(=Ezæ5Kؼָ_ 1zBJ X96jL^7{J1i@%8'7M_\Q#Uy Wo x8sv|Sn q_m >b[JX,4[T{Ratjjzz'ȶiIws KC^Y%6ꈺ]vhiWvh'̂|[^YrD=1&m8SxLU޲iEOsnxKN~jIENDB`anbox-0.0~git20191115/external/glm/doc/api/tab_h.png000066400000000000000000000002611356361734700217260ustar00rootroot00000000000000PNG  IHDR$[xIDATxM@~ΒEv"!d*rGq={SݧH uO^[_Xvyұ=VCff{R%_rug(?gh\i>|sIENDB`anbox-0.0~git20191115/external/glm/doc/api/tab_s.png000066400000000000000000000002701356361734700217410ustar00rootroot00000000000000PNG  IHDR$[IDATx݁ @@ѣ?Q"%If6[HQ<]dr s?O=w'F -~rÍ[芭m֬ݯнF)Y% `n,9B!ь\<#IENDB`anbox-0.0~git20191115/external/glm/doc/api/tabs.css000066400000000000000000000051731356361734700216150ustar00rootroot00000000000000.tabs, .tabs2, .tabs3 { background-image: -moz-linear-gradient(center top, #FFFFFF 0%, #FFFFFF 5%, #FFEEDD 95%, #FFEEDD); background-image: -webkit-gradient(linear,center top,center bottom,from(#FFFFFF), color-stop(0.05,#FFFFFF), color-stop(0.05,#FFFFFF), color-stop(0.95,#FFEEDD), to(#FFEEDD)); /*background-image: url('tab_b.png');*/ background-color:#FFF8F0; width: 100%; z-index: 101; font-size: 13px; } .tabs2 { font-size: 10px; } .tabs3 { font-size: 9px; } .tablist { margin: 0; padding: 0; display: table; } .tablist li { float: left; display: table-cell; background-image: -moz-linear-gradient(center top, #FFFFFF 0%, #FFFFFF 5%, #FFEEDD 95%, #FFEEDD); background-image: -webkit-gradient(linear,center top,center bottom,from(#FFFFFF), color-stop(0.05,#FFFFFF), color-stop(0.05,#FFFFFF), color-stop(0.95,#FFEEDD), to(#FFEEDD)); /*background-image: url('tab_b.png');*/ line-height: 36px; list-style: none; } .tablist a { display: block; padding: 0 20px; font-weight: bold; background-image: -moz-linear-gradient(center top, #FFFFFF 0%, #FFFFFF 5%, #FFEEDD 95%, #FFEEDD); background-image: -webkit-gradient(linear,center top,center bottom,from(#FFFFFF), color-stop(0.05,#FFFFFF), color-stop(0.05,#FFFFFF), color-stop(0.95,#FFEEDD), to(#FFEEDD)); /*background-image:url('tab_s.png');*/ background-repeat:no-repeat; background-position:right; color: #FF8000; /*text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9);*/ text-decoration: none; outline: none; } .tabs3 .tablist a { padding: 0 10px; } .tablist a:hover { background-image: -moz-linear-gradient(center top, #FFFFFF 0%, #FFFFFF 5%, #FFEEDD 95%, #FFEEDD); background-image: -webkit-gradient(linear,center top,center bottom,from(#FFFFFF), color-stop(0.05,#FFFFFF), color-stop(0.05,#FFFFFF), color-stop(0.95,#FFEEDD), to(#FFEEDD)); /*background-image: url('tab_h.png');*/ background-color:#FFFEFD; background-repeat:repeat-x; color: #FF8000; /*text-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0);*/ text-decoration:underline; } .tablist li.current a { background-image: -moz-linear-gradient(center top, #FFFFFF 0%, #FFFFFF 5%, #FFEEDD 95%, #FFEEDD); background-image: -webkit-gradient(linear,center top,center bottom,from(#FFFFFF), color-stop(0.05,#FFFFFF), color-stop(0.05,#FFFFFF), color-stop(0.95,#FFEEDD), to(#FFEEDD)); /*background-image: url('tab_a.png');*/ background-color:#FFFEFD; background-repeat:repeat-x; color: #FF8000; /*text-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0);*/ } anbox-0.0~git20191115/external/glm/doc/glm.docx000066400000000000000000042523131356361734700210430ustar00rootroot00000000000000PK!Wٓ[Content_Types].xml (UO0?,V`ax$btoPWڇŘe[_+Q9[AgXJeg{ao.wHw"No44#a4sb]BN^HG4K([y}PK!N _rels/.rels (j0 @ѽQN/c[ILj<]aGӓzsFu]U ^[x1xp f#I)ʃY*D i")c$qU~31jH[{=E~ f?3-޲]Tꓸ2j),l0/%b zʼn, /|f\Z?6!Y_o]APK!4 IDCword/_rels/document.xml.rels ([[o6~_`C` &ђ_d-ANOI/%2ԒTlPrbMCCb80i^ffF?KvtO'(DNy~> $ Qw5ܤRG0 WIouB*[PT/ !K) T1zycy<]o*5łfp3-0 I$9mIX^"R%$w;A̰ -^iu V"T 뾽B &c؃0,  JR(KI83UFNѿ..jƈD5-JVqRc?ZV͐kʩjeTd ,s4KIpXVL*4JeIoĜ ~f NBU< cB/{cnT0 ZbcyQêw)|wqȻ 2BI5OĔi|.fiU dٶ-MC%j !'E:VbWXrMX58ӆcUVLMnN%IvIn{ЩyF:5)F6)N|ْO= h嶕'lA$QS XMzIm,]MؓrB IqԎߥ+^>ˆ 2[Vq[ie5\@ZRƊ@wO7Pu Ru nߚ*l X)'7`COv"S`yɺ0`vkN 9&SonCv:5)&mO&pE!J`CgK) NNژ>'K`ɷtJo.hڶ9FB6Um"O GwdU%ɂH³6tBЅC0R6JD 牭̫SOabl>(UFS=|hk΀|+i|%F672bnƞ@=2Qmuzoy݀!!kww[-z%-tG#Ox`S[ؓK(B.R‚[A'\5B!FTR(:.FS&9;z[=ipf]JO̊PXP.) Q.rSO8`ʹVI5|ܥY(YΤ^D5)#;#O֩Ȳ!ۄu2|3k.ԭnY 5{YZ$ o6tLc)q|hz .w\Db׏'y]:u!E[#gKs&SD9tqő5<ЩHa5cETǞly[ t̕x g@|o ;`S*+vS \_StTOE=6<_AȧYsD5C;|[=_6~9X?糇霍Wn6򘝾 EN!BO'+XiLy4}~)}%jyqU,~8sXƏ}EJ!5M<B`gGY䞰 jk/l=AÜqUaHp/ք"Ӓu |yu3xk$ް^R֖oSm,&֠f$y\7&ْ N2%r '=uQoYVDB(Ɣ+Oyi7>dVlhͷqk/n˖YGnFɱsCe%'u 1#O8(z* ާ9$mt{9Kx2Ёy{mI#)XʐSSuԤISQ s(\j\U[9zg%}QZ3Ri`]h6x {JVC'k5OZ|)Mlͳ]Wg1I' wjߌi9GNO{Al;YO`k¹H>ภ?amL=EMX-vqUymW @(mT]1~HRI-(k-Ȉ_FFFd_#YNwBOa|ۭ^;!Y}/JK{>'x9"y8yi?C/ C?Mddx >'iTx~dgy񓗝 KKFA 7I:rޟq5~F2 I;[< FUJEnáwBofGcBMᑫ.{gťr 0uQ)ry}Qiє,siUcwE1n &O;d SpdA~^]0%g.@B|;4:G Z(Qξ!~9Ax(Z+t(A2$h7zOYI䑒OTkJTѦJl$A-XP'&OBD&q^- H-I?qbe-j] Byϲ?&Wu*xz*&@U gg/{^WȻmL\Š6^eI.Ҧ*hTMMs,8_D*َ#t~SZ!\O-dw8%itЁ6vT4rnTq\8|=\ }q4,2,'0c[0OQL-u[`$C9sy[)! סIlє-f$8݆{N+e{S F2ꤞ* ;TEt\Jk`cjCUp^N]@&ȳtĴToLId3lYdPKtEEHQ22@ zؓZ`/:Afxڟ腘8~!!`{>'p}vrG,yDDG GeX~n%4 {."ט/H3FA%[EzՉ8,D j%,k5VI oO * ]0̨3 2#4H2 Hy0$xćNmJ7]A"ԟ?q'^%~dF0dt|GJz?hGcqR!yd(,Oaxޑ01MoG0,שVdD"0`AbO#C hǎ0g塀w.fx;i tB93NҚF(y)z^y~Qx71'Eʝ+H `p 0Ftްll35w ϼ)2T@x "E'n*𤼕=xQDRaXMXDR C/"$=^GDGL,G3j ` n3b" l9lJ}륀tdA$c~dй2Кi3ѱ-]\?9{q퐋ru ۱ɉqOޑ/n?}vKk?W_Av~G_];77+I jb]~/|$&P+؎`A_ 6$¹A?;'ixJ_kb+vi\oW_o` ~^gm׈ 7Kl+Qh|"׫\_|tK>}h:Eüt@Zw6>+ZC~`Eo^|i}r{ ?A?_N yG b~+% bP<ЯLb;%P諒dAḣElATכ4uښh}uob"Oj?4҈2"c;D^;s.@Ax +K<rٮ@0pJ2q<W {<;u,8)oS %s{S.U4o(E(tT$'ED! T9'I hII<-&^e ?igC*l7CeU٘q.qldsXq/%SQmU(.wQQEtf``ŬKuSO0u4ͭwq/42".n]4epV ^ Gr4[2f j#UVg^Vucق@@8 ;ϟ"pht%pXjcŨHGƊ"+g WjuR"ZXt_֗|XƕLjI'7^Zv ?.fMZQk͒+4:+nRire ת6@H YK5 -~<'뺪)rY^#Le-n3> vV{[>ꪥV8q'3fBf9^7/e:lE8P_LrEIfJbE;qk_O0Pe`TY.ezDv.VޢXj6{+2oXr#`y7E9J0+?'7K%0kt ɳM5zU/ڼjafިU[{axr)NbA[:y~D}r2vK!.}0S( KBN eL'V7%nG]-?ӊ'&$(]\BmdӝbZ6y8OkJJeUy>~K{(8Z:Q2>:׎Kj]2Lv#HbkuoqZB~PM~mK8s^0a!aA qg=" dYG7z=Z7?հ R(DK agmxtQPwNd@I GV h础N} Y'0$~4T4M0C7@??=- H GgI=&usZȐ 7 &~}3kwqYi [huofWB?<&< w@P,m˸(3`ѬCAUb/FBN>mÿN,[ 4PFv0gdc"S4R{B纊* k<-Mt*L;.=rk`D2 A;r\y !APAQ];f'5 *ag?ĝUmzlyutQWES2$;``p 8˼d/Y mG]5vU_Gi"Y ֍A v!~i@(COA.,o<膩鯾b HN7D;"g{tv#gA3t_}#gf<:[׻0Avoc,詮a":z0yzRf={~Gw= FM{=CXŽͦ;ޱgut"v`~AfuHf }ǞY%C6%-v!aa2[={'K*"u!9S/Iʶ=sG*c۠#w\ _=U^>QxACzTJc3#O:{dYt'`zj\ )po{;T [K-:f2Q *=:)˦`?[<$̲qo;'[ixqO=xޱ'|t \^cjL~{Q84#x4JҜx@D7gm j0Y"^UOAլ1+k=bij#H]M g*Rn&~^wuhY#w~Ǫ++$AėՖ=@hfxxkhuATVWY QA7_"&5 Jɒ,Օ'~LF$} ( `ŴC[9)жr$[T0Q1}ƊqhEܠ$ MBK&)uAkR\n}F,vN g/ Uʡq2hI8xasK' S(6JL*)&+J\^؅ : xYFr߁Vd/Y,txJH4^UUr6p,I!Ci+ ^`TE %Y)e o}NFcFp+28Nx 3/FI d8 DGq(pц)%N_JiyK+6kfNrE'5 -.Y%υ]\44;k!#I0h[؊Ykd؎hHMzZemѵY"jšU[V&UKHU9 /ίm4Ef\w!M;ke;>(6HMQ"n4!뤵rߥOk)_wI迦,}T%|3YXsߞetMTYt4+Uɥ?"͠x#YS8 EN^Z,8^zOBNXݐz./1ċM'bLn]H잉r[Ouk#XF< qbk>4@ҢX,ϜZC5uYeMV”ǔyv$\My^ZC6V̪\j,\ؚJ~=!:& "/J# LT+\}L~A:6ZU65ZP>iOS7tTt{1XȼʍpE45RWE'=ַ^х%7Pddnna/ul|7 sZiwx`.z F,dxV-Ծ+ K-A@<2 {sE}pQBKke߿ӱߋzOmV&يlV+! +ņ!(o݀<2!ePxU󁏴ŌU824s-[^Xs=cm,1v JijОx픚l4AULAۜs+M u/)ro1*a=6hGuW")?_`…wdn+”9@,bQ #}ak͑_}dSV\Ro :qުJI (h}1YnϩB5ax d 'ۿD6*hn `mEh?{ѿ1֕XFWˋK*򂚗t|2hl֢ + Y&s^4'h`0AcyUt9U/(ˎԣ eNᕙΉ {^_mRt~fl`r0C:/ a@LThuYB ,E'"X;+ue*6(7r{ D(SO/ #J4B npۢ֗\J%W<_yoIzV][kd6ZۋLAL\_)hI'7^Z`z|q6 2: N,8%N)yZQ*bjgr-)Eכ)#k48e8k;VZ/vZTJ-~}ѨkJ^KF_Q|1T륩#)k=o\U0_O$B?W/+HZcC/<+ٵ}柂1Ǐ/zcU0t^+CHwﭬ=Cy5͑uǠ0?V;Koc(؈yEvlY=+ /-_$NɈ.W-ic/qs>.La%LKV8zZ>ǻ uCbeqq?ʈR-[sUg*TIW}s-4ͤVo ,hTIv6R;kiS\GAF-;6Yщk 6e(Oih7};YӰQ5Wm,3<4X=@eeDڅ5TvQjjJkr}=;P"P2@BQ s[2+*- j,E'6oa)63]TxA64`"D`p p->Jbߋmq5;܎`O1yӜ"3D"0ӗMq?peԾ4-yKށy.q4$[T%뺚;9uҜF(x龑u%H@,SLP ~-FD^iu?_hGDjl|dA}<*5e2̆?G58rd1i\u벋2|v5(?,<҅^9 ~/$x)'>=ʫ8I# fczevSn;15;4w2f.eխ,uɤw } [JX|j;eg709ͲQl3EZTSydEWnI`Ucs?IlDBE^,Ku0He{,n H ȹ,* Ԏx]u|ì!P$oAlNH1_?K WmޡmLYڒܚȸۦUI,RF~S/I:wn<& 6#p݈;ZDQ6蛌?mnw`|c؊*RiUYQa['8NpzC{VĢ90D5nZZMAV%;gv#G3,jTI 2T)aA>^q Wy׷L8Y#S/FL2$L2Ĥ&&z rE_VB%&E~,POO0'$lgy|# Z $ߙZ_3ٞs&;Y$c%2]6d`&i`xY0o/`&Ez;RxZdYaO@ϭ=o,ױTEԝ~"WdSSrՓ{}MTI|T1W6rsAtI{d45/͚]I46.m2%SRy*Vs4lҤMٍۤٝcj7q;a XGTd˴XD:I%g(:Y" )jG 0i];4VOp<5W+E~Ve@4GqDtd֖TuKڪ*Jy )]l#Ōx_@h KE&/J_ϑ:T퀦d #Šr¬ah+C;EEW݀*p"UX?XϺF#]CZq6,j>~tE4 P'b?y1DtPnaЋW:6ypr3p 5#ǥR0=Xu/hbZR:AS'Fl_ x$9?B|WK?hjW`' '"hn|ν2-X stP?Uވ_@.[Ժ85홠-7wqͭ| ~J%Lj'x@,]@ GWan:[ӫ6R65Uͥ9mI5ڕZUZQgLJWh֍wØܮDK4b$(Tob\)&j)3ޛ 5OKoUՊej^qMK0q>sa҆q,\xxC7x$>D=\gܟ@i}??B#Ls.@YJ=.{KP޸/lpno=:ޜqHuVE'|ా 3Ե!mgrCdo3~ ~yp >_y qrX ά6;dղR/wDA6+1ptb[|Pl^A"| qQnZr}\ L{ۿ~I26mDvt?[wL %jc4<}ajTq-Sf,t\CPzj*œ=v:;hŒCWkL,ĔWhpx̦o9|k@ڲD)8=`ؿ6~ͳV$ZG+*hBxe/VS8 |.5U'`Hn^Hx Qp`E!X9@į~<1Ŋw?E:.C_emBe35f~_逓:N@s_!0Ud-q_D1%ę]Jr}1B 8|SF-:c ƟW;Ķ~qjJ +1n(XL?p;22cMAR,u#J5;;(FuH1(F,̰ęQ^d--)_U׺Poo]'ML -W5 Qdj[xsc,js c?gM=m$b;&⃘za7-sBKrce^ͰSҀQA~(.&Ɍ,ɇ7k$y:7͞NYX=Lx~Cj_jX[vNb:a?U$5| nrETg 5ؼY7Lԥڒ!j|Щ1 D1MHð\AWwq00 kcd9aVS`lz5|rQdK~ s'̭\s4묣Nٗǯ#ݷw IU5KcG=\ 6:s (S&L0yFV;b؎ӖeQ̼O@c7@0rl cGRv_>V@8&wrhl~$O7ƘlZ,c "mS쳤֚ˋ֮~H&齬{tWN7x\w ݐ#$?HSo$%n>Iɻ>w]d J_w]%SRkHi"Iye*vBc{%YF@AS$yMlI':SJH] :Abm,bg&Y5$R,uty̿X(.fL=i-lU!.ܕ wN8#-Rp5)²N‹jX ψ$Y"'qG]G%\\ŤV2HݣRIK "G/Xnqjno|H3«[g(S\SY>fkAĩ<3iޒ-rTŞdmi1bujLX8ٛLɿ@ӛ%#ewNC^ 1J>l貉xݲZ|UmcyU^~caŮ-JjH`{ cerLO~WjPɲAܤ-(OФLα})S% 'cai]\JnīW2UΊhG_(8`=@Ym^4FC6վ𱶸è~ ,͇a7 P&Yk2 ^E]0hE_ :y%d=vD]ދLtKv#IGldvPQdtwlGV g.j1q)`|w]]7lF!YL*jX1[CUpdRc횟_wt7uv?=m/zdu0+:dNh q*# $->rtWA*8 ~^]Q^yM=+T>Utfз[<<،*I]-?4 }IKȽFy1i Zkf`'О퓷e)妌e9鄼튉L0-}Kȉv4[Iyۑn#?lO.#`SؕQm)I>uo`ڢ$'4xݖ-8 CZ8^.4s)y^7 yj Q>X5öHۚjז+*~ted8}CFw{/z Vޚ`4\0T*9 s Ç U1dY]Tss+_?^F20HDdZ춙NMIeti)# c! Kmm !*%#n<{P8m|{wԳC߀p.o|(sF?@|qOfDK$0ĔQoNIxһS'+ ?x q8!TdzڃzCb};fkQpbɆ-ꚄSa7WU֎ õȘ1xECjy#3OS9ip|܏~n"! + -I$lִJ.[5 2{E N$,$hפ+c`(MUl1ua ù8sP3.bwaWI ޼}Co8N&[L6\iPo+Ֆ6jXqK^l|b]aiQ-VvMʁP[^ғgܤQѐa-)Jw 0K,AjHc]|xӏ}?}xwYN]ّX'~xOܷ &xI ucuJZ !VH-d(DF%a#9<0T.nc٦3` BVbO*S9.JL_^rYg]RUbPW~fU# 뻱Q.vyB|%oy1m2S2TI=am'upj$z%(м}k&Aƽ j} *F\7jtt'sv#'D}*%l۰yXI䘗),&Af্/Ibpd=E@x)h @ifM$2 Ȟe8\gS 6<ɞ#DOȞu=Ż:Qf)uR!OVR(Ksm*4B^B"KNɳ)֫I i'b$Bu ۑV dHRR˟XQ 1 bJ&b$AwQӫk.JRvxY ,w,KFimbKN,UE4>aOjWS%~֏cs1NQOI#˦$,t1^6Ư2oc΃T\6Y4poHcE-4L=':X.8LDUG:K0R65w Psl=X_G߻jfXSus?-5X-‡{_θw>g-q3O5 bT5%~ |@8z lr#?c.k ^{4JݧEOV{ zƽ3~XJUw&nF}"&A4[,S-_sx$1tQd@/*zeH|Oț?u #g܏9 <wcfV ΢r@6Md/r}q/YUAq\0qx!yE*+T%ٴ'R*#1`Ō@ &7OewrgO6D/G5`WJt#NX ŤP^{ ){5"K*yPbgW,-$2flieMqYͨvR@ֈL%2!g=`Zx[%+,oij?NnUU- /bͣ07C i #f\p;NdpFp:^A;^iFΨ)!dR]G2tL-ZU 3ue1TȺꈢS*T;֖CQ_6Ґ7<x񣽉)Fqdlۂ`oR][%=j$[6>Ȃm$S5KEٴ2`uR&\Rٝ0؞/tëKn FYL la>fEI9/u#4 x"$4w%71G7ĔgaL5 +\iYDɻsO%K fu]5]A^)!l6DfkHma݆_nM `aF7\|u7Z>̇g%X5< <`o:bYj"fP]עޢ]H(l=P;>eJ#J 2u!;uب l\eʔ6o8*c?:"{ QB{J/lֻŞW%&(pmsyTQ96ղizRg+xHA]=D-b F5ڒcA sF~ХZRȺϣߖRXK{ޙvDanT!ȷ3`tZ2JrjؤEi(?hFS0I2[MK&At4`&&!%CfnmT5HK|\LKf[gov)_<O'JCͷ I6M&r'6/ɫWͮݚάf|*4MKEK*]=Puy,;ak#55 9?2 lდj'a2 ( V݀ XNGPFԵKr:?׃q֯ԎR)j8 gI)1o= z#wH; [ˋ9n2 $o"9N?/(QJB몮XcVC[+Vmt(|d-ܶ%  8 H UpCeorn:E5Jt({M QL˖uM*2Ī\|]!IsuT_BF3N_{{kB&K7~L i|P0OG{`L/*&&sW"OόIWwZ`%AQDkrZOdtQmѵi56=qX)!#GzwrVyUY0XS"}oXp] yb2x)֚YSv^.U|*+Ex̸_y77/\@ _dUE: /552]eWPVno"s`*!`md޼QgˍYL[p^zJ>&tƳ9$ q4fkuBK9iڐAIU]vq]Mnd}Rh/b,]yh$e%Y.јw (n DݱT]Cxw8*wE|":%hR7I^pLRQ R5_a\^fmEV74wi1j5\2L*.w3T8bwԘaqC#gr s],Ϲcp| :o툣#y| V] KԀY*7߲p~$ڮ,)'ْ$#4Tdd2?eImf:K( +d  -Ə|‡#^7Ĥ@qmfj6bYb 6(}trwA/9やd*Zkl 3)rQe7O\9M5+zG#o7J1/l\\=q4>ru>]~z{sCy̦)~';P2C^R6duQWK=fӟ_h;LԴ)K'K%+i!ڲAnP }2w=a!L^|e3X,@r`SiTG0˛:31qNuuUrΨ^(X%@;hϤɞc _J{sQ c=̿U(6s5 "ë?З6uTwMٖKKmI^bɋ"^d,hEXQ!c(%EdL* AԽD:&B, +I򮭸H*kH $3P,eii_&B1;] edxZ(Rr?- OïgFnM>&4Ǥ=R`*|,m+vm۪cu³s/ וJ]P(XY5 (RH9OdsLd-nЗ7LxuӆbYU1aؼ…|i2k<,QRbڅg>D5Rm1u{Z'݇#=qob~x%9+ 3+놫,3mb3)Pn0oĀb\b|H7,# 9cLrbKӔIwo_lOLZL,]tZڜDQ:/HQױuRm3##h1CK$ꎍOB끂n#W$ytcSTɡ@۪o \@IM[ ˊZ7ͽqA#WˣnQL +sѺ_ˆuuʦwaIr %лeKMK2RPu#ַ"G}(T*Lh%~[G0IBS{AB/wˠ=Gyo@JpB*<ދHĤd-E"H3)$TD6y1x$Y3iõ`OFʮ[*dPga2_.wlPNSI]~ȣ̽M"No%g:i={rj'bL!b i{1~xUzmr_PxY2K\ED" R1[(!+.ծC:1TCI&LqD䧲=!KfkJ&5f[jydp$]HR* S5v^(7txnͺ_<o%;Ժxz`TVtYVu%^CUQqr#tRtd,ՐDXDz?Ǭ׉:Kdu"P~D$wKFAvWZW1P Gddo|C",23}Eb=V5`j!wɮ}`pȺl5FJ.3vue^} ,m y~z{a]\3(v:I4:9emTbL4e]5ϛ ^rlE[JM4(M}I>c9he)!Ѱr>II% =UڟF uLiFjaCX&.f,(w@֚^><7+o%h86CEM*Xs5T$[K::̫5X΍Ǹ̄]?e]dQsd5+DtI}cJ%Q\T{@b&RK|rEqu2Ry c~\B(_3k2^Vo3tE/nu>?YŚe/ Yv K-/قé:tlߢ3pLΣ0 iNwY.7I822|\GHaB9E_8!f^Y.liASd5PN1"}iTYKLDWTϦ$O"4:lH EPh;YǂYt<ʹ,e|mFi[pLQIe3EATbtD$ WVT=vEF?yF)6[%b> 12-#)VZ?X9i>W H.涗uT+RڗMy7;Wqa"j"I;I~ 9g[Ÿl:ޝڭR""fQS"H`x5%"+Q5YMffY{#^O Cv3[iuv2(Z O+"7wxo2= t,e$!*φ73<< Y @6BՆQs԰pZ֨+ȡRI"WR@|㲪vAZq`z2R شRb1r}RZ=s+py)W)Q߀ɼ_Fak*dlYRu*d~(\QLpDK2 # L'5ۧXet`؇CtxylȂCAZ=1TըϋU"uhzz!z&_@@Mj3 <?JWСBJ=OaAKCU}/?szͺwbL̢u\TBB\S,XƤW)T[p%Cۡrf{(u)u~F)W'Z);hqML^p! uAe,熩a{s\#Y/Gd fIGa Φ&Y;J+p_Op(%jl폗,;z,DhƷ86R3|~E]lnF_jJu>kŞlROa& E,w_{g{ET8J)D8H+MhAVWZ~!Y?&񬜩>`h[l.yMR,XѠl1 UMŖ.W\-Wcn/R&% Vh'22~1#} 13=Rb]\PJ{ ]C`BDs>&n"g{ xMDֽ'f1YEM2[J{(0*U|G 2DghqRyQa5|ӱݐV:!˧9 |N!|@cq̲O}sb^r r!D3cdWشAXųx]Mqxan.*#E0TfщF'R56.PbtJ RޑE\Re=&2-"6#MV"7qD;$|Idk$,08Vs/衹{:̽k+}F.vvY9yaYM0UmEћSY mAҚKY Ay'8ӻ ySޘgZL@}2-AgR'jP0@ إ#y6 eHhr d~[u̓]m*`AF  aaĀ5RE`"Ȼ3*+pQZmShm|hxZUc n P侮x闬rtnh95d<&$OG3.,N:tIۤrNۂܠ1u++#q)4,iDDL17xOD?c>k&skK:dFR'[b~ZtRǭpG|'x|(.SHlU2~<$dmEDr ךL6J,جʼnvITA`:vԿDGO7;ި3'dv°1S:4BFE%VwA]qg:"QmgbxaǞ㫶Tm|H7//@$n̐KKqfH)eӦRVGA}?jAni0kw) L/u~ \XTR+ckf{9Q4c%'2?_|"$g{ب#+חTiZ7tNh>yZ,Po$bIJ˽ɟ^bX|!? L>L/1?7+3_^_MْI/GҍK&bGWnOSܱ率TˇXϳ0_rC:26ˤP/Dl>e7-[毟EF0`Oph?_Y$GīqF}%Lf3A񻱼b,. i_tZ/I*-˽!ޏ%Z|.?eh5Շ_9H>FVlɦN@1=vۭ$n5*9R+HLx!EmS]~D =SjT"4~|-U<ʅyVȔs>TSrQκƻ7i:^!gyJL^cL{󳳲m$OƷ7>4>AxvLWV1teͲ</ u-!ؒ͂4^?&Edkl[6i[V+`R bK_jly+ÖPcز/Fby-QDض<ÅƙL\Z 9 wt  `cAP_!h!u}r̀8,-@!b A["/6^%_?H\=2Fo 0 }ǿ3MKvF(CV'gn>,;֬/M^WFΉ9L zǙ98+_OȽ`ɐW qȟ-ònc̅byOR֘?пl,ė4,!bVw=Cb8 LJ}((_|5翨Aٷhmpz`-EZL"6KV'tNAP|I5: Qlb}ԫRs+ ѵ ?\5tx>SGUó wq\*fwSW<MuXfqH"wQ[AcEEH|IA՚XA{:3*bzXfr*wNWiWIJWAU* <W!I;Lc唩;Lf,R&Au baPc@tp"R#;/a%/U+8VykQ?U7_~ |%/]U4DT1̀1K34ʅlb<-8iewhx3zG$>hHS'Ƒ֏8DL? >BG>z P 4Kdz@Wv@mWD> 8ıbWIv-= swҧ$P\#ݎox?~oY8lGo14&h2-Z\=^, AC'xO̍U= ~kׇT˺-+~͍hZ ÖS@/ɗd2mEţ8\WU6(d.I"5[\|9Cˡ>0Zƍ M,FyM[6Q%(+ɥ_~;{ N|+obxgǙvW` <3;Zℎcbȴ*#FNYǕ4REk~gۚzVMOtT ;s5t͡rUͨG6Ncm夔eN*.`rzgԮH̭׻6Ema&Z9G5+F[!,A'mTR$ +d#cO%^ qdirkyp۸t}CO?lA g^A~Wh|"P3)6ܟaK pha QE>Yd`ә%7720;_Q\g+\H `72FKAi3a#S%K]|(5%lb\ ԞkPAthcz"cxCL?L_zj]m$l>pal V}zx $vv+ / N.: >~A10=H+94K*}]d>&w:<@kFZ9#Җs>'~f ٘&O}߃QrnpOJr i7}2 T9A0Qۍ:D2RQqꛎ¿%&ZM%d;vю`c9DIjjc"lBGLT^R{_RPMY7qAqiKr,'e\@Yi!s8%8 )'3hC4Vq{l ȅi`Ʈ;'DZeCN#.MDL8]t&hl,4MOkBtq"FrEq{hjd:,{W~`iz[?/l +xLY8(BT` -bt]G^}7+pP&S l,`Näĵ=f1绾%e:; H0`j^sMBm xHƦCEez D<ҥsl&L+!Hestk V e'X$ T6)44s*Bh{A.HW#]h'z;ִZt=U9ȼWjRRRatO}GVs\laƼŕ`.Bt; `1 sF8C'Ղu]bÀb^1D~fIUt}7Qv#sGP :3\pIP|a]6_kL USEaa^̺tcJkN׫!iYUPN&zgv 58ռX>i޷i|k7 0 R[Gr/@wV^id˚CÇ=#xYWl5%> pU X v=C=;vU`&/e5^1믋HLcTG3_S2klf3YRlPK7pBeؑ6',g^jNq-BU:tk( 2l,D崓xq2@zMT=,˶Zi Q@fp;O}CfɰȼdxǖAɟY￯ɘʖ%}ՐL ݚ:vTDŽcyma!6VdPZI!8+=B@7`@vKt <ײ4BY"_{M Jf)|xZ<&LC󼒷< }C rv4^RNXT6%a&)(e)&! }Ynh=65ڷR2C -# Ǚ}ڲ|rE*Wr Y(#y8$x JWCZGfv!?!__~Om`lƧ׽UQ` 1Cdf~>DuȾ%Ͱ?;54<簀ۀ|e eۏ?ٶԏɗwe୨5$ b\ 0ܼ.*7(Mn=C"3dc enYG7εz@3ہ딛aЄE /,A%jw$Ҁa^gd P{QYEX>l=V,+]RTyS?VV aƔ( bC`CY^#ZŐC OGP1T~? g4Ǹ] Mity d44($  leȽ~ :p@@ %k"m0cP؈P$ *J]?oP3 [.{.\J;1)~\*{U αyZ ~@$؎YRܦ`jA}IEuCQH瘁sPrKgan#tjx1hQ![I =o>(*&%F5}qx(G)׈0`UDcc󺨼|St2ӵ)(" l!{pXDl̀l|[z S*tK<vA&Es4!i"m>P Y^-F3+B1@L?.T˽,AӱyZɪB^I-U)~FN}9%ж Df:-0bS /=Ws.%U빡u[L2sVx)(]NqQ"9Μ,kS/ q@p %P*:״U|f!u~Zi"hֳ;. ]t \:W!UuRY[C%J H}n 3/ Su]w0ɍ8T= se|Ʊ,_]ɞ}i}*:4`~7WO6͍k-"7~ ( +v1"~o|}J&O:C2lǷd!~~E8 %#/$d ỻ7;㧵כn"5{o,ج4]<;|ZR)NYo8g?E7%7K**Nlx*ςIq3Ko-"Ou$()US;Y|˿y|]9%MkaaVo$e Ɋ&ڬ۫'a' i>|Lf0 Yh&v؏ɒ'чk'% G_2W,'~c dgY8& KݙoQʐn&Sz?IM22Y(=3h6qȯ-,,~خb^<lbgt" ܃!KEI+{܃9jV>?yfn Ʉȗ9~K\ T5fFt4ivP>| .l2ch86)Z%ҩ,T=bsY;d*쿱c 6[f) KJs_'>.|Mũ=?2\5%53 rSz4͸y`Z(@|Ϥ<I\.âq)#wJi@Jp+̝>qwn+B( xݑUadqpZg_x}gޙߩh.\. ej͠ 50Pe\#NaIxױ/|}R>j}wJ׋COh_;1mw)3BCQ(]p1><.FRy^pN8[>|0b/w! #^e<5IѢ:\% PP g=iB7":>>fyĥ&s ᕚ4z1hDbt[Jj,R! ]R+yS' 7v~Ϝ~$>镺 JlnU^xeH6`".,UI(1=j5ZKv *ɩWΣkou|/{.6H}YVu^,nH=q1Yr9X,OS,7MgTJ_s"ι:oY%/-ɝH1SuV:t3[jI=d"/#\q9/_̧^8C^P .jh{1"*n2Ix45{q5~VsMHL7X+Xns&gē+OkD&K',g8_dD)| ʑhX4T?µ W_їkz_INQkď_fvO 0<3ÑCdKu*;|4Rާh<ʭ:nlf/A4]HӸb.FfˠQX^2:khK@GfM]hwOĈDɜֈxϹ9݁n|],XRi..㼤Ra#mWfA㗾Ve&s cn*t_y^_-ɥ{i|\TE̟m\u My(`ش*KF(EhKs rBbmn`DEȤf!VA3wmr G{bl:*UZ@铹shl1 rNՄ,AcBbzB3=oQ@Mi}tׅZ]`$ZAƍ 皂[Rtܐ0|6"ڳcO~).(HQ8$tL凅I?&p"dy\Z ew&e{Oєc<[I ȉUQNqyv a籫4Р#ĕLWB}])dMSJ^rBvl"-egD "!s@ Q$?|JKY0C2KJ#T 9j Sw!>[ POVRe)3ImAjQoD%Fpg,D"ȑVƢ~P$ 2FmC$er!]LCUvmzzKG=x&ĝŏ+q]{R;%j˶ájhȍdwXcZsl̓rs؈CGxz0nSG:fJJ>gsk%Ӛ-Dpt) ^gA*5)Ze80}[# OMx;DdyϬF.F;_z"B J5ܯh5{Drė푻X,:̪ |`+?UwP^;#9CvTH0gt,?gOUs*q.UQX^g^:JZu"ڹEOکLgQ뚋\&$<]  r͝6# -\lArGۡCC/`zd'.4l:E:UYByvxZqQUqR+V[,JIK6FG c3קauPore2\ F,zՐ\u`@MW99nXshgicΎxx6]B|y #:NWT;z 'ye IdGW;/b'$ Lov0 &ǩ"鐄Gu%RӻJ"4Gt%wUGeUOqC]-Qb7Y3tn@[ƎwwTiW̏Ȇ6>W.m7b6>p!@~6&el̒evtlEw$O\ڞ3|vnJ9ӻPpb7d!\|U:D= =ID 2m,]N5[n^~ΊJt7C!ۢO/gH}A}, CJH -X]}zA&ק=t>mmu.`Z9#;$>ї]m':ړnhp + :48y8 lCrԧo`eG ďǁtL_}\r~a,>OSo9w8z3?-Jp؉~_ECN⸞>CdX w-wy~UlNΝPY\p/ Wm;Jgh}2 Rj(}H(0=ȥ7T^CPb'p0x+a߸ TnIWVt2[3 Y$er>RYJ%sј_ҵZ y w!um[U8k @9)^Sd:ޗsNum#nJ5Uggُ2OQH٨J9.ַ.Xk!_Icjv;W*5Wi#r/]TWxRzN \X;i Z֧5ky>oM' )3? w:8<:Z'eVm V- V- ft:$YN'14hөU5=ٿr3ax jwDx l"n΄:E;OLNp9 bW,˄=<<'4<y;0\7@" <\-琪몞+*٦:C$ɣ˳2X>"TǾnQs9$52?_QL? z WC'*m6g536yljqkګcTl t{j ]k~xvtQ.m~b,A>edO1Ұ5l';4%^$uj0H9Q%1Xh_c NˬnJ^&adl 0>/ b9g/{,CTͥ|lKƇC:׵539_d{ 'iT*QPS B_!O,=fX2+}`9xt_8?,qTtoCF+K{Un0С'Ar:Agݯ5;'}f[J*>O<4Y}Ai&kҙ rT=L!o[cWpJX _S O@?^JEx|*8( l6\(|,~0{ 'Lu(Pk!x4f~I^cǥjh Li_=BqUv8Wlbu[Ŗ *>w#ym*bsBGM`p>-8j v4`~|w=h-GQaw[GVzxlUs1c=[CVSs㇣Θ;lJn,R&UFq\F()dHt'mϕō+$-6VL'#)%X=&J6hR-lڧ|QoVsWүbBZxHGZ%{܎P5P`3h]OqCzf+YdM/05Vfj>i3:50s`ȆPXzRz6Ħw# dE\.Cn;kxdY.Fq(={:Yixo@'Ğ٪@z=/g ]@g~8RấQHԖݕc{X]nW)@ NOFN@=V-(s= rVQu}şy_{|%z腣60}Z T5l^"alȚ*[Ǜx̣%=:W72:\)D+C4dEKR帎2"q-9\DVEpJnQeUZq,uX*Wcz>g4*xrʍuwd| S~V>EI:Q+t(x_~9R>& }4[(kNcjw_*[4w4JJʅM|}(h?d&A_rΕ("s{7nɘ$@y6|cfZ"G Bּu&T68cto[Udwpδ%vgwi -в]JUH43U~Y*y%3ѱR5X9KC[Mn{Q^` llм"YmoQa1J`DޕPƯM, D3 #%HR%RILQ!NErp `kb"`P?m̀>%0c.qFxyܙ :dԶٓl(蝯ÕGhzFw:m< (\e2VYJHLX7ĥD+bf,qOe($A$l ʼn9[“n6>))! +,6qqRv5Rr.Ԭ ܬWU[5.5.٫*M{c'(Y'=Qd'i:e6)Qef]]p=3ϵzCw. 4Ө ,5Ha ?n3`;!gʟǫoїK?Z5Z..h6D֠8MJg@ `.^tOA+!ii'ݖj:ʈT>bs*l$-f4ۼO-%CSW/JCIyh@x_s7 Ff!>^1YPS3i`6a뎒:`48PZ9G2,,'yyI62:to\¥01\픻&Ց^oI- 4dM,ukLP?^k0[ |Q*nٮ4٫>cI#{e4Z,1!8;\ Md üZaip-~]_|8w}܉ҳx6.'鄲6ϧw|AnSir]`SG  Z4:4k8j+pNK;DpNwC>=_܁ ն@}kni!?(A!MhalAճJi Upc=ʫ>sZLO+r+ be~&\t$FyK>Q6 A\U@q.VY`R_(@f VY0::n ņ_} UUE#%ZtI.lM 7~Kz%SoQ̀o7,*&&y_c∣Ikh&ܟSNd;Y1SԪRuVOkl[e H<_x%xW7M$׳hӓ>œ($ %d)&B/ - 74L1x%JZz%4Np GS8W^r;y;_(IA^G4̸N,76cdxYU24@ @ȴ%iuT.9JBp3-l^/2՟F<*6f8 azLƺiJ6R8L|k _~1%vB(L>;R7pr\Y<.ӯzrs7Ľ4URcmdկT;'KZĤ"t4$D3?#^qtGF'Sϥo>4|B$BVɪ*/th=QNYCrOLR'=\E!qj]^߿~Y0OBu)Ң3 cVAT?07O6Ǭlc[Oq4Dˆ0׳[+?#bG71矔G"e[_KZP5vYZA7ƀ>\I*tHF觭\' )y=NJr6屏j~{HdE-i7VU{.4T21+)kS`OfiU OQ^Ѷ0ҺuЈp8EZHno_rXNFw!9F2^M}U:TuUmLuyIu4v!Bh"ѽa@i)DsM#%)5%FR=oȳ%5GALZ95߸>[p>we<q4Mq2مPCe۶2s@v[Qi KxFfGbls ˁvEOs UY8_~7y-2C{ vgԫϤb{ڵ:xp("Fg_Lc7DΣ(HޢLn»;Sea?ː'y&Pdvn_856`^ݪ$$1Rw0UD25,q}@7g./N̟I@Կ,orf69k`#M&W|c CHC_oCA~tӲß6ʂ=nil|!i V CΧp<:Tt9sǠ}Bbn^ΑwXQߌ}vkYLyC*blηG~h1d2& YvY벭6&n .H(q/+dYyy##;, wdvے\.7rrK1 b2]D=z;m#^7<։)]!v8#Y5[̿mv@x$A0Q^RxI>ϸ!u>ҷ7$) 떲#ئ,yЃ4p^-lSQt4RMiKj>x̗ޡ$kǡL *qsj.e_1s&3ǃ= +ZKU)mL9mm$N:Y^ë7#j{: 滎Wy %k;q3"lk&ā%5L eC*6@^Mz=:8,(F[Kˢ"Љ̐eJLv^1FhBuLe$qTࡂD+9$;? ۝YBl9}y$l|O){rޘk3zǚW_ͨ1ZnԊim^ȼ]#9u춸}K]FyWN %B ,BCc'/?rhrik:_+;/((@T]b~^=_#q`)O$ID3X 1h-h؄nSKT@F,/|%g˂6oݢOۍSTbw.fm x+zvvy+oi?1'"ss2<ΔqC{F%`l^۪C%*5= -J16.#WA,ڦ[CwWd)"? 1'pچ;?dŸ[ڣ>qNp6Wa:r?|3; %1W n y_5uu[t3`Oagmw_eg6GsC*.f0Өn@[&z/ 8`@&w~5"2$4EJb 3YU*$o DX-ѪJ섉L lUkZ:I~;uzQK&-P}de=sv\(#;3/Knuv Qm̀nڏB+s!:v *\M4i2)$ Sߕ))g<+]4L-Wț躪th9kHn@ne:^K%\wOE5 vf+yYrK5TͶ<,Xr0v=S9j#i7oA͝vl5z?`,!f]wD|q,Zb. c5z._pVubi}buON?N]hX.hE=;Ӌ Vni!fʔKAY=Oh8"-&1t :W5@?Ez-{z!+Sxi2Lc'9]- H(m@~H,t O-IP5<OckI: e!4,> = W|˒ˍ y͕\+\7 >k!}vLXl44=W;X<¾ sޠTP8ESܤHpb]fx3w)U^J*{ 'zDh]:fRg7IДey $n|Qv..sJڎ&z9-l+f[9^ ھϹ܀*4lg,1uSmS[OUhVë'z.9'݆u@N PWؒ4a~.I׌6F&6SAMm{.ezf4 r+Uy5 Q!ܜ#@,ȭx+R8emEt1M@Rr+!eQYGܲOXE 4;s̰&,Ŧ\B`adjL6{U/ud*t:˹tC; uhiCK[)]ZNBǣ@wB ̟= e0Ru]C u{0Z1Ԫ>Df1V u*dсAx~X<Țj{4b% rZ:vϚ攵B&ٽ\04\z,CoЛ_r>&{KDɺ&{GI$U]!^ʆa6XYNJSr.ZHِ1Dr H)$ΓUQ\(Ɠ]mHq $Q eW%@u }&?g7)_s \C+[/>R^*T.PG:;ͱC^ppMry?Yht>}I:++aFIä__TWj<+xO|YkQBB;k$fο,s88%( v]G Å'Sny AbgfzT̄b؝T䭶vTUN+訑W >7AIp2@aؐе.W}ZBr;9C *1D>4-1 ߑeOdVƒa@H1]x!Zjf :'ذ4ז1HE2[q4_t*[Mzx|~^hc#+8[:v =rh"/`7'W}~Ԅ!l0Dq[tt|ѥMlsYҎ'E:eRf8R~$`APx-y(kEU?V4:}M&)UYe 46 bj%JmþNJVMtbxE񜘌g7_*5N7TG꺊d}йX^^/րe8O";=Ʋg%QJMMkqf>46!q "Rɕxپ-`\?/ 0Jg09n³5x"$%|(T-];mwŬΞtVZ7~X]ևہ9y'؎ăr{,͉u*r՛<}N7iTY 4y7G#߀ G.9Zrq9:/`PS]iy\Co\y$nbwzoի+ְؽg6l2O!Eq)k~\3T3<0@]|<1< w]H!H\ kBj 2s~"h@}S{M퓢~7uhhia,cp?_W,:67+ܬU,|Uf'f MXR*7~k7tEW< b`ppё{R2vq@8:}h7 i.2#O!. lKZΗjwaI;Y'J)n=!FXUKmƏK^^*aGء-Y<.yAA% '#M7kgo8#ہ-첺iCo0( W0] Z:*TAb:€_aI4RNd—VK VK rBq.)k8/)\U P5իv?Ie/Ьa5q{ BaS 1/{ҧUpy!Ĵv]Bc`P`,Ioik4/IPY=cc =xX]+c1`ܶm~OD+]4~|t{!Yq=g~rQ=hΓTNz%l9*0 3 ~]Vf_*,JEJ> Hm{_1y%5[IJ6iB'`xװ^iXeZ汕 9i"_u4I <ܹ.|MyvA(/740hW o")WR|rKDS+ʻ\u׍ z$0 trqTwxNz'c.Dx% z7O yԒ91Ls ~e|&4`)R١ xeӮ~ 6)WMMm=fM=w_Guxq,>O)iQߒ`O<纻}Jtk4 p-'sg}p|ԷsUЗV2gxLnu$s)C]!Ol/KV4&$< ]qSOp=pU9<鎨^uҠ4%e DFlrՔ ~%=o7<+.) ڋz,DKw :E&QeO~$MÄ8js]~ά\iX}@ՠ ma&[-iQA^^M-}䂛:\Lv{eAD,^!i_ kzf |^|!e&،L SP!vly=(|i(|6:Ot&lVhK; JwLj Oig<,]NNd0RyND47JKhP<'[tBx(>2F#٦ ?+Y,xxx]'4ۋe:/_~iG?E(I ) :I7o? g3MX<~-~_?}c}^Xן}g~;}T[0E^Y=*e@q51K]uc=qn~[ٙs*펽Bޔ '%eL n 6noW^7Ty=Wؚa%ЀVs6!73=۞2wdy_s.ϱB/N8#8rfzuNuY^2zj.ǴEӜ0ƆےWewp΀PN794&)FBLSuV_y! ˰8yp > >1vֳ)]rq[Ր1C_/zBP@ Yra7t2ô4Guq 9fMLI"ZC=`rԹ݈w|A/o}JP,⩃Z锩/Rp-n>F ?WާprF8wJ؜fܥ&gܵ"5)͜JSx(2)ҰCS0 h naɭэb K?7&EAװbEk_Y<%0U7m᧌s4I7L'>G1|}fk/`t0G6Y"S_g/qN[ؖ YZP=WYZs~|IcĪ:xfXz )8c9Ճ*!_5Ug>7G(9 hS@q뚎70.V@g>Gg!4}ͳx!39h}~9/i /!_t*.E!DI>;/^KÁ9\X]+,Bp6M$R ³%E0` 狈a> z9H -HXl ]˴ltpXid)&oj0WC11{!SRu ZLzBf"lv)̈́,^]3ӱ5^ W7,PsZW{{]إ+4WSl{/W^Cúuvsoo`,ݪK̽ǭk]{y͵BXܻ{uGe*\{պ=sqܻإz=YׂFaq4zDXws4%q[񜾩mQtI.YbL4ScXuVxe@x#^o) wup:: @G = * ؀LAdyص%ĿԷe(e3lCy'J0$0.NB%%KX`MC? 9#E$ sXp,% :IٚzWwtKu(-pu *O^M(Og3KpV6_"l@H ؍Yb|? PͰ+AYy)"h\ xG,S[ bH mwLI]廠rTS،64J#Iլ?{9TNW^%yAOT|ikzYR- P-:mש<إ_!EWO%VSk7{Z=d4%Sl=m%X`k)smУb򼕚\AOQ S呢͈G}A  ['|*F|8#2u<LU:螉S!(Oėtk VCߍ =)zaRŜE}D#*E0d|Fs fŸ}4&͌mKtH l3XT,[|ih;}s,O82bfNct ]H2M`69H }Qj p/% H<܎=zZ#30ʓi4r>Kt=0nfcscYU0d5TԈ{B@1`H׆Z+-S-W\Sjn߹U59> զ*͂0y'wv8v&83|A1R12Z>$ g̶z8<ũ R 8YFl<gW mM*e9p_qx`Q`cn=cZ^?qbZ qRtz/f| L4= 4*GC{LYAd!!Nns!8A@uϥv@仕ej]s I^}z(=(Ω<hy%ЯayrNwɁ\n k[)vk_%5 C|'aƚVrI VЌg9YV[9YK wl˹i]F (DHO!8eaVE27НAM)WTF)]CRAolVPr?njZo2sBvTe`>r. HmTr4)&M6I22ZUK~svmsg D,el[<'!sU;~-3G#ؘdY^F]pbա{rҼչ@{k}F;vxx,r N? AU(+LRmvwp˸e_4OO?s=|E)~?-V{UBV\[sT*Ӊ$ܨuYznT3*g)uLϊdM3{V^4 _miUŖB/o ,ٯB% 9V4_u Òeo"܅"k(&VEK*^%m]:dn &e$EcuZ:s0D9ZIj >dRՌF␮P}~^:r;BCa%GcoI*ŎԿd8 kuGۮ繾v׎<憶 NJFdlZAw9,!ӄnr\4`)&Xoí܎Bb'R [H%ޫ((r>Olo:~`i,VX@` Uv(C1iR8 W)'"OQ@4Bܱxe3fKᣂ?-kbȓMu2J"vb\t*N.rN{072 7Jm)JH4Bn/.t6O|=Jh޽'eWз,i:&Ba9Ȋݷ/??+ bb㚘&xTKCF(k4p`e͸o4DxWDQݫR2aK<4ev"v=prWXK\@vbո3X@o@=nqyKڄ Rtii*E)J9H)(E)(E)J8E)JQ )JQ )JQRNQRt~BB+ ^y+<7U عSӒXby$ ~-333xIpMx뭍 Ӗǹ7#e^[;_X$)|x5`ox†MUx @s1|?Lh-^h0H_>AFGK]GP7& s8=L< +VhC"j#0ĉ5qS|l!6+~$"~bW&RZy]SpܣlXa~K1e^[i`;gvt^0><]cyoxI˗/?̇$RgPc ̸ցA .7rrrx]S07 ާ `K1 ƹtgM#}u7`k%P94A .AP4OLe[ "K ll -W7ƃr؞hB^`ɒj/E؀8Lu6qAj3&x[|B?E#^:>x:5t=A/ y7hT@Lsb<jVFFZjU W^X| KZ?mZ }& c,ÆbO39J.Hw sr䠛 C@u2n}{G2AٯXdvAL>1TV8bHЊDWύf]an~9X/02`pSWp31/sH749VpD>=fb]8hK{Q 0r}W`.{Y΋:tՓ(g]j۶mj֭z®@ӡ\ m Lqҗ{-vAG$Wdqa3 Rc,^#Ac[vXjz=7RR -p0^0}QcDcyLHK$ WzaÜnI^E~kz8ꢋN>0''*WU|o KD oٲE/xHݫ1ӉE LN>170_l@xd(5p}C,6E<9>YsH^q`mE Y 꽽\VΜc#reuB`QcTiCoܸQW"tt턴0s 5רXxg brAǍqȴ.xmJ% Ĝs_[pȐ!y 0lԮx}x0^QUv+14](.LwsL_EK2\h& Ii /VL|k03aƌԙd8Y;ld<,!Rzj `@lAg MEI_/2j!9Kԥ,A٢b:;YX\R,.x55MLRu1N')bTU0: o68TPHBX6q8,I5;/ G)HrF1t6FbcX!y&KFfVWb ;PaOxTPgt Op2RJw:Z0q=p@} &T1Gq .$!cȴP}].|0ZQZά0A2_.UsuرhyujM$0GG+񽏯V}v -1Li  b ?NƁ%?RA31l>)߿9rd4PIM+n0c Ҁ*{D ./%lp+`eKFhM0BtN\qZg!`0JS`#' `0Nj`̩1/C0dYlyQt y/4vz -N>/L xnF$l^Jg ,HXQѧf3z@**~ ^Sz۱Ԥex ]Z2Ns\2^XTdJ`^`pRfbk 'zwqcOylNp:D&g?glSDKBAbv  (%'M.>Q[z_qŷI~ޣ$RĽ2cE-Wxp_>j0S aÃA~_~3½}pcRx%}@袁"s.ʙ%uz%I6x7Ⳮ۷o رؙ!LR`Iwl` >dH n$PB}fh'>$JlXh.P}5jTD 2 Pȥ>:55WX>cK_@3\ pzEm2&$~|&;uxRx,lW"} mQ;,x0RE!VXT{[nђ:M7om,(dS2Z5#{pU#&IAb,&5j;.<p j sx -Uw `k3pAp+l*;lVss.ʬbѣ#􈹿x|!j.QM0@o;x5X8zΜ'?Kٽ%M1`]`H;L"ѨN>GzR<AZ$&.6JwALK i\>b3iR0k15po\!;}1#汛 m[+3˶;Fv+qPmXTgI `7P"|*gGg|.ZKZYAH`႘vO?5n̴/Ʉ:/SM7ឿ{뭪o瞁N.J'C4 Lr04=A=IF !d^=G`N.Vv=,@7u yΝ:SIv1Ws^&)7kx= Dl0N}v~Υ8츉L4$Xh"3N* /9a<,]\fΓKLő@?55 3*W摉8đE馛bU)CjXxr33 lyfnFO)+Q^c[C훊g1d>\(YЌcǘ0G;ނ^/?`O]VTOq2-'[ޔUp+Js'c"Lu]|mzvJR.6t,.c FtPBye5?DehUTTf@¨S1*YR7XTdZO\T 8WDpe+q7C1Mh˦sq, ,-XdK"'d8x?`p2ofBwZIJ0 b ,[Nŷvn>S[EkjԄ :L s k&,<͕A}  ݅]3s6=Y<$g?!LxϔOgm K=,/,dd'Hm`7$K%ڿ :%%x}yvaWxYI4>UV> 8cqgWf6]S5PEeϵ 2L1`l)(,֠NAI3Fa%lu nS@Tq,iN3giDytyT6?K~G+=zh~͡ӰU#C#āW|Z> ǀQ uSM e zn-ȯم ⹰ 0 0,li1Yp,bVo8;z=x_b(3.L `cMX8 8Cs.>ڄJ%uyL Sm eHH>Nd|fCx/0@{yFG/5Ev(̔"=}4Eu3v6  +`l|Nkpb񩊫Hr:PFyv\27~RA^fҶ*No*)Of&`ܥ]@[nQsbƢ1 #+e)0TE{Oa^ ; TŦ?)-9ILs-*>; g\ ;ݎ*!AIݹSDrѿ\ծ],@߹P9>EfNDjw _'PQ]{;!Er !|}!q**k3ϰW:@_k& A򧘞?;ˀP3y5Sfpft@|}`#8'a!I}Xڭq=oϫ6+FbZ|ǁ0BԒ>D4FLav A7|}U>b "bI+[DMvN'0tp:fb6%% `f~0* w01Ȩn;Bi䛠}e!V=)t9oy@r(51sF P25bs -匚Zs3o]A@*S:)jdµiu,Ԋ-} ` k'\0`& ؖqvGU* )y`\ޏOڢԎsP8X,O>|9 Xr.ylk Z(8o_U *K8՗O `C#  J AL;0% CCժUtjK@R|{nrIՊ1&$[o\)LjbnK a &tn`&n^ZLOk^;Xç;.kپ&gg, R-WK2r1\KdPʐy NM> [.[,^~es9 oߞdt S(d^.ཱྀ6@[I L`} )a)"m+m|8e+#=pM,g?',g!~C ]QdA%3D,60M>BkLt3m{lA hGsRZ{m5% `& /ig05DdZ2R5 qʘ=:Yߏ3M'tnLG;]U;  ՕMz+E΄,Ŵ |vQZKo_; 47Ukuo<7UMa`x5XcA[hFjQyIjv ;ovGu& }̍`icμ?뛅 q,,VL59X׵_;gWtM%_RbT{$KDH_ *&=9*k #.+t:dsqkC>b3bc;&1G5qاpo\,%oV(}+}%Km\LIZj=Eu3]e-:566bkhr`?Mr#xd^_׮לla9JʠMZ0/골A\Qs(Pst&UZ7ܠnWZ5}bGg3?`\[WǚPAv}8ȁ; `[u ӧl/{nI5YG W9yڞ$Zn1awķHvy,? Xe!ɪQ5DR} 3͇AR d!`诜o .J' C aB՞|l(f*I ՙTB]l:_gVS8|VXGzx߾y:bDyܑƙᷦAFU t@웩dJIķ֪FleMC)%3ԩѻ)y9`ǧayɴ"xK`Ldn{3հ4%#}mN 'lw\}u%Ut -/tD"Pq }'4ޭ[@C$HɃD}0)TC& Kv $9.7v&E;$ZɎ$ p6/z)IoBtwf ktƘʗ.HUxleR ? hLWٽu^gBHBeK8^7HKXФHtv8.x%L2qT]ק<)0g,Ƹgd|ލ\2:"/A!$0cIppA,@\,-  *\4u=|=0T1Pu&cpvrr|uDtKMŠbkB]IsR#"FfuK)QB-3Ĭ)cY:eN qy3< )Mp%i-F ,z֋D_3Khm`JQ5~h%(@ 9}y]NH}6bЋ sf+Y`@M7qyO!ȳg9g54+%M,6vﮦ6xIR7rLr$ `o$``=HD1t #0q;f͚j߾} V"mߎ07ڦ$Aad22SfPh%!U-DSʠr3O48g3"LI<`jM }G'fz:1vo>icK O 0',u3I3*v"!*zު{hsH N bTC3'(-S8Ζ3vm{d0_r`{6HN g* /R99NnIzH6v+i|ϭ9OڼB6Օ/L` 0_Jػ )\AؘҔ*=BJ(d*Ix$ 0'P$,]Oԗ 1y:783!,6 ܠ|$ 0kCJIΓ[L8$阩p{aU:Ș.*O`q}T6*NjD->6ߥ&OY/Al2.D71gG Kr 2mJCP7!Gڱ$`637KK `;]Ux^P{ZH=<`Qf:"$?XLtzTS8dT E|Xqlb d|]z,x &wzxVR `C E`Dޓ]ڕ҅!|'$`0M]A m4jAءGP܉C^Uŕ"M bI/g̾N)xbĘfe<1bKǿcrv1pW LtJ5B>cQ}d`Sڕ'ē4[JlA5\𒗸^c:9} (RD] uZ<0{a/=\/݋M%D->>&c%U %4yg9tg~8V2u0x<0sAؾKX=V&KFŞ7jzgUS2`"2(U e) l `c@{fŏ/0VnSw@4#9x OAGd*^!褙u}us|^-/7wީX :seY}]+ 5tgL w/P?:+U&07PaY650dT 5k.[ {*%9l}m4 7nYi} A zU bl<;$(U&؎g35af㼈&fWxh%Bm>-+τKhgҎ#qyWxfeI맺`sqh[~j]cYj槔. PJ*`6GNt0[ST6Glۢ~8O 0>C_)ѳ=n@GRPX]-#aa>t5mhT;13n6EÄ2 جxZJfd,`YxXa*lD\HSJғػ;4|WI;5ZK#n&: 9'5/0ZK&XazJ\(fP597x~w{t&13syU²mgP'L=gDy@B¯LAn`LDx0 q !F|w6\U[$Q]x֖N[bf^Xgkc6lx8JYZn2*Qcqs7ݻwڿq&صgPڳgOTChs|6#n6qy¾6D gTPƹԆ Lt tB%9tVxϗI?$VUFGb9 &He:Q%g@i'yAvؒWE.hu]?xg$0#LIi)1Œ&sH9QmW_U?_5-VfMU^=ݦ^k6>Y}*{ɜ<*VAbÔ("g 55$3Y%ljVؠqL;V 0v@HwO `GV A:pAqL51R1ORU? 0AmB2AԸnq0 $2XZ)`'9A=b 4Bg,lJ̾]j+y }ЄR~[n-OoXQ)JY9bLcȠ q}d3FB310˜vKJd8{c 0a0՜> M+,P>3#o)9}k(oWֈ,?J==({`j̥ `*a!Oi7g`V1@26ynN=4Hm*e{`G!y&t tH&bYFH׮((Nf,QIզ])5X$)Ӛ5]lJM:#74NA,gφ[g,%We&C-|qD ?i\m6Mjxй2Nl{/"%ܐ?f614LFX Ph6ldl3%| ne/>߳gJ_g4 WN/L8Ib0`ؗ\-jJ*clCP=H WĢηdX|q3 3Ki=l8xwX @B"pl]J2el]7 lG}ѣGm{%֙^zXQ%%=Ү78ןiR> K]cqBƿ@&jMYiI)+686Qޭ6߯7l赘B,f^́%T6a6f;e_Jγj]=*K19OmC0lt-LL!qzxEMj1càZ aW9KؽkpkRR*h,>t;lDZ}YG̗^ukH;; *Xi1sjg\ߓ14bk\7+.xa61MoDbLd5a' +-cDU>1pb@Rڊ` SI6 6qgщ. xi7-5!~L~:}VWx߮_:CĽ#CRΙ]mf#Ø9/i7W_~Yz! 58@ +0sy`oqR0QYca2kA=z/gb;hLfK& Tɴ@s&rj/ɣ%#挒8(hdʼn Q2iR`cw28gva6Bu 6@-Mv^oQO=f7 Erz3 4p3!{T}˜v_$ZlꫯDP=՟EM)N9šrLٯ2  ޽]#m֠GqsqWfՋ,v3aC\gSRH1L9U3%k&QFg-͗F1AhSlPG4Qu4PM6Uk:ӣ*V ڡІoJiߌ8'TsY*'9$%h8:78do ʖ1 7 = XnjQ7TQ?|G;Ll`z!h q" ܾ6mI&!sߥ= v&\)s)8-^AijxN.M Vrx_>Z-ɞ_p&H:ڶUyV&u׭QziklNo4 q70O! 5k9b]#<(ִ 0ae S: d_f%eoL L KU&7toINp\;mYj)'蓪 aK#GoaԸ:uN&_QQU.x5o*/Xg]zSmn;̒J!U*m2& ی S `i7A\ۗc>^Kk۽A^Y':jbٲs/Tg Q섊?ުn2&"͝ƀI,*H9e'%1Ҵ n7Y2=a3KD}1d;cf)R؄7k(8OIZzn]/HЯ@K3qD>m HƔ&SāqeM5 "C|T C`nZ-kRg'IDd{SNJ2(c I_F2#Ecsb@urndCDkS0~Y%) ^Q#.{.,>`瓾YZyl/b&[gxaZ04P{ +.d #GgJ29`L0 gL{S:(]H *cW$}U'JI[b2`#*() |Ҷ4a uR5nX>rTqj.̦ [b9lgVeڝE&OV^]6$A%dKw'D s\_s. e;B_]k&ѻK//φΚkZxHr,V6'RÆA{Um0};/%mS1φ@Ig7k0+P3;%~1V.čL*y'T1A=rdZEul=g_Շ} 4^& [i:8|b<*\im*sbϧErQĪ+BN0X]VFy葦5dhU+Xd< 6R;az Oؾԭ$3p0gC`: ^\;#6QD{ **+SNٔ䉀Z4 ~L'1SdH,$6j6u\$g5yd&9< o.z&Xk׫$N>/}ԌvrD0/o]JӉf7GK(C5MO1JL!GaL.7NJ`Ȯm+ f`}:nHꘀksMñ0|=J/~' Tzl29?#$96B^}t9'Fe4G&LԌ$y 5?}ql ʿ|Pm۽[;< "fެWQCœ~}:Ϗj#$lk.H 5z1cԯK[a~0s^)=XR(0Kc'bf#!&3T3H[D:Li.)sag>5:`?fEMgEVQzvYmAA 0]qMTCu47K& uWid)6*OR{te'?~d73w }F/,9 6y\(emQæ zi/:T(tx1>}VR8d,.i=*~JbC0QIT e9,4vlX;:Ǎՙ5u[5:N`+AKmWb%=Cj>Afdٛ(a("awlҾasԾ %pX/+?Ѳj֢E“< Hg$ &d4/ m|HCaXCz2S >[=rlJ8PƔA&|y`JS݋2:K҄7ӷKBr&4 #VP94vP`(ö}6C4 ҰSGO`0wy$C7mv%R$CtT|紼nQTzx EwFv⣑HZm)malg;UoAlw%@#XѹE @U6 Ȗ|]#kJ,ؕ5$Ҋ 4%0 6 `֊# M8 `3 սI7TƚH PAռNߣM1tLpc.Ka&cMQ{f&]``/YdWxMmJ#}A{QlUg;Yz>>-hFt:HM8"K8tR C=,k֨Ą ((i^dgbh) _́ ㊨-jR=nOF{R]YZL&O:I |ݬYيg?CwR|fH]P>HnL LSO;v*kvL @+wGW 0ww;$4r=lP9 10c!%L$51h"$HKro%;-XܠCkT;h8? eMN\ܯqN$t^an0)'+/751 cs^N邻e'R,SvM\3`qD)b+fp^&588MߧNP?QBis<_隰fau[/סּw,P;- 'җ:= 6'_qyJdvH$i`t@{;tPL RR!K-ZhuN[>N{}*n*`iI1 *{drƫgL8lk0s1 jr`H=$n$<kԤjUN|]=ymYkǑݧh4!k0H۷WO Q`DvXY9% UV: >3X*y;\YACڂ%mGo< ^VEl-mx@{ڳu $6OYp+L0b^Ԓݽ[텄;Lc[ hwȑj T-F"6^vzB ^,Lb9S$&١Br[Y=Wg9FWQJ3 ~Ea3_3`':A=G2n+4F+iFɓkB&yԄKExTܟ]=t씈߄rΑ{Xd-Xö,`! Ӈ Qcaۧzu#EK:x o #E&yf I1xS-_^^Jbqi &t7 0[T}]#R@}|CX>U%"Lx3\]$gd90{dRKP0Uc0'ȱ+!:QϻRCoV \)fk6Zx艡.x^@CLD[Na9B `IsH 4 ok.ط `Qt:4Z"k.|DEMU9q, `2W^;J+ fNq}f˜n`8RRu5=t `~[xm9>,G&x۷o֘J/dM(y|21)_mtˀ=ES(a9t&Ѱ#, `DrIrV:$S&Ki+P鄓Bo^d} *x/#AosEt! gHb8N6)W$Ɇ+ |Ls$PE>;DLs}>xAaT*P7TQX*MXS,Z;mTX!Jz(cH~*X|2x+,*am7*4!sYBmH3-0).,cZ68)ku(hii>'EO؊B&'xE/p^t{oUMMyRLa\bWp">?*aZP3XͅXO<4שϹc2A t>tT}ߙnMIP0N鸇Iq>R>áxzuURa+%j6+0ρ^I>곻(Q^Y}Ru$q5\@K@Zk >ItXk"M\ `UG۠j \G=vR0~6ư[0Vەxnj]!YES`2OF1ժ={3J|єtf 0櫏?"qiz۾CUʯ]RrE#}7d&/Fe4wO_GAz1߳&Z7LNhfqfxd4٠F3r|[}|A g[V@etr0LČ'Z^U:#iJ&5<#f3rf7sH_J{2K)1#UF0\:|%&M3ġ% ڵS[>H;0'[w{NK4tK_1c~ضjzn9 M wԄҒBwEϳxI\Gd ./^݅]4l5&74g2* i& )<.y.,\vT,N0pqTj>6GJ(E~sq{+1a1hwx}4 5M[RFڟػWXpsIrn{,HN-oF oj7^zIB_V9|2jPYPYjȑjh/l括#V\a)e9}z8N8guP!)z< eɞ/P(}%>(Rܱ726g Qgy%uB;; ƥV6_?I#Ħ6aHʬ2]S<&l4$-ՆƍUyLpCQi&ow hءw0;$T %,ִD5J ͸Ʃ}%hJڒWB.i{u+ )0V'\^71oaI Pu1Sz&g.֐[^۹RlKf"?Aox!*3At`~ݰh&Ş=U_x\Sv0%D9F{G9iޓ6ȨlZr|$S(}}aNf缾cؒ?YH5ܝb᳃ T9O,)ҤK: fmF1ZC~5H)tmýR<+)J8&l^'}6:x-N( sc̢%%DYV@8T@{/ UMJؿIil2(Cn2u'ǡ}DGyFFxGU ]_DW?μdHpJxOOgVѲ3ks# 'uQҋLvb&;걨uB;V)`V<`F%S{c-aTv:w^PәY[!ZW9m:  .uyqg6bv$$&,ffg;srh}[^=ݸ[@`V)װ4E&ҭ@LF 5*O#p9’V.ǖJQc\{0߃M8#"#{)Nҙ@y)1k6kuX+%PTgn7-3`),B|U,_YRkG1)Վ.f2rҤd^B/B?\3Jg0\/ -HiyawOw,W!6ly^0&%U4YJ ldƩ=K2Gp-\g?X$:jLQRE½HyyxyavSӶ}Xy0g^^ 0VikKjnm[ nd10Y͚55kR/xHׁa# Z%})U}QsXdm6OG@fPգ8a,)y)LR}eo|P5~Eh0Egg %Xj-q ೮>fX#! =gFP˘W:!iAcK 1+F@f0L]&Z=ZX ,%xNƆcdGgL K7-i&Cz VmIOu颞Ϣe4.=zv/H8 `Q4bۯ.v}M xo?@=.`0 &:uvݸg  `PJ0+ tS)QY,ߑ#!VN>H!OP|:H`5'SC~[J#܎)ŴyU+`$oĆJG/(.?@sp,-G `J^aJܣ6o1"9C;.>e zݩj`'HeS>ڮ]BWHLZѐ?"%ITCU%s|q_kC*FVKD1T)00p^64$QԲVaf>xZ {#0Zf%7|l"Z& f8[ÎbE7.%a 5 0r#~# |\@v^J`Fy `3Lڎ$iO`y詧B7NS6AH^ж={i,5lM8o P`RISY v0: :`ubP jJ#&b {6jYS4DB_WxLZ2? :ԾXZT )\L@3䂆]’~۱c6ײc OR` zNf^`s%*m^2єuU ъ0oDEu&H( 7bQc|ehmjԾB/3=KI`WZR'6ʞ„^pOIXQs!1'3i@ +k^zIhPWOZ0;KC^lS&ONHXRzZ"oage(|5ԸPX 1̱% վzqcUѳUH9ˑ&u6$ܤJkh,y?s0v%BQ> E*HNi'0UT9O'HEF׬]D/"{´iV @ .hmqH2;A@)%lxv 106< mXK"\1#p 2j;FAnȪ ܘ`Lpq\SWgO}x.TdLD1e<7Z ^jJ1DŽH1LDrӚV8i\z쓽p!0ғT N`1QGKlx6ʔD1fʭ[7_/07$Mp`W!ؕ,:qc$J_wx,xGm60Te|LfL< Jksx~5#Ђ,JMzc+(}+mWS>M% h#ܱILR[3g5kV `;#]>Eیە(vV)ı{uB-Y% @܇` ev޵oz̒$!ĥ \LphA$ L+2[2)RD5$vifJjpdyaJθ.ajXyFNxN>>\~H2($IkgBߺ0\ )H[tȑ'@\)J2&ժax<{ ;/S#>VׁKw欙jޔyjjԕ*{NZ4vѷ4R~`4V-kzGնTD/b}Gb_\eR|[xM;}Xi>Hx'L eB~HgƜz)Fr4mT$76 :3$طhh*(e`SP${abr=Xiy_b,UW}~]U*m9[c-[ '6p վY{&kcU@%pB*}mV AZtl< m>㞯J^,7 NYAxd;i hѢ6ո2pb(H 96" `70'@2A*9E;'_ի'[_wOSմ Ԉ#SՊ+Tƌ `|r&6@@CuNڿ^m]U.UVlPjҳҵ*M L$9dٲtݽ;Qg̾mMbLmR5 <Zq[lXλK%Q>Y|֪DaGsd1M D&w2[{"vIha 9V{=lGf=I삃jjƍU5O.YV5I T4Wި{>uW5}ؿI9K ;uGE̻:wRTSU_UMmni@S;+y*+3Km[MGQQ}n6TmnڽN>)*oPXp| < ؀[x Id|n2;YOv'-*?,j[P[4qX`GW{HI{U J8`ibX=rz4i5yduW_zJH,|oWfF_w^3Uծ7Fj:*9dRN($˽%bjj֭ ?Mva;߲;1Vu\*R,>F2?޶K|4pL Rr!~̏fۛwMD؁Ax 0x\(iLFS(mPO.WyzjZ~o=w.juU?6Po~ST=ǵsVvڸa*fԱi'6JA4 nq Qzzށakvzl gg3ՑT`-2vUz4Q&r A" o7[dEVQfof8Qu2DIYYf5Z5[ Aֽ'R>Xj6}˜O=X*(>['7eʩW6- h̑2ꞿݣھVڹ|ړGmQɏQ-*h"Y;m>8@i ~#wvK0z?uzAufД0|_DrP<΀y9xd91C}1|VZwE怜c&OVӦMSnjQCfP/1U0bT(kr2vhl-Tf!LO/@8RBU{GA?wjݿ[z1|qatPrӒMjͪ/:VR+֮P;w̍G\tLZ^W`o>2.͛ȵ 5ٳG(@&<ٵjH"C]cJf-M"+% 0(keéBK)#ycnVW؃z8vdضg{ ud׳K#GθZ*_B[T/ʩ}Ϗ TNҧ.W&.SV}zJ_F=hI}]'Tz* %VL$^x?.=TzIfyUx}OR= =5nNۑjzW Ou/ݧ:IPydU^/l0{̉h7?ۊnPJC'g0< 𜘿d8նThτ>] m0ojBw^9!}KԒūTyئeG*6ެrv5KN #p2h&s.xb.88< 2KpQq) 80sLY`x>)@*ݔwߝx $<:ubŴmU&"p 9x`U ɫMTu0A4>Mn&߯ZjU,fvlyHԌ/%U{#wNDxm:qLի̉)-)Lf4If,IIx $xov$v?qy;lFonݭܦrj0C%;UUkWWw}p*}zԃzP-@UHsTˏ@WY6O m{S-R횵JhXj:؆ `HQ&q1U8Ne7c ls5#ߎkOWzԩ_f$)(oj]漞rSqf:M4H} I pˉ&'CIDL=p3ccaU7 .C;۲i]ӳaYdK՚IkTLu[l\ѤNg%YU*}ښU5k.c^uԔy{ݻk&ٳL&%awoQ'SN6 aeߩaS|LNPXE9̧ -G `ze7I[s퍁ҹ>?`ZRՈa^P^lKN8Y͜1SM>M6ًՊi+Tj`Wip6Evp˩eUծͪ%UڨNotR[2Yd1Ot|B=$@3Bz$[KTr^ǚI:Y)qLXիWc kzC1/͊bQ0m*U$$`LHS* si3h7h P-~B=fh*L[VM^fip{܉|B /1jz{c9u*c]j^+!kёZVK9@b_IOaI!l PZw_"x&?!i6-Bk>g?d|I :vT-@$2 t A -`@ K'EJXHϰ.}ٝ`fdV_ûV?Fuyvs?M){uU*VQ:7*0AИ1]c%1D=b7#vEP)TC" ƘjzroL1rSLn삮ݬo\gs>s㳞s{tzw>ٮ㦾c鈴{Bi1.ѥn݂unnnnenMѿ/8756KV$g^Q駻7( -4#W3[K$^T8 I/03\- ,t@'5!j|gձx58>(d:vd}_}u(ߟ l`'wavZxv=͸g7y}}G-ķ?: z7}vnތyFI WmzhӶ2˖K%J>}r=5'%rǯK2FfƊ]+1(=>/;jtrhZWsV6v)p=Kpra d5aCFc91N =ThRǙ~-[nq>cgEr(;^mxt\@uFyv#T?fL?i#p't-q3Ft]yzbÎ>:w.Z׻_Nxwǹx_T!fzwaSwH9D! _IB|3|/4|#>75ko"Je! mW 8`0*AcJ=<0J~)]1VFgU pcR؝i_<ֽsTＰ=|o}i܃㦸]q4fl .>[̥@@݄:|r7~Z胏 Wcd"Q7/tA;_DopR4VH ?ܫ6ntx-َ -Νvhx"Xu#TB$jM`E+D$^4C$ec[ s7Uuq;Ν\!q-nIŠ<)EU1׵*^"(@o*{t,-??/Wq>oص+_̦FJ38PJa#d3Vӑ#΀waxO"wX,~qhx6ۤRC&=IӸիJvwr<>jԸUVsGElɲ(ki5ۤwFޙ518 ^pOkW.=]Im/2=y+:hfg}f 8iO*Э 0 W#uY-Z;ShI{l; pXg$/z.0%m 6ugsI>R7Qfu3E j_uϸ~x[p{G"o#kv r Ky$x pZ\39ƿ*5:Gįؼ}7 G1HE[|cz}1_V*>&qllҹE&xk7+B0?zP̸:3N*~mx e&g ~M75I&06Q3҉KݜYs9[ĝ/Ob5|{(NtG(wuֹӂ;/h6Grq:o8 r\bv38‹.Z/&@LR.z_h^N?-Kmm7\f|NTM{$<9RYή- ᖷتr 0Ƈ,;tYg1`c6lXoԓ`Ίv.v%mz(2s˾r^]/Mortwov;GG3ݮ;q(۵oj^I>9TwM67q͟OSڀsoIܪ5‹F%bv0mMT׍0Iwea@^GI[ou7GKBtz8lF3Whv=Ҽ]{Ou;옚j[J-s)TZ/xz׺z|(sqgSOq858:c|\&'}NxQfC "a ڼULōDP|;5"Bk6?L 00suXJ&Nݎkw~];wڇOs';#R=s~Z٠rsqZKZ_1c܇;k/J304 K&p5exD~b9kjz]sBۗL}&j)ii2I?HF^hpƒ`Y)2-?z󱧹uV~y}C+e_+YtqWY=MȆFTEei4HU)W/."0oΨwv ĂPaZ*4*0nHRa9S@}%5熝}iviI$@q[3R D{cl箋eA]|YE26~hP¦8趐t;Q sߛ9&k$m[o6/d|RN%զ ֥FQw '[5G^w])^Нa?-j7*#j Ln?Su"^97EP2j2@%eKJt`" FR~Kx~?}*n.aY*L%})HBgFG4>oL+U1W$Q-0ŴFva ϳ-h#֮ustM4x#ZVnfX܂rpSvC͕=M~F`K!aET7-:]{h +% %=08,!Q*>~}h[d!@yX$KQY6/6dI:>XiH\^8oJio<(:HDk3QJeP1n;\‰9[w8}\wtw5Yto@ &M] ;.]}Q;, ߑVnPqxe,u~n6K%'#N4|c$Q}BS]{v '&+? Kd B SCp[-5}Z9q*h_ri;GN,N^O?]|r!;&xQǎ|u,VTmK gJZr|Y&8g9Ct}%G^aW4ΓA󛥒Ӊ!|g2Ҧ8_&J%ph߆u,!-@(; `4HIxA:.Fnga$UL\c^sGG]>9xT4P9qd7Qj3q Hh6J⸪yCjPA=/kiuwy#w9/^tFjhIV@c|`$0>B*.GVc8*j7j#>`W|[cuz9\)?0R 4B1 E,+KsG6Œ"'zj&i()c0I DF!汱e D0ɷE]dI&x+ 0< Ȱy.cQrYvs0Rg$ItrQ+QPi=Xs3E'HB? l"R֒Yŋ#;u5ȩEZG@zȑd~:v' /`pQנ պ`N?KAs\>3|]h/!_ú_ih吴hADZfd9R> o: C&(ڮý|SJw`RV_c239괠-]rZx685{rg.=z r\ MӰSJ4q;2+ۨ$0Scq}'kMs[I?vjZ vlT5HqX `|(*6aס.K#k)+C+tb1]5gג<|M3xCx `{Sܳڹ{eP)وfvMN^=i[9bɐΫ0s1Om>hفm.ذ1xvDb /u; (~~7<R fTJ/[%ϞyfTaâ4|6Z} :wb) vPfC$´}ocǨ,lJFx`g \\f~X]@L@!Z#<\6J "u,u;97j8wT:(W04]}=-:l7O6[-P'QRP,C]~? xĉD^8qYY(#7Hl]wlH)iί뵟VcAxˏE.ް!<-Ow%L>E(|G]T, 9u:8Pղ VvrZȫx/j7ApP=<$Q#1--/sa$)1  X5Q{ `<|~R;**/,%?ĉHɓ$s߄ FZ<gû\9\Ҝ%u*G2^1kXP s ߓ|sYKiV F*lEk,;~R_8­MA ~_Ԯz:A\ilI*|~5(y!`S |/W}'=H|\ NEl$$7e k*mG#-ȣic~{!vI7gML<: l`%30;E1RF@$U)'!pWq(+KRk'JI !\kC%uoK)1 ޖ8T 㱓o:r@'iq)_p ?D u!h&^W:ftKF "Xu $yIP'T G$Dd3ki>*jRw,תRҮZy{M,3(sS'PNxJLΝjk>"{ o]؝2 0 d/I6Ǽ"eh$4Lrbqі9 }% h…Fm)egΒAfd_gXA ^KߗSE|\z3 J(m`;Ru3͙Ǒo{Pǀ h튝0.Uv#@#?)v{L|}ᨬWCW1Nz.>y`\.ii i,"hqozlp}$bs4;G6؜B$eE(I's$BZlV E9y{JEԭ*j4B:AȁLGx&TF}@f8Lp׼Y$]Yüq ڸi(p&(c)&hyp*RJ.>%jw*>Afz5}ރ9 BT|X\Ckf5Qk5]a s֖'uDC4mg8aIټQF݅xXvpֵ@IF]stQXh@&o1?YSkdFQM'?h둨f;#X9Bؤ1q&4Wk&,`A 6gt_+$IWF\ϻ0ssW;D4@7=:_>aԈe d^#1~Bu ^ka&: 0x;9غ BTH#$,sԀF@9' j`sR{V]"[xi̶ÓڸV"ouWꙮ՝FC$V=Vyr,T à^չjXߓ \s1)V?Z㖮ZMbU[pR[,_]g\ l(oٍM Wy㪭%uƳJ1x)S4KܥH>zF6མ!3FHqw̕6yuy 2 "4kGn>q]AJsV> hMocGK!܉n`{t>0 5~SxRPJ8| #H8İ#gd ?. =hf(N ] `'ܵ˨kRYGX#+k ~Ns#*+'IL$ uu iQ\=$f+UX1$-+BxYs380cn@4*2(i0 $L/{UFK.uM-$A,pMi!Iޖ8́5?3nyŨ؉)\AVԞoҝp V>O{Shs,ё);e5,/ڕ$EINw]7B2~CӲޮ[X0_ry. qC)+(3W}_')_+\)؝lj'-•Y% \^.,<2VWBӴj xq@!AiaP`^hn `6O|%7 I_EuJ .h`[d#1 'LISທn0 xl`y3vkW YgI'K"}@L| z{~2g `VH\⡑e?F0p~-=TAc}](DFBf!M&)#5 `BFcg: bNXQ7]sFOkw$l]?ϯzu!5dǣJb-p@6o%@0dsl#*npw軥6)PxoWf}P}Ȱa>}U wJX ۏĿH@MY#1YGf8g^ި<߾.ʆM QE܃^v[U_i6y<ܨY̋3yaƦbm$n`+Rw)K96;P Tb6Ԇ&(CR6 zQ-32hvbXc2u%pQc|-&;+CBid '}>D8+Ry&ΰІ|Y)gc2Іp?m!GC"Ug2FmPK[̃RƣFUK?2ѱR xƓz/q"[yF)?CűsCGp5fqo5W%TR(g$_IF,50s~]g+ĿL7qUuh9{W/EjU/;ri@B '" PU/ϑhQ.F˵L|gjbFIX0C;-//0Q,׍#*!5d ~=kPIjjh `^˽v%YS]y gi6,(IY ܳS%wyO-,s]rĨ! s@t&Z{Ll~?Mq6׳}6F66ECeһ+HA1^ BF aԢ/b&CLM+(YlJ,jkDEdP+ F?kBszaRꘕ YfW5H!:iS _UUyGy?gu`ȑnĸq7HjڀN|x_t/,=Uo\?M]. 5%UlmgozwT, ŊɛigxB $נ/\~p]]JnmN7詨Aj^͖jVqx9#*x-o8+y6N8MH6YRɜ\v2SCJCe?X6w"w%a/ɜtl箅FzJyԩ )"*'i3L.iƢ89ꭦTZbtR!^T7|sk<(i%GrsR)4OֹRiM#e]j|]ҰFJqvpCB{gX-AZ-5ſ^ b7$k$:X@ jGgqS=t@߰m{ҢI%e\x=9c.ѵK=t/Zઅcq$Ca.,^Š/cj,ڏsw$$-4$g7J3hA&C~g QYK-jtÈ@^!krwM2 =W740?nSםM- Lh:& 4K16[R6`Qفdm:u9'A 'UQk,HBSv6iY.IiW:v<֣y[ނ@AI$QB=,:-pA7TMr:Y9Y!:L'k<{]es@}ümUQA|.\b8׾5Z:DnbC4|J[/fT{p0ӗ/v~n_t$Ϳc{^կͤVʢ0Y:ּ5 "LB}X.kǴlH=ꠠ]R d.KxvO~TϷgOץ7뚇Τa }1|_ 1M28yw47֮u}q=G#}u%,7Y7R5iԖ`!A&gIk1!\qETZ`Rk2 W/R7B?xUol;AI}R׺y'&iw\tĺC Hq[<#bDV=5hPdUeܼϏ>:nGb1{｣5[ }<h| ;WI!f'g+IZx 74Dh-NO6͘1G;$to`wjtvd)HզD%=@sb_չ>u7Z&XVREv{h`6[5 zBAGwv$;5n$|B  {)ŇalπZH2Ⱦ0A~vŗ8:fa>rdCsn%;H k V@pd~hQ} snGC %Nٴ[SƲ*Y>5 #\kذA1o lQfpktn#lY2ޒx#hX7Z" -PJMN:i:ɓC[KDU ,B]E'a3r`9ؠSzΗ&ϚcIŽ! UYHJeS#^ =Z=GgyRb`}{dCZ{{_~HIZjA1DVt< ܭL^&iqs ί_̐`ҙ(;66ÉMR5Ua=ҩ kiU)/sJIYig[g+= vu16hX _ÇGf0($n ?s`,Y=yo1`"a h!'+-f$E ;I۬Vj: }]k}a쾻nڴ$Xdc4INԼ$>Hx%O$&pl] xC׌j|kN96f4XO';м(G)@Y9o¼e2MZUuF)@}XxȀn@F'=@N2:@L]>tpZ3): P5vʸ`*w` 9Bd.H|WFms1X|W/Is[ΎIb #8(T 0rl pc<$3(ږ~Tj}K.>j+c Ya"p^aaV-8Ҽ9 RFmEd-"iƶPsDx!Kɛ3̤o汯bU@UKjsJf nuTE}N3]?#ROs͖:ݩSb҂ͲȭH=@'I] sq1g6UG_<}6&(^,KxNF[ugs=أ!/K}1o a!!VKSv.rbyKP"iQX1)8I}N~knϗ7mao3rBpSi4<+ߌD:˥:٦8ȉ&Rf h n+ed}vh=Cs#a!;fq ^0Ma4ʭ*IC7GN.gdU%Xlω.tNѾMS)%0 Z# M*)_4(M.7tcX&yV靃ȪUpq&FiIe vLÆEf#gsDU0Z5@TZRnh7sCOc"XuX_laTU>CxwZݼystggkWI50BPۚT|PrHe.u/®Dqs؆_K:5J*Ⱥbc9n8! y ُRjYuMoTKJFZg,] gp`a[7%d FNRy&sJkǵ 'ר1hPI(L}h1Y9?ş5`:͊y-ɮF s^7eI&( 7b򾖀al4+dYFDʦu. JҒJcd%:-fjgU`^$}K͹7@݊*d `}:$T|R qLx|9+I=_dPwk6z#mF;-SkRC\ai W[Q,-&c|O~(TӦѣFk8+x0󁨵G*: @>6ץ*8sDoZ*!?+VȰ.n!n8G!wx\ _j|LLq캫{b(7-#la1Bj4Pe؂Nʋׂ :o|[h]m 2VjImbyfت5wmm0j2К nSyoo B)Fb>ԯ^5xpY6K9BskQZc3ML9B4J{me%~`YXwqG`C`y-UssSZ(`2<^C_cӜbf X~}ā8ĕ8k0K|[{AAZ36twދ4j91#i$͓Œf0sŗm1hKqOO|Cm;6:EU Q?"DN+L8|[d^$ɓl+f-5l^ȨC߉弳f*kzh  ")|dp3}QeH}cvJ}Y&IMrJT,57Lтgc^xGgtѽ{@b *2|pmcIjrK~} -7Uҹy֏ǎP͢Z7yp# [%sg:lV,Dyr0E+V)&2Qiy($-2]%0Sks]wg|t.kzһXobZlSZ͂"^J`1[*qEujxQ8yMyrhTj#vGZzgi(uLt)FuvxվԳ+e5W^\aHbEܒd C-O9fXbjzPal&I5՘hNXaUR%g `PΞ9hj4SzAk\LSxa҆I/ `[olJ#m-Bf{Κ%}Gv ? 몋Oxޗ"#A⣂q0җZgy[Sf]Tڤ s".Ɍ,Rԡ UEPb`(tMc[$=LE.t% ,@f2fcPچ^R圫i"޽{n"eSc;{AȢaXxoW/+96sAӧ4Yoeb/sT,4WtJaAE4B 1fl 77=@Nzms5I#F[Q֯_2dFL}-\S4[g9ɻlms7h6?iw Q`O5އtaN- ;\[Z5p6 즼$M) 6rY֗ ^n[+d>˜t#E.Lb{PB,>R&¬&R&\ʘEPc@j|.cik3"8~h/#/6 Lw޹ּ>*$܋s6wz$9qf3IvY&m[ bu5YּlRAFb?ϢGۼ+iBTMQ;|+ޜ.7ѣ"G5Kj3>gyd:MAӚ3| 7ئ}q9yi~`&ϒ9C]Db[[l$aJ3i 祥+r$#$W*K v8'Sy=̍mf-5&hkXX[7mJi6,rѰ=/иzf]l.MQtx~ZYUCYYk`fvrlxAxv!.jy2d5jT~[Tlb4u؄ V6^3w}Z}nYdD | ۤZ[Rْ-(m֍ۢF'KՔ[ t~4\B"B-R2_ Ӵl [(_.y]]5Da!"MU!U[aJUE/PfPl,J^-RZclܵ0ksg>* fx la6SY|%J̟ܚV IENDB`PK !g:word/media/image18.pngPNG  IHDRKUIDATxrr.PKT%U.[pr) ֿ<GcFo`<>@br{} Kx_:yשbq+_nRG,@<\ ,܌\P#+kqd&e`iv- ˻RYUziu^#N}@|zMˈ=4r33rGY@b} z)]]uj0*_I н[E}OC?AiMJQ{͹E8c,j*·?pENErT`-9.5}KgE]ق,cO#PMyf,Ur1i9Sy81eR97׼.r]f LUMʡﯣy"ӓ5vrMZdqnIk4Ӂ]Q0dwjh[Y]>vϾ9$ʡ063|JΘA-+|c OIu4oTf8& V?sހ8#.r-S-p߉E+xuYE,[9ɀgHHGquʓ5G]}b p^=Up8/vNoIo"}Méy$.aWLʞ.-9!^`!5e${N=h&Qtϖ(uj1:S!s2)RϞSKAHAM۬ :wIzr:=xWJ~SkW 89>ZO! P9β-PC/L;[:Zuoo ]5e^au}I}@64:ᝌa(qOl: 9pv_7w`gF2:EOo2 KH=cߍۆd#mrd^6O)5_͗z[{׮!r]Ur ZR60 h@}[w!kT-)19$z݂-C"#<"&WK8sĉEEgFʏ]xYz}%IL_d#|A!wXmR7&&EkpcFFaqq0D MiΒT]Zlz -(pN/o@657'.GHyڕ` O'6N Y }1|3s~;moz@ƶ\3ӗzV ,cNz+gtkr/S8ي ]s˧E)RYXn^ wm"%e<8tvN͛63}:>Op=ɐH߸Aȟ6 <躻-V{o5rNf SʲΩ'E-FX|H5OȜuESf\֚SBvx)C[>T(Wt+gVisc־B^g l<%P״}Rs}DmyN[õfxne?dfn,5_!,PkBVƿZ5S'ViQ{dwqZ.յl{e TlHmsßX]}}drLWsM85SOI`!B3%Z̵ Vyc8vW<oꪃ6VFBCW 뿑"_@pBi6V8su؊,x噳k!w{z &kOJK:=rR$懣)zg`}8PeXWl5/ΐ ;;/-"Vׅ{_]3ip5%}8 ovK-nQ=pZp޸$w:o~Wat\[wDNS/g^9޼e%U_/=ըk`fpn ]΃;:wQ6@XB|" qV˫q@֐oo׭9}'m|:}~{b̟ȴk&Ŭ路88Mn#oר?w-[I?j'wIbJ3 _{seQ`uX Ɓ&=:7dGP ib:NR$EP]%ȝ^p .XT]<^|n׏]oWR@̯[R*]Eч /\apLj n`{ŕ[l`2L(zu>yxW׊ow`#BP겲qNT8]GMl³" /Ez-x ɳ3sҚ=Xr.߾ެ Q1]Q*2Y`u3R~yU/2*kՒδIZo|{q:ym]@~LJk+<5wk2p^}Oԙ<+sf*-R,xh /WBQԸe悑EƁ3Fٿn N-jUS~oO4{ld&oN9W*?N.Z3}Y%OQcx_AIO?k DeB NFfC"uڲ93uk UZ+@9`ԙ=E|vDmN5P7i~6߰ !"$֗|;_Pזȿ3e֕u^lwdł^i <=Sr͛ϹrxoRh('J{l͟ v7Ϳ2eKۿzWg2N~l˺x1>Quda 7 ! so w<[?muTKS6 L]op@l/Z*וOጽʕR8É<8y ws&m,;YyQeNCk^:eޛh7`c.7vR7@9o]j'"\nHk&+|BWm/ë%!] <+Y+ԩʞ^_Tg8Lh6Xq9:yBTX4pW(M~ _ǬS'䔋ި8p| ji~kl[ƷgPTMWsۈ:qX+/Lkf_GʥA{uFjm 8U~넍DT86ݾsE` ͽsؐIQkp+>s8}pl?ַΉI-c&-Wq+ QDuj1]*0+j`MvuPkљuρs `Oͷqkxtx승wvF6i|ݾG?'x״Ow+Bbz&պ5W•UF˦Ʈ'i`%Zזc9ptR*ϐnΖ+$MuwD&W0[wq.z?IY27:ubcr_xd^&F-}K[ 7U 'CP%EbS!|0ZpK…YUj%w=UtKC(lzyN@K: \)#ϏǖF2@<ΨgDu n^ܶ})ʩ9v_pTm-ndt~6y&i(O! <#rKG$ '3Bl}23yx\Tɒoǁۣ"uq30:/APtNE]z֟eu.,m+CSoW~' Z+we&vƆP5~öS/^gJv㯐UeƍSkn gK_cc{7D@@ gZ|3 B*/Vn1Q 9TZ,}(װVngb[J=ӾxٳT+ ' SeW.VN:%b>ޗHakgᏳ75S!WgY)H}6>' a=(6jA5g^D퓡$.r=0+ 'TaVGؤ#D uM^w6J7n5vy$47/kVρ;r''4(Wpv=s\45ZC#N-ܡ:z㴼Hx#,Xd {v)+n6hXeb:Ғ/%dE/"xN|KHq7є56\oۯ<'tcm%q/~[ i6ۄڙxeXs@V;I^t4]_ٕƤZfoA7ڮGRMڋI5>]߾ %q{Kؖݿt?$|Qw"~#0]\|Blȷ߾( y8G'Oqj`љd 7i_*Yl˦<$m 8C^ԉ9=q -#}h ÍܦFQcKz/N8@$ykۼڋeSQe | ^TyYѯ̽Hw_P25T<ZXÁ7.vƦ3L>)~#ҳ}y8ޞ5!Zv̟j2[4v(9}xja/@] p-Up0]f"w/friOۋ;vy|WcbTy e\,`c74-4S. .v <Ny.c~_X3p3mXҪww2@`^k_b7,rr0jNJW^|]n3 ŧ-:_ -GfI KO?E]l،EL`f@v싺Rgz<Y}۞E~*ۘlKzq)?~f"뒖Qu`d^)>:pٱ#.W-6m?ioZL:*^Amf{Ch/7i !'']$)Gn{cO[ʔf'+ko_N=};ܰ#G ?^ۙMyc}l>s`qX{ RrFr/nF=-'7<}%<=y ZwlLݠPزYg0͠9$jk곶xs غ؏`3k˗5n>*}5۹CXQsgc 7IepXBo\yLV_mn[d됣 ۪T@y[w3t'"ߎ_|[бOR̎K]{EVQ+37DTY"`Z%>/$XiZ\8fLfܮӓ`*`ʊ]1]/fky;P^Kt`Pب*<ޛMZ׼w29p1û`~H\?|F{9bH{ȱB!3[Juz(x@B n6Am˫8oj?j/et=I粫t]zc+WᒟcvxN )D.3(n\pƉ{37Y}B7Ż%jql!ظc_ܸRwOwj1cdi3#gv!x:P}O0o5~L T`3Z {-]J'sx[NJqPRȸQ;bklw^ekaVfe﫬eXe/S808/^wA#p%7oku(e:znԙe_] 7jo~bQZP\a6E\|ۮ1.L1}!<u J}qiߟb:~΅KďEFzu]mʵ=k5lam`}q[L WG\ _6Bc`S®y-]^OI`{J^ Ŏfq |{.yW4Y-9~퇟zcݸr8ccw} CًX~އI÷g*<$/bAlB~8uC[ ؕ͛|nVB!?m';%MUV~%-]F *p-3_j"uEh*6〼MER~=BvZ La n{Dy4vr}\o힭 2x$i"]0_ar'ʢxff ͕K{o_zYύ'@,`4s~ܯOZUwSl=ZY- (d4ź勤> 2&7 з3Q7 !frkn#pS7s{`ꇆZ9՚^_?];y+e:#d;ҭW&j /fƕ$ʎ^򷲸ymЖh?i֝0FGNgT6k}ag˵^ɯO}";G~^&..U+OWLJ3NZa|盘cԮٳ@m)ӳx\ |%K¥W-'"WtJ=jd3'pLxj څGB^Ae _ly=V/v5fY~疌 g GBjy%zqx)=P x_ݞ9T0g[IS}ʛ{v]'GoT jI3Im3VS׽˒W;9;m,j$+ڥ-/!IvtF9=& k)c>%+ ~I\ C*Wly[}z3&-n:wlXUyNzͳ n');J6LMߪOxhI b^F)cdY <&-+zhd˝~)^yVxNgmI8Hɱv]ܪ֠Ӫ!v(dW;?gF'nNԳٙ#c/طZfesLUZzlóu/r9@5zk~5YŊ[`캘ᴾS%x4&+̟}o$t2xl;n7]0 sD&OaRFB0cʴԔZwR )^#o t\ cQԕDxv{P7c7?N=8{ߧsAҲߝ ^1cC&&-M]XԏBzSod˻>F+tzFmƮy*g|"gşulVRr풩,n`<{x=O汗y43ԭ.;Ϩp nQ똶𤷼]v:F`+D߹s& t<# b!w{Ux't=_u(|LI*+o fa 3J58Eԁ3Df DJ%cg?<ºee_'V)%+pxTrx̭ÿ_Tv}1w td J`x%NԓkM0^h;q ,X\NXyo2 <w]SWm09*rvxZ0e}įxl1k>:q׬ v-^>:s3ߵE3c Ud &V-Xk q֭n! 1{=xnRT<']~6S|iwy;WIo P6-{Zٸ+*nkb-%882=qoR'˭>ə &EsUVω3gg܎\q PZ1++kOpL?R'ic`'ehٟ1#lR sX0Fp{e`J(pk k˕JZ*o蟟?feO+z#bu,u(^Z#J%:Oq7̉[ݮܗp^(BlX2?\sԋ<T# m-jnZ@j1ےiպʹuV!9 &\ޙHwZx~蹯M֗5]?nowU\<<2yN[ pK;og*#6ߚ\1țpn?vsO &/bɻ<応.K2xFKE2ǒGo%mBVIRWF ol[rBf,o)t&칑PHGVhwgF}(7.WF19rk- ;9C7u™Ml~W pH$ϛ]5_}&mƒȆzq=~0puN!/U^뷓&l;\T?kC ߞ^]S[KR,SVݩ0O/-پN}NLYB3~AE9S&xG?ӑrsN4.@^]y{\|Ol'Yv3=aq}6v^Qpj%ˇ[l旕2 v?TK!aDžr{o O]8%1/^N>Y຀;t8;JnB1wqz(Wdu@ gx6g4pH%'6&Wx #}T=|+Dg['..]?\!vlLPXrR$@F7;Z$0/Hܧlӊi[oO'-3Nŗz=Ro^W ͝'U5MR2GowOQ4/~  0%4O]ɚ3ۘ{f C33V5{`Dd_PX\_o:,ܿb<(BvlŗZiռSN:)/Cγ .m!{Pl?=On6N #K6:`V-qBW,Խ|skv 3679\MuordÆ'UQyIvd9{[\ gFL ã:vZ֓ ش0crigJ~8qΛ&̷*PXS_5;q[uIHM9oW]75^307225{AGޫe/fYzfʆVH3pZԩCb#:8-|i:*K|aeOr0&|s==~cec\ u27s`3:`ioΕ5b -6\H^"jw]U|fPղ"sza{wT 6˻Qe_eo[߻w,/40|I~ [~ b(Xۋ"ӻUd/(]`pVDTcAuiIƢϾl=FZc}7b+`Mh Gn\3F:',;J>L)7i؏x00Kze'El8/jzyVmA_ Xo6VߕPL{/9 Pu:dIy2.w4vڼZH_Z]Uŵƫ~dP`Y7s^PMm3 ƅ_D: ɍ4ڗ_Q &V>~Vζ :W/ Ҷ[gf{$z`e\p']NߡeesOGzwc6x EC~\+I)}zX.*tCwꊲ[eahyQ|p,( Fwho/8t؃;3g}]5>DH?A嵴<^`bc%+[WH䕾%}a`0"LWIaY L2S;35e'Dbl'U1!=oo7tp a ߐ#oIѧ( NfCǶ6LXgxo&pr-b6X .c&m1l16T .rW3 xkWuLk`@}-PoX_$㪘s`]GM)2uhͰ l;k^՗ka^7V21^p\-NιR˽@`BNQɩ+s, F]nk#ZS#OB Trd^}ZO۴hB`qLY 9++?ýfVvOV/Z+ѢA2 <[䝗*Nz`YsT;5rE ͨ:7 8*@kOS: ,?ߴe/(yF,{?uzu%ov`+AcXU| Ը>%O[):- ^oտ".2JSyg.I +o=eʫnIƴSnf(A.ݎ\FApSW!Aajf}s]? Jd>ʯ}d (Z>'M:d#Ӊ@vkτ_)yn}..0eʚ#ǙIӗIk"`$}}뀦B'pQy/Oz[cڿ6ǟb@_,xüc.fEo筍Ѿi/C^n 7`pEo-DU-_HM a剴uYZo"!*~&VS}k]U:ې8R y͂mIw'lwGZ]@L$zԤ~IkpC78ڋ:fIX8\`fOb ܝsaO L y!3kv}|?mׂ阯>8b$ #lVͽ ΏGH'ܧ+sNL!פg|&Q$GFHR7 ٬xj|s~5.Cmmpj(eDْZV8J*_k5 LO0#[t d"z;FnfMdiH1z4cqRʾD{Xv;NX 83./y._n1ݰKQv@:Վ牬KR] Su.{8yRH*r9wb\Oˠr_>£&>rZ>/Yb~L3P<"Srfͼm{`u;kθ`$4q m iو-?phc) O#s>un&g1\@X &լ*^کOKpi1Ɖ{=K>bXpܚ}Lk'Ԃ4ט}^B^ι@t7S_ cΏԙ.}o(Kط*˅ӦOusI۳7ر-'%gv;up{Mj󰢶llH!e}1 UGz_3mv{)#XwLmȮTBJ ܞ{h(<#g,?Klu-@OxM>o"ocӏ75 nN ѝLFHsgϘ547.Ux!_,5v>^9+o,x0_ñ `}&]0^]#m3aVgI$zv?a2_ {pH]!\9 ?b9^xϧ]R/HqjN0]SI{McpZ&ʂQ{(^_O `1:ԖZL- g4i'pa+tqj&ːhkM.^3+N޽kS+uRW$6vI/@R~4oydVnɑ{ GSݠ;e4S.FR0Zk\_& )fެR"~P#w]gU‚vM?#I07(??H/^}Tӯvl ,\hlY;ajd@t$ꑶۢ\D Sc*ɔLD_㇟c2ߏ+U:vL}^w9l`ٱÅ2wV9l^ٍ,=`*PcW0@`Ai-ЖgW8)jp\~9h <@1X-  xln` @ n`k4 WXP430[ "&kAxJwzAA0@(` Pq M09 }SY)*f 2O1(e WIXٌaq "#k;k@QȍM}n*7PPCIENDB`PK !Rword/media/image14.pngPNG  IHDRKSIDATxr3PK}S-u$Ck#)~ 6 ^|@RrocR<HK_ W@B~Z, 3n#SY@O d3hK`S-aq Il!lʿJ"/dE)ӭ }=Io_4]Nk /z~x`*͈.>#U#M6[Rv|%T:FQ5nS}m` zJQ^wɈőCn,_Tw?CduUd-$4)ݴoߑpY{}S6O\y SO q82k?E6;+Ixo'>CV I C6ecӪd0tG/r6-|#{g6w u-~pi r(F#5{)౥suߟl>y_zM;1vm}5(w/샿.ݾ1^kַߦMa/zĉ~[oك5`vyR}#+.JWpm!}}*^6=t4ܴ g[r3:,[=:/8J+o vGR#a/z 5#q^a'T@O8oiʭ VWIKbߋs0+i9695dEM?hfy U.3udeVl[t:9"͢?-s @CYy;O{=YT}ۈ'Kxlʺ~MS-&;zF>0AZ佽ywiqVEe)>؋fUdRgƚfz .ڻ,km8dSe%Syv`؝BQ -ѹ5kSi*s4;fo _Q{bۅwgFQѫ.11ʳ,~3o//EPWWబ];Y{[vt`޹4LT.wpխR iϾW,]5~n [g8bQx+`ʑ4MY\xdZIק,> n GΟIn2.w6!Y <6/&_]W㟱䲵-m|xH_4gn5x?[icG>Qֲ9Ņ40N9*vGrG]t@Oy֨l=XgH`gk{0rqȉWHcݔ;{ɳM#4d|qjwR7Nҏ [/ 0zcO%ujuIќt#KJo5x/sɀ_5^"lnjXzJH\$N}iAW:BO,%=P8Tݹ%7G-,N߅L|WE- * 'Nsc/ŵZbLTҳ wX%6JǺ3kG?x!ͩS`0*g7M O%9lpY =M{nμZ1AY;־# Q8Txm ׎;h/6ٙɁb,&{ LCdY֒!5Ti]siڬƄ"(LW7=xI*Yzw{Nfid.Y&"x(IԱ&nYݹ_+w<8k!Y&R^sW^Sf+&oq,e]Xjw|WhNn]!$Gje L*^F# 'Ww;VIK7` aD68kMz{TDJG~gOki J+V̹ڑ.I7zLo"ZS'& .gΜ!)%_? 72%{x[!iQ7,v++;,N ֆP37<E*R6*mOp|OsN?\V<,ax5禝ɣj8 ޣ!zxfS3\v dV{5ERdV$VF r'{).Y^8$n'xN):Jɟwr%#no% ~Z9}~`!w"x55,چsř{Ru@bxl]Wך#kWK;5ckSu;_MqԷw+Q PxTɡ5 n;:>Q 2cr|M.Kl Z$'no8;vT/"u`nUݺ8㬧^=k{sB47͢ޣ|§9Ecމ`ZjB.Fxq1U#CH>ZӨ !iwZ3,8-'ZTvN6&m{0Jzt,jL '%m3g]8PXn u]x`NVuI*"oM5N]p+_|\uITH78gL+z;Ʋ u oMmIi1\)5ewSK6@( c]{O*[ ')յoӱi| >,q[݅Cxh^JSXYJb[@I: Sbٳg5ū<,a2cU^~}IENDB`PK !u)qqword/media/image19.pngPNG  IHDRK8IDATxzzN_ufe5^U@E@LcN_S3EP^|S@ pc'*)A`:yJ]먡c hD|qD]}Ư|_p:NyMЕs xL;#SC3p*^WH\sHp^ HwPr$3]s"pOw sR7\gJ:>w@v* *Xkk|H O%b;dC 'Ff o^ʽ"?>gxVJ<.?P e߫ʓv]8Nd,ϩ-?^xCHO).G鑝G3~ѦƤ  1Ru񚮣8:ͧZ$s{El=TLQ5k ѻpWNc{졇9{Ff􋫚,xdɒ.(7hiQW+kJ^<p<"{όgIn"ZR>8)}yĻ(~b]+a05)v)ӯF۽㯊ur1@}kTHz&j3i5<jsڃ119ubva\&!ht=7GJԵ% -i) ?L]ᔛdtUjҼIkaqٝf''6*?t_Z3 %Oh9RU[w>lD6WjOzBrvUh|TW=44`]sumX9G%:続\yGs1nonh/p{kdL# R 4v#1œHtuZиjvvf@dN-4#5HP-;{;Wa;:?`.^IFWEm<o|]D\7n=i*V8;LS{Wz>ҷYqi#Ҡ$nPs|3WۧNߛʃĎǽ8㽟tFzuɓD5{HOj{xў(cΑqwÃ̀D\9v5 *2iy{9G$`CM(Xn?{UFuu{øqj>y3TM풞]\J,/o+yoR+(CuX;zQ/47A}u}?6: z Zs0 |?8|R Yo&8cH5.=~l|x2ҽ+QFkvHtm4HOg;ޭ#6u'ϣn]nKW7H$KKo(v~H?j_`#t;#K8"SsZ=]|0wzsWʽexF9K#sS"!=ҷ_>}Z@ԝ{K s98`?9iuoc4b|ؿCCwMs#:kl9$wFύ6G\=@*x.cKV)G奜x4>w7۟[ g6T^caDIS۳n*sY _[c~ߒRsMA[k)^&v7׏vHbsW5ҴVV?U\I.b MZ{[ s:khF'^2R*y͛Ͱs%iΎyP8iԿd_=Q+޹vXO`ΪNjxZȔ.n,Yo^xv`G vroMU~& w uQxhDK,B5xjlmErm3k̮jJ `rz¿O9 7Wý*>+G۱Uf{_x̣ě޽jS ;)m9$܎6o/ۥsl>auj#osŬwd9ygl7d9oATO)ay\Uaz EIQ#ɽOUoǻp%[F'nsuz/ )PJ<,ku8㋤lb !Wn.z`xD|v{˦(e^[p(Ο$h%e.o}Iܨ#jd oos\/K%OD5 YG?a󛺆|G#%lp{,d0@q{`{W߮ۙ~kos Jz$Gޕv ֻͰz 1d#c݃`pqmE?"_U]K=@n-m1ֻ8窴}5^;&<>-|ֶ NIt,?Hʪ攞;8W. :NiM%,X'[n])eoTFh;^E e{xf<F:?~z3?Э]~v?lz!o/ee@OnbV!vo>:]*?`r_U#+^a[p`vPxj[vB1XqdWNssWM ޷MTHQXEyQ^x3vk?pb(`yeR/E8Im=\Cte3 .lWЕX5 (m/8c-ƭ3]VЍoP{w%`5cӅor\0ҦKe?oU{^v<ȅ .(6 zɚx#EuCo%I~ vRwS_sXkŜ8w>aܰjKyz':a9ҮfSpb޾Z S=(^~adtZy}n f/6I;~erj[a @}e{{U_=l2h }R+MxX>(VjNXB7} aUznafO<j~AJ-Ny=%ў-pջqe~'Y u)/Iܸnֲԅ%K//k햛wwޚ/zqكGv}a T (][0 ~nP3xL6<ձ<c;j#aᾯ6HM]"֙|[a,4`@ ioRd'j>9_ t2 ,XxM@n K5 b<zQR P0???.^p+89IENDB`PK !DDword/media/image20.jpgJFIFC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?}*M1AeXF|b6Ul,WFʱs)_m*6Q(SG0rmeOeAeMeC>Ps)]>]s)]6]C%MeBeMm)J].]\9H2 Qʪ!PCl֬8H  O$O&KA6Rmmy9vQF9e*mm9vQK` KF9Ðe*}mC66>B-*]hBj]hBj]hB-j]m|[ivTmG.6{ivԘsm.ړb`1NoB}0*3ǎ oū S2H8AN&.ѮRtaVHuw>:S䈽΀닳"Mԟۋ}V볟.=F!$oi?=Gq9M+ quDu;Bc4 5ԙ;tXǶ)C YdyqAxs sLj@ʧh Ic=G搓M:3ϥ>H% czcQ (5i OҚutߚIID>>jf~5Ǯ.C`z+j{^3:>RR\yա퍽N&H^༷ٝ?~4=W/e/MTҹ\9/er[o=V _Q/3/kRSTDǡ6jQukFbʥGpBg#4kToac=A;EsK pqJ _=GYQoI袸K4ߘn~!{VdeE-{U1Uc}K\Jܿk0˟ANΗ* OX_"K?SY Wޘ6MҧNY4^$o%hԕH@aF\zB^eeW$S54 !Y؂MW{ˢ+]CN3LY-hOAQ-čqWaýԻhT|ӞݢÎt&iwA•V=Oj ӐҬ5ԬN z5Z =;Ԣ}~:?)j{1Rr +X? { 9Tm,HO1@9 B7*8s>}MJ4ő̳~]@Z)<{拋K*,cPF̂S*.QU ${U&&t`q5z1T#wRTR R|AP8RT*h/56h ̌)³nu_K|dR˖~^j 'O^£<%u$DۥJJ|,U/;g݀SQ:2 sNx"R &N" =E7@~b};T.K)j}Zg4/Q^[ag##1UQ?1ڝj{!8,Q?,20cETI~ ݤX+1^fo`IKq ]ǩSlwǢ4F65?x~+KCUCl\ ȑҨI0d6wk-nň9~"^3HL';ݒ1{?ʞy)EW@rIE}Ve?KK#O# Anթ6[ȠrkW՚ݤ8-CJŒ6-e-YSբPoFڣn}zW=᳤]E.e,G'Z􄷞Hy Hmߡk'V +8 @WiVo﬚!-S]8t8SkeQFxu7纆K3#|Rhsic}'G1@NzW$ַL#fQW=kYbMNN5n*Vԓ2洟sESncץc6I5kc&ޢ,jNAc܎jCp2\޹͓X[[ RȝKDam'wi%rۜ*K[6wdq\lʱޝsLI3+Q#w.a=l|ϟuqt>$%91^Td+ESgڙU[Tb͋oܼv0ێxxY ;;$}+#:P{uIbլ.D*C:I1 XxFw5i׉`IO" 8V:3 C{;`mUcaJ]vaѩU)"R{jH4 +n9چ[a&z)l~ϸ|D,dHgHrѦYo8 I[$K *rNHϦ*֫fE{i)%!s݊Ltd?ADZVsq$ǥg:k Inxڕs;FQAv=s*oW`mGz5_g<70|Lw$< nEuml#0J;ƪ'ϠmHsGzBkVy駆o?9(@+ats=D'8j7:m#p8lus=vpY@ێGNhsj[8-o $cJj{=NWF[Lǟ,Ks?#a5( ciN4jd##S9?#PKy+Y wT.-KTx.^;O$sBO6svWHO;VYpv5xulm ,}+HU@WLd$Wbb2 _JԶ’6s*7]:P>Q|n/$NN[caB ZIw5'g(cfY9~x{M݄P"9n+`Mњw1hO!~b˸1j;a<5X4r9r:U+öF'^OjYP!BAqPsFNIOz\t8֚в!|ǞAN4v1{<9ʠ DIlaTڸ-\)ʱt 퇊omKaIb5b0(ShNyu-uH`khc_SQiX;,vLoMvu gh%T@Q?e9]l[S+l*D0/Ȝkd y䋤_,oUӒ_hf<~U_¶1.K8aYj!\rexzԾh#`?1+tF[ n^K0ʪz=*gWb>dO0qk'TO.PwnkM.>Zsw M<sTy m! @oe$6ժ :5kl3r@ƴKd4.TKJӼC<(!Wr9A},Zy^Xv+DɎ>ݢE'+8oVK# f8,뚷_cUS"{nZ>O]9gu9rnXP~i$ܻٙl;wִV@4ʨOvv)yc рqֹjɺ)2@8Tn\`jW>9ZZ͞WQޠgPTRɒ:kXFDm'Q2M[0%rMp![ebU[\aXhkqci!mdc%NkCJӧDrF8uZSs[w:+@[ J]%|p~ikq8 =Y] p3Ȝ. zSBn*q'+ٞ\(>~p@5rA1vv\cɤ1K%XWf$g*/\%HB i0ǨM37OXM -`hyvܻ6F0In21 O:6T@95^7s52ݣ b]\44l9)- oå$H4QUs2HnZG%J,c-袚J;o꣮8hMhNH+Z(|CƐ]M ad;"[ZP X]P~R88گI_SȥŸOƞ#r@VsPjf^?0jޫ6[ f͇ۜ\zE^ȢV]Ux{{Y#h^O=;UfEgVlTiO):< '9aLeP?'+e9;# ON;SC>|Ҫiq18' KZXy-"/$[("pNr1\ԅzTdl^U 7Hhxϯ]nRB͝>a31'֚H.7l03R6czI+|qQO$b\3'8帋pdÀ)0SFR9!'j6(Nz.VNk9 w`X۽Qp{PphBL( b?n*$z1R? E17n2ht 2i3$FFb zUlka5snX S\dWpFyzTcVաէU}qX#00D֞=2KH`56;׷ӥiX,}'m >xE/*#׊^8mⰻ b ?_]A=\E x]GqV; u_ϜzSḶ rۉ&j0$K*E<0>ȡ*cP$j 5.[C v"2-rw`#\mlfD >e ~|=@mT̒q1۶i6uNsxL #>,kI$R dSw@Zc8p*,R%bPG>ҫf}*dG >̃O|ԏ#tIJz7*0GJRĂ15nW&㚠.GhIJѡ\3T@*($Sʸ'i{d֠N#9Ò\zӷ `}Q*=S/̇$TzBĺRq^rw@[S6=`jVO2 o%횣qv;~jF[{֤5m! 5*\3@a7 ژn䔎Uq g3I4:91ۃ rqŸn,BDZčMqyGzRo9j%oʒ=jv$6L5s''Gi~0Hђ(,ڒE璭PFЌTZDC2H9ggmD6rALf dm})>7cV+9cp`'t X J#iͧ$`HtR)Žd2 Ym z71T),٣pD SYKgs \ԧ%b>**xܜxjh֛@<1ǡ(nUXEo/#ޫCw?.v"~zZcO;zcl+ s[,[F0IJw#V=fdgq`23ҫ;,{ <dś8zT(40==)Aϭ4X3;1e\uY0F6qZ`JTJ̄E;&BFlm|0]V}JoV(pOAX GN( ˖E;*t5-2jҋmfIL"1!+sqWMhA2z*ǹxLfM{TӚgߘvKxqU~lJb0sc4;vcR}#ޝ*$ cx<HQ)[ zZ8$FGAi ;0=z( qg)j73DF{)s]*\#hJ8}8U X `' [waGbJUxd񁚰eħ+$LJַ~ֱ&)A^pYkn̠{;9$QQҲؖ$I>P暼42Q*ej0 ]G;3kdUY{h}x֩4nxaҴ"E(*ޣe]Mw (OYf=O5aV @* A,Lz&Oߊ֣@4 Bz櫜F9oAgyR&rZ=[b:m֦18+F4@ݩg6Q@PSb<DGGS'e?CR`_{M[V^*o*dڲ|`U!UIqO9P 3QS0jK?F#'p,PFeHⳮl|}[ RG+#d`GtѯʹemmkIo [d=]~SO+2RW@WY:ci o .ITvK ̾*Au 0٤qOp,%$aa?̶laӥS zQ}'u'%WwjO7=5ǸrOҠdhGFXr} hVfmNX7> v%`9!T2}t(D ޣ&$D+VFQb (%9sL,Pq-$*i3QY=MvjReMΊОjBʣs ͥzOiؑ9oƁ&jeG 57c cgH{Բ,H>¢}Aޝ6(]"Θ“'ڜ-az *$%_n~:j/+g6iU=ATf`NR??ҡ}2FR:#E!:1ҁ#8# O2A I(qW\}Zl`"?p8WLjF[1H4uݺ#ܧ[h<{ъ~I(ր1OFxU4̼4s !w T(pIe !_[@è?R!$ }48 IIo,zOR=Ǿ>9Q]zn/#i4Ī%a fIE!GaQ]EsEciZ("QL;HX)PK ! JV2f%f%word/media/image26.pngPNG  IHDR6_IDATxUGv QTl @L;PFQL0P%TPJ)Cvt}Z{9׵<ϻ~cs?]窫SjW;ԩjW]sp]]vvծ5Wx!}8vEX-s.\탩]kFiS }8vmAfrn`+>U/Ն  r;{7+\jW4t/;^zVZAծ5xkxn*6۸7xíꪵv7kV.Js ?#B !CT[v뷭kr횇גZ_*Os ?cVXv1-ZkWYA׮yv-5=s Tv1nرnXϞZnZ ׮ylncYܴiS׿޴Hխ˺^xjnv3Ԯizt\MaÆnnWvߖ ]wݵd fB>~}{}͛/8[bIzvSԮf5jȽn7v{W\7wk/U^hͺ{1Ǎ˾GR1)}[gucɫvԮk5tng뮻woRB$on̘1Uc[lQ t/Ku GƾCܬ^2,.>=sK.SjskZEku[>}M7QbO?{%pӧOJ׭hL~8;ԬY*r{Ayɿ-[:`W9.Zvn$7ǺuW'zZq?_Ή4􃵛|Z+G8d>Og~ ORcc{ ؽvȑ# _+lבCzMVd`}.@n%Vk)}bV#{&5^Zr˹{OK:TOw;(xR֯Ef C"Z`Air ~h^=o^4ͺf {9oKI={:'\vmJ|;Zc;ۺPRI+︣nX ĻDfnUnH `{{7І^XDex=z{duUh9 mqR_kXm'l\~aT<ƍ}&%8O [n[TӫWE9 {FwN0#FЁNm HK;Z|v$R[.|gxx0UV2oު1$.[!N?6Bl " N$(]v; /V̽ec|tRex" g\.qoXLa=\RjƎzE)/-{\K>lc&+IkZ.®S4Fzf.; Pf=*PqE'@yamVuggkYw'J QΙvwR$F4hAvIx<{u֕FkРA<+t L0tv6ꃴ?xcVv{Y6;o9'07P/BYChX Ł <~xO7~Wlj~瑣G:5s2/~2^enmӐnyh؆ ζnАAC]0~My\2> VlF^q@SOT:W^Y;|#apnҵ[Q]VD|:i5_Kۏ3בq,{ISO/ w\}ԢHN}s7a)!s, [ .6lڳguAC P}NȲ'7'=a݁t_ :EzgyCGykW_}#OSO=Uz\IU?sݣ>Dž^yg^rppI {S! `N <ӥ^c> wUWMDos[~f>޽z /Y8ȴEmj4>?NeᄊC>yz8}޺rclm!)lZn\[4Y*e::(`Rkc|" U+coiC:-i>8>*E$G ZKymwy衝|Up]}饗nݺykW 0m OЦϻ;Ku nFO] g]:7[@}=z>s<7?>/Sg3\+I_>+v]f8r) iiGm#RL9spł#b%%S+|3+ paHcK>_}x6W=_&OvR.N?ぞcttB"Fwז s} G/ Ӥv0txS&͑=rqǹVPv)J:~(fkMX~G_L+:n$ߟJ0 "*`-DIHv$#wARsP?Fb[t:e$Bgs6zx;XJhIQ[ӥ$ڝvsse% &Z}# mf\߼k4Z8Ѻ!4=3UhkıV}MB-ʕlZ* `6?}fe,sD&}s@LvXy=H6n }^kHтsךvLY7m7܍z%w tsMduanͷfuSfsC]'ϵieҴ WȀAvi4־Vu46@zUlXc4;X68 m!*`XZ>Ek yT]gJ/-U$Q&N,ysCE-0.3oH46pC,6{Nr +L ZZ^%GT\=Bsو?H뎎mƦ ڹo-0N(Fz'ϊ{N:u݀4w6H)sxii SF/iLdsl*~ZE09aڻ 9`J%lkaeDۼ- 4a0r* )-spxY^|/1a51āÂxn Sr8T4y ũ$6#WÚsఎ7*~IN_- sSqBn>}g.v-r窫TbI,zk?: S,eb>[QLHih ^2X ׵;'5c=#3VhVc5sekP^+G3E ks5)6&(ul *Jn:6?qcYrIwE3 ʅBc-|6M"Ze˻sgIKER"+ F6=O5*O!Ckحf}HG[߱x<ɥ(OD͹.{lfks9:"]L\*O M"yPP\> cJ& $qrUt888np7קR=sR6I\='{etU*lm^6͋6EC:H8$N"i`A5ww.XxWc= UiUاas=7?*]\vەi:86,;'I[6Mf!M*5 ~y.xg<gNCgm߾}baDHIp( ,˓ n׮]v#I/E Ryӥr9,]={{OLq}!(x[Y\ô7fL+ -Ժ|WLż6SȐҲӜYo͛$| cu_Ը·ao!2EH-6خygԅZz<:TQs!͆`S `Kpވ6%T('PQ,戅h-::?]J-1ޞ)!feHD'(@r e/vJxC@hb?9lJ9% Z c\Ja4R aPo! ^0o8Y=d]>6rwX{Ȭ>Fte<ڤuYD~x) T:0WqF `vj:];O2śo.[#`aG y jt7.'Ę 50y0PX0-^B8gX}j5pJ}Dԩ~ϼ3ܠ)p`F1FI禁<ͳxC{A^±p'^SQ^S[+%.v]szmhJǴ=>W\r; [gK|Nj<J?}p0yfۑGYw+Z4jT,;Gw,9B^tt<|l߬p)g =M,*TM>$t㏽æb'1@tgYeZdL "SJqT87Z?ESl@p0Tg `<\A?B!;8B:NIh}*;Qb.tӕtM~׿NAP,V@4ok+]Dž] ~Fr4ʹ |V lD}-Yhbo 2 !N_Vs|upM>;KϺYηw-#䕊#z衒S+0@ Ri{CM ʧ^b0Hea 7fz L#dD"f6~ך AYBȅw(\7w&O `Q(XPHgDD2$:P(2]V6lmA26NhoB%롖O>[3ٕNbW\R-EKs:uv J6;`Ls2U*B`NE!6{c7c?/ɻy|׿ ҲVؿ蹏VZ xcȔ>ss5GҭMsTBmGAlԍΦisNw%w(}CI7`o˞xb(W o#o3eO Pڮ-L6qv}1Mneav-Z?m\!ن9JB*mF<}^~XzO m;,&{ε<0e6s%ie5/H?-R= ]Ism #PmnLѕҪ.I&n gҍ>Xpl& kC,U@FЇT .R0pq3q>q50>J(WXC~HgQZxIQEYWww@MQm83~YmFC=Lx{g?;$\#Er( i #Jp6ҿUB88 Mu8 b ݎ;1^vmL 8l]=0<`4o,W\ញgDo3K/Bɶ͊fyq$HcMwvsr-zg4^n&W&xbKk6=~_,1؇X=o>之>1uCŖ֦>ZOE!ɓ&\>T} %&S0TPTcFQ 8/7 <I.ؒjI 郻v82VkC"Йt@։'Bcŗ^Vs` M=SLӳ+# ؂ᆝIZ60 h(^#$J] 3ݕZRδLk\G8J3)g%DF3jqTM<.yiIY؁:qi\b2T0"|W%`;k4f_kH>(eg|~&z'QNM! )*ؿ K5Z.&LP c|"4fnTpd(-BFޚJv p] M}$F4^_KZ4ur8W4&p&Js[hQ9z?7hƋvz0 M L|^zmD ݇1/ |9d7<{29t;}EE\rɲ=`o:Fs"uGTuy^C5)p}/sJɇL=27[sL}/ӈںE*W,إ(E5@ff>KSӧgK "9 x:^v ĨY`Jj>Xbdd@_އXwXۗ$F@~}{]*u=F3|p!6ǔv(JHDP`f/CKT!_-h\&ºdమU9<x#˃v[ܴ9  x `I>KJ5{AZZ' Z1%2y>Z`צa6!/l6X*#6RPOiTSIEȈ Υ* *i;Ͻ[T `=B?–ŞJ8-N}k5肪}kb߆&\M H ǐmk3g:Gm &szE}& q<޹8*@4wiҽH؃[Y!m>Cǽ}֮u^9lRL3pFRj a#?i8o7wGsƟWm).UX*@!S.CMZ?F-&NLgxP*4 .IHt+)A\3i&-yK.?07q dԈv~" N|_ܹNoy'R Ɠ(¡mc*a&zW?K +?[LSs=шxuʴQ0BԴ9gI OdE6Vx1EІyXb,">:pf`9F뛤cOE$ c%?ZB^4;2x%/$u(FZl9"F[l]3+ϫ_fO: Mf꘯% FK P/Ha%P&(u־"(pX{! Eh޽ҞI4SIW=n[+g|ݮm[ZZ2[O fCEew MQRK%pun(\L9;:Mb݇[ %`Kg|,%1& (jv~_lFOOxdfZ80v ύ#|w#*&wT:Ɲ*iv/g\w)y#ؒqIYZ6mJi4˅>SR ;'e2N.ƟV[[3,Y+Im7-ZhQ6ji{Z]cIn{Tx^ԭ]qmV\@ 2^kT%{pq&7s̲!6 &ʴp`9K0'jt*~Ag[OJBÌ=U 5IJ,X(=h{\uO 2fl{Unڼ"+*[m $ !{@yEBwa2dH%T| ~t Kw]_qa&/w$/{d+ ֘hBM'c;Bdì:LhLSHа3#+mq}WioG6m0ymʞp\1ba8el8̑jF˛PkM)j:Hl:V d+D|J$Ie .2`*Zq1.3|F\Xjl>5Qb;\cDM7g"u1e3E;U2@ hMrE, $"xοF`j)|Tl0L$M6Nb :N;IcF/Ligz z + B# HnAuu:HCL%ߧ;)7dCq{uH((+gOp}SI9znJX|{:^?LWNJ7(ηPѣO?, m)9;DcXeY ĩ\V¦EFʠS3 p.-:iAy0BÖ-!9S]5XK.O~D->It0J+}6EMkу\qJti5~_@ߙj265,.+~hi`̋T!ߕ)dCZ9JScjv1cqe'"6\ƾ2Ypn-JR!nQׇ{gXhN4)Yk6o9)"A(ĔG\h  4q#&#B/s*b-g|P&vp ӎi9mg|,80Kȍxt7%DVr&Z=12B=4Kjk 2¡`ƐC;Ox^gq5ֆs fќ)ڋMi5kV8fΈ¾ K IcSqm@,9yRAHLC u<6”&9J/0|l+V~G`vIrj2K7Mč)Fٿ.2'd8\L 9Ч~띙wBFA8Xب\YŲt AZkLa *M8ذF1UJ#R5|~gnxyO幤ѾhXjzC+=iM%,5xmt +}6>xev/s^hE'W6rӸBHi] ,=gI ܒ%9jTk<-,3$L-s8H,߰߸I`}K͛t 4Xƭ{NBn RXsiay*N 6Rhm~[oRf*GZj&&"nzIחn}*M~ν_\3/Q|k ?QC^ۇID1cЁ3eɶ658z?RAVsR 9qG Q<{:B~jk-G7wmӦcnkog-x{phc+@@`w SmwZ8IRs?^%@B7zvxɦkѣ]DY4{.1r~eeMf| M,s!3(%}xN0?fòac'.zײ}N-ۆu}iy~^+s0Z N@Iu G.$agoE_7( #_EXY#>4Z}>ȈTj)*iNVɞb}ϙe|-^=L/ՙsB ~uy/`h/m{TM G~},??>P^x}/+ǵ]+` "TԾe6-G[~v44W&5Ma!|>yu z_4==l3ϑ6)ss}|΀w$pnjs+քO=,;c&։%xrgC=!EmۺUMgQMz#YdV5ʼ]W2CV̚Bۚ)j(WszL÷ߺI/ noL4džIRUQ9{l0gb|mX̶vn4o*냲q[M0*8:>ƞoEl< @99.bharnֱg3”W/ݓx'_׳=lu,`|'Tc@M̴&S =A`|\jKݏa;kIs9Al8*Pdd y+R!EeK%*ؿB9V\f22TT)læ 3ODDZe=Z<%"4Q prr_AAbXk$ބ⎘a*Ny T.4ozBH0U3H&L5u^Ken!5Vʅ#ܯֆm}U#W҈:`hq3wlsƠ+Knt+f/EH#&h/k]_f{ĩUn:]3dzs+Լ99 ƬATN̑8]atE<5D9搫 bMt{8_us")gsY:E{Qe~_O eEf4ZnLT+mJn14mMQٖQKR'A.33)dwEO{:@tX.R(iٵ7v㙩 ƫUXҡ(XѨ0[t ќ4o~v?&c x :Mƾ7a+,Ao)SuL̹&Y㊠A Xvhel"&|6ٿޘ@cqqfZ8NRAHOċn(^ܰG\A?!-Jr.+`m*9avbڐm]J7cƸEa#m}} ;FtkqԂJZe:4Zi lHӢJ%O,83URa |i7>v@lS dqhs.,3i5uhڸ;[fzVHѲo%^MvmC/e}&2 0 9GLYوc&8bNl:1b\heVH;D@%L(,\0 N!Ikn?2__o6Ф8l=όMMf'"ZXDJs@rS x<772жM~.`m֏2 09ۥ[7&3+'\H ]o=X׮n6(2KLYd{۵ӯZ׷S{4.|ι2[a+r^'[h缩4|2+x@yT'ʹ81{* `@a,eΒM'[]kٖWי=!qM$ )4=ozMO=忁9 E2ps(m֮5 /ts&&0Z.'fK*Fs BD 웉W x @/h3c&n6˜g*VkӦ0LAOXo2\ 9?Ґlq%]6/?#yjVK%Bae-D +O?ݗr\/븣v3 sҾͫ^L]8+:)X8, `+Qt{vpD;$`^MY>V4%x(!R1gO/MiF=w̨_H ]nRI'9]s'}3&0ň&yCqD?e4>I#xubb13I t]M*)lR~$Ϡޖ٪9J9y=$l*FnFk"#tyՐeALF0hmv.h:QH&o{n74 18[9BIJpd&2} boAS4FZK*=Ni`u+3+ ODɻ3.)d؊+[נ436m3JGǿH*esƍs&ꑓd cxc\}: //x@в_$^vYm0ElSg  6n+2$hnƳw73ۊ(`3rE[0QJPK wlڽxv&514O$I )4s ų ?\ʆ8R/ +ûhNf=Yϧ}"?5Qp{"|XIcLC8ڕ`B+`N6TKBDwϸn^p$Ӈv6xr0fR^\J)*M6TIA8~DϻGLk[ھRBB Bz NI󘽝+f@n ٤*Revd qU&%%x^H66.p y#U({bS oX>2CIL{NBjc?@SkE5MRT&BUQa8U2gެM~)emkC GRn#(l+t'IܿΛ0E -' WJ$* %a"ySSi%)f|(Ɠ* sqhsK?@W*1xhIi Env B6ְ#9Ǘx~9 %{8fbC)1z-4-˫>MBVܫwjJM` Ѽh5erT"G/Ըq@l[i`LAp A}Jr9PSRe}_g-̷[|4J$3fxbs*juj~^#6ڰDw$4!p4Y}jx]{J*e)'0f#&Z$>w52W1c6*34 MC- PbYˑMhum}Br]/q"{@k᨜9l7.4Sfp8ĬS7YFilǟPI{>Tp2yc?~j ڜ9HS9̀Ch Cy؅6swb`QVD7s L/NY=>ea͛)2 .Oĺ ʾ R%/AۊCA)4-΂VCЄaRD48Oxm ^@w_}'>ၧ5ZϠ\s mj~ Lc']pTea) ''(Zi|A5b2T;}AJqΜϠ5 z^7jU_;IkT?_{gFkO+nXɫ_`H#nW.C9@$qh,bl;7*nM~wR_$r%n5NM/LQkh:ZGF R)Ka"1XbdÆ~M4! /8QwrHqGKMZ޴9\[=},xg {m;:`t_D!]F+5M 3/p",i6AW#)x>4H?MAࢠߊcb!J `hԤa#?UgIsdOIm QEYv0ɒ"vj9CfhG[e[3QJu'7'!-1@$tNCQL`՝IН_4vq,$ܐXn#|%ؚkg{S/+SQjTfccR,Ī'@<$]kM奨|:Vl$ᜠ2B[()1!A έwNS@n:lpQiTZ%_s}kMLP){s8R%8S~?lNt4I.#"K ar"87N_$y"a& Ƌxq[e`~lԹzft-(CO{^/'_YvيNy,t}Rq4:q.ؚ Ƙ&m@\dP4y?ϮzWM}n[:Nw/ @sh^Rsq،>Ծ+( ;FNjWn\q*% !qb8A L̑^ hޘ F(+x1=08%Scci5E<&cad t. 3FZ=-xJ)L (r=PX z x|^sM5Bz)o .Yv}rCa/r*MyiT 4*0ݧh{+GS>!u@RƑۿa9j~2\U܂7Fr&C[IW8}H_goo}Agk򞘀`M킴7 v3tj7tAs)3$'pJP޿7.Urq-,T){ +ʐVtݮEt&׮JPh+c\O h\A=<ݜsUp\u0+`K.Y#yO^_80D 80E ^l1}0ߕ74]=?I"{z+Z bj%(]If`.:vN8T)3cνr>?sY4ێ DZe۶,򜫵ӝ!SHA6ؗf]0ذSˁ7J%-"=7&F`aӞcW=Ŧ< `}:M7@L O>ֲjpdr UԸS6dk>D> cS#VrPѾl$%jlTKuHEv:.wo镬{0)p]8<^ֺ(XZ@:&Դ];:qOyNS8S?/@=7VC*Ya4g<ܔe\M`],Eâ&kC /]9l‡@ek$YIlz\یdCG=Dd;·ʌ h_HΎBG8ްƾJQ8(܇H[ ǒqqq4E gFRH7]Hx! 3wxֶT.sML6]j a{̒hs<Rn6=C {3}Xt=xiLRD8\GfpDkBjB[tVM @ZNĜ{o&0%sNs 37ש>K){;M%H'xiLߐߧUה){ |f#TLG3@PM:@&C ŚkYbGTVs0jwIE]É˯{2ϡVK^2~SS~ha&iPfEz&:X=$G|5-5P!(u1DZ3ZH9jhN˺sft Rx̭S.z ݷ;t̾1ԓG 7 3HLq;>ޕzswG$q,r>e|y&h MOZhj;FLj -Be3*+e.=?;Ӄ_76[DGaK>X?N.<.k`EƁ-[3TkDVR1OxB?33ϱ;Rm`Ѽ!',da#Itk'օDNN,( &'SLy+#oTX΃U:^x`&R5zw]g .蕍|6O+?А}K}{Lm|%BiTdϠ!L%n#kD7MUhov xV©H+MޱTŰ{"@q1`/% %fڵyɁh 7)<{Ik@5K{5Qh~ Xew `lۊV,}%68 %J+uiCw/nT7n ( KPRQL[>elX)K/u3=a2)lx6@3R 5]c`#Va5q*3e50B01_u\Rq62JC@!a⢋6~i|ya' ܎;D_PSgv<NmSwxij[.: N ԆşN>sl45`6(V-1P-kP0)8$v04nG2RZa ݣx *PcnRCZJ=o|k0!tDF/;Q]}Ѧ8غJUm~$z<*c9UW BJgHCM xN%q8-w9])nJZ $-g 'b+rosS yNM̍ :!ا @3M9}l@Hߙ0gOw^OE7Hn5U/8l^y.R&(>Lc>B\td;kʤnvkf,(Z8ҦySZ /VgC'b]TM Ot$A/"jI k39Krf`\jSKOϓ>[x!ꫯA ܹb IV$m/]u׹VQJV$ȧqB٬VI>8pRFEိ}=M4ȃv.X;j/`  xmM4q] o aA?7sCܺ ݰJ4D`ӕ$5Z5U6 LQi1ZbmmljQFXs=!#:2aw[\3ˍ4YdLaPy:42שhaUqI-CUZ(6sn\ T*-I\RNsdon~v)b[&Jc%(Fݦ.0Ut A pCRbi؜gU%?ӫǧ TAT*%μ@m1xcY rW($B@w֢KOh,ڜ !M ~R Y}9oTle:49{Ӿa]J ].\)`x`R=N9!xWVQ&lFfR]:0X %;MX$ ^HJJ{Wm{D76$(8k+˅ {N"ΒXyY'Li~I ۯ0훲5NڪRGkkKԀYd^o5s| =4SZvmz} mo*\rPm"!O,#-x?Qק$70RϪC_s9m>.]W^}~EhSiٹL1"$ Rb/XIn'x/jd տeut0T55^U3#A ?0f{bC[;pF!"o"Th+: , IwDfCzzZoWϓ5j%$]5A,RzgrǏ1{=Sjp.`[ش0S OXs4쀑#ƑE YQ<|x'ٛ(} [` cXppAUS KX`\kq\Wm0MxSUFqWS"ׄ;{;q[xIgfȳe49MC@O`uD`!sk&(+3"u&z1w_cJax22)}LH?;lc.:U43I .*) CMxad~ޢ3i *l#RG1 Ӿ8ޠ̩.ь#/ƍر9{Ε#F@X#/NM$kc$\{ w=S*%+iƳfj@'(zpb{[9)ڷ)7[mnL^)iM6u(Ec̞=YA u 63~KM^ۃp|Wiu$:tFIbQ̹UR m_[ 6쭷E;rciJ鵑ߴcGp@غxV㗩Sc]hAFʌi|<&݋e'()Ԧ&LK˺^z{Nkl TJ=76a$ Csg}C!}y)_-q& 1CUb7 K S\!b/u xt/y/3l=_4!"~q{iX TSؚ#jeCR!cPv ;ql&e0զUgO5u\`QG%d.ܦM~ xMCM #,DxLF jh4B7$N8NŌ6Y oݫhF8VePlM|?BEF [3ڿs,& e bk9ȊDKYy!vĹЖuP01,J&a 4^[Yܹz]Ⳉa{x3{/mhh|HCjJ'mR؞=oW[ oĠ+cW0 ;DQ\Nt%L:^9~s7 { a$zRAa:9tɈBq8һcǺdWI I7XsD/CCJx;ꃜ{5Ck:9 5H `NG;V'$vV6cy {̹ݫM~>;kS:S7.\;|])[ haZMkPW0v''£-k =ϱ %;E7O;z?to]`*E&smۺbEiEEu 8ijбe v(ohS&qz^R'=˜G60PohL9pN&XB*zJ?^#u裮L{ &yV*֣K/6\tEKdh:}Ǚ;o:7͉Ҁez>DpUrbTsJ!q*)uS%0`OFINdOH+B/4یnb:yA~KBpІ5{-ޗ\2;@6X*i-EgW[ڄ C`0S91 tx| c ;uߝzu9m3 xYP2tZhc{YkM}^(Aj ðuD l%Y{f୔\_,/6r-W `K[(({ii 珯 ӷzRndz`0,H y؇Vr܈.&nGx0Tr 4$@^;!0<fDwd6g4IJ -J؟ [7Vk\p0*.BhHXCA?YWݕ:9kRiyr?9t=,YjMg{wdOH_gPS^%QZ]B@"Nf[p 8Q4Vw$+βpo1 ~y΁gC =J#'*7F QK {;AϊGgԙ#KfcKxw y5=}- }и0g mJXbiG7̐~C6FsAWLJO}mO-6zQ;GwWUemgQDz C);z =$H BBHQӜyrsrl|'sO^]k!c-\Z@UΙ i^~>GluN)cIM :\h{e7n42ϋC{iʹ]_t$W =ƺT pRZzWlqܐl+]`w8# )UrJ͸L7pYD_+& `:TnHY.^T0JAjTITe=~-cd9Ōp z':BBT,fxS8פ b[R^sJY۬\p`a꽵`4bZ;ǧzO[[ޭ]PZL٤d q0zHmw'{lڶEHO=v+ZtwYV4/J(4HꞜpk-36s#ûlpz&c&Tn~\*_NJu];QѢ0qcbGp'g.C1Ko6,C{b ?DJvS!Rv' U`*Ɗ&=h`:'NDKJtM)-2'6P&f?vctSyx\ƆY4gۛܛ`LW kPGRpzL*vjX%+A'2c3q~وJQ(!ɛ |^hh䮊AU FJ>)hT1^kh,f[hrɐ_$I^^ƭ#x$2X佲&{h734Bչܛ@̰I޿B6WI;U^툒7=YO-%nH Ѥ.{Kո 00I8ZZVMy;:򐌥[7/$} dsuI,]<_RRݥ%4p£z(Ɂs˖z";@ r!Zr>ύN#oBfS"@4bId=n IA3YI9GḼ/5ɂ=aVJ('DgmoTs)qLj3<[m#Sݹbۢj67^)踁pc&JfN^r\^ k(tF>,3_攻لdeLWL1_.K%Z:]Y%Y@F7 Wt6z~ -OJjXf)M"9f HȢZ!@  ;Ϗv3Uh[BU:VTfPͶ[.Z6jሚ Cf6"(`u%dJ˂O;*Y a~>K`Z`F9\_ V[x4K.!;,:YM Vh-l5{6?dk?L ^GRr-'VN*GnP@Q[֖rOE{mgA>ů[/y@|TGFU1 /yWzmP$>zJ3g[ >=ͫgsse4<)vhGWƜ9;"\9,!cQA5;b GH0ffn_#55l'k18uzV\^=sgQZ8ϕUiK})M^pO:5s0nOZ?'x"/457Ӈ-kC3&u=0K+hMa:;)B[iɃ|Z\(C*Ulv_;+ז8J/a,n"\KԾ(Iz}XO2% __)4B635 b.e;sa}Oo!)O B}_6l."s^u,BuX쇳an/y $j'$Nx'oDM0).fKs^ˉ+[kˈDc!~J}}.DOߝdt`0g1Ӯ&_*3=Sȧk޼Ygɽ';kH\R+o6 ӛܬiWӑHrZJA PTu6AmS/m[[w2L o3}AӞxy#yGeƐ;,7ݠf,~H +9qC! #cQQ /PHA1"e8WٴOF3Fa-prջ%'H*6 ΉԿϗr;u7ET1t8{DMu-] [$}?V]8B6Z̹Ҹz&Tyhwr#t[ Yn|߾}L4 A!W1y0Z乺fuCӟbױЙOۤUA{,P|=ϰRKC`P/ 4((P&_yfs,ϴ֤N[L6Ws.]M[yd*`غC)Eb4CФh rĜo,n$sHsR8wPOMķן[TudDȨ/Cw#υcn-5&.bR!>30/4U/*CI=b Mj-ÃlT9)YF%2d͗Wp͟:٭iT+9 s@/~6 kWv'T~&s#J=/Ƌ53 NzjYgaY|!Jޙyev"]a.=2ìPk -u7ϟ,3ͦc DX/cd˜ fI0iFWMJJJ78æjl:|d\0}̟(3]7\_IkyKKL9sZwNV3eeyHNeKjT$Fz&vK?E=dítuMn/?Ќ=bf+ZTp DZA{1]R(m;hX-jtz52%z͊p*Ҷ#L"-"Pd.vk\@)7f d6#; )p(/M~WT]p 8Ȝ B=1m.j4s%GG:J;#OfCW5P9|64JFM5AuѤDmC;OTҫ(ngQK!U1F[45J vP0LMUQu-$=O?+#ؿW}lI{jџ`n/N7)cF;1?XiwQnjLXXF 3A4.2TEA;Ejn4^O} eXXi7Sek֮Q&dI]ު*G&K2^.x0fd.**U;>=/hP3/x.]ڼqJ ?/Y{B;τ \6jC lw*rbٽ*.:1}IMB{wW'zP|2@&ok8s2^4qD%"'Dunjp;=~h}5f3xR"Gyh.C&N|ڶդA}clsֶͫӺnp/ ԆA؎g`oJrژT ן^ǎ=a(3dl1R}5'כKR;|n4]Pp=< vZ\`&zA͉W>= mx%xпacl d\sdQx})'ԤBkcs ͋%*CLc&cPRGAXZQnx+^RV6ܹ pMՀ|hVX[ĔV\pd?eo,Z~/i='HzTqYFCdѯup" >0ΧLMg A2[5ǁʋ@MګL2 ?wENqC@!sl-WUEʽH|}dk/SZYޕRjجqR{nۆUkgPlڮ g.ǐ/ݷR~:8py:}1:VHU,dRٵTEe؄Sr8c2+bi65?6ǸR 9(㍃o(mAf3,5SH{gk2B1+̍ K`G9|oYPt5)g{%}Ytp6GE}1\ Ԛ P a&pe )2j~'eB2:BVEhr!(ļkL ;bVVGvO%Dj!ڊ 108O_ x%K`hݕ%Ve~<{ W!vt~m8Pbz;$DU($9wԎkUhJ>XTzS}t}еlg@r>k由Eλ9o]xC:1d엡lask(\-Z w9Qle1d[ 5OęgIjRhVq^T uQ.(E)?ck5DTM/l7#E*B TԽDZ{ss{l"*ua hR*++U\m( 7mv2vp^sfeܘp?>bS '-E=똎7el)nBlZig?)MRj"`Nt%:v؃uԝSn Mlx!jF&hÐmN6̋si bIO<RCJ{"&[I4 Z{LtF@SςU E^j7L`9ܭZ;a:$)AHaC0N?l`o9#yLǜ?"h{uOS~4LەE@Q񧟪>_IiO0Mdǐyp5ܹ"BC.#;[iᎉTU3#Ieuu!plӸ)2" F[aƊ=YZ6c2@r8zUb,peIRlIqS=#LP!s71w\6Mi8!{ƫd' Wo C*Q@9thi2I,rt#–t|T4 ٭ِ6=K]d>u>CQEUQN2Vd` Kh:+)XڧFC6aǵ,R)fzUE͇&.1v~߶-*&uJiw\Ms?>D&?$Z1~e+nVE|9 9ā}+!yPwI]gR< ^>M·6;}7WgEht/*F0C{jcɦ%W+dڈ{4ELy߸W/187t[ɔr)Y b֯DpSXQJ_7q9^Qv,-[T4YK0>3&c2Fhw\}_o 0Um+Qw٭h=4^ Piwrb?c݅}.ƿD[_asHF3%4 D4p.f+Ŭ`ɋߚF %Gw0Vv^;VVwU2D ` ޒ2$&pMH*fw ?\lNKZQ-o)y' iW7 tR ,tT^c8;FF zPRjp.v =A`/pe4 (-Z@*(塱 Mu%m>۵+f=ּoQ@u1S -Ji/݅?ײI,&;Qgͷ4Jn :{' EJv2͌c+)uzVt_{yM3d6%qo"}WA'&ئ"h #"U5c@Es5*Q 5Đc0HFJ7H\;sehe/EW 4{TQ)5jrχ=5ifDԮ(T)~zERȿba9ߵ>}+tIvy1srjYNt}1n<ؤ$1r&,nzaM鬀Lۓ 'ߔDwqXwK5#Ć}%]S4RRyƦIJ&~|?860U J9Nn]}ve&p 6{,;8~{Y'1:f,A]6i-LSTh- _y\{r"cКA8ʭf($ U׫*Ƣ|!i}s`mRf(X c֍=19) {czhϺh/*U^"ZJ(? gV3\GT뗖٘U8`I:Gm%!ETѺX޵~k8鵖c(z!>I\!_41OtdE1egǬrQ&S۽>@#ZpgAEu$Zc9ct-!m|ۊl` f+"2_{e-gȡ6Q7Qů}pj r@)!e~M qV+ icKH1Sną-8׮)PLNsNW^H'ȜG+ce{k,pf"66nWQT>OqA/N{Qy yjeBW!E6ƒ"jo-@(VWX$rr-٠7@3.7Zݧ]g_](oE'b4WzH_tF鎥ﳝTպԊ" S :[˂|fꗯ*x}f.w2(HY)RԨ\,GF `Yc9^22Ams.mf (GrYX+/J *ɹ}ҤRșSU!dzcɴYNE)I^'[9t.'j%TbLftQPR5P;6+ek6%cג汚Uo57zRIfӈqк{k4 (u54az#C j|f:˽6)hlr%Vɜ%C{Wkm!ɜ3Ues kS,B>6. S=%̠C 2*VcG&Jf5ݨ9z*BJvҏ0u_$Y?|8\^[;R,*zIaE۝IH ~3MB&=Lq k(65rYxhf}m4p;˃%9%FMYaUrݱ&UxQ =2 yUZPSD핀%Kzԋytd(a9)%5ϛ5#`xSfЉPmYYBxcx^s :c?E#9v|,QJ 7]yz,3E3fٖ}[K;n]wXZnj:)bW5Կ='%c̭12o~y3ѰWC*gc-ؼ-yyA yWg^lU͛ t=*Ay**1C@GD)Ulx,*'L\+{)*sףa:k~8j}\ 3%]LJ|0`SB.^,M@%6?wOnDi\Fyib"N':9 㧂 *_M\3o o>WV-ghi,x}B/Rۜ#j)5+c㽍pj@*uѶN[_?ve vz,3`r_ziܩ:\hON|q[e+@f^ MD7<^n,te(M jI x-s]/u9잔r)e)HiFsЊm7Jҩz%2Jf[WBZ7|"[D,Ze*7\ЩvS2qxܝ(t7 5DvPZvAbESƑY'.N#fM"7bT77}H92&*c J1Ssa(դro΍Uy%t=ҭt6^U $f~[F`ݡD-Ujw%4 ܵd4PS,DJ5֠֩7~"qia-^DQd "c}*L֦D5-Jwx8moCI}vw$a,R@fD1|Tk~9j|(e]`;؎ &4&Ja[,A|TF2)mY_+cBy>6/tr9lô*0U׻cǪ lWu!6'#QC-4=aj7VwBoQ)y^ѵ0w͚5UޱcۨL|1E6NжgجUP Nq#&"Fxyo>,]Y^zO4.bύ)Cpu|8w"s&*lDoPjr7u;KeZ7:;&p:+#FFq-P! ^P;3譮ޯ{E񶌜Ws"|`gʱcaZfVzbn 1X"<߭/V̫ s;#@ dl~W@<11<-'׉;xP]6ɘQ"$Plȇj7%O>{>7Hqm%( ٹYɧn p^=+j4mRl -}_" ^ V(/|4lE#D *qxGTXȭGnܙ8L&N ce2e@3."XSv{XLT᏶nUF pF蜢&* _iݻ?:L0Q5TS: `AJMkNn6ڪ / 9pM@;Rp!3فeQUz ;I_9HU7D<9T+V U˂R`͘-;19UnVr/;AZjjW&#R;#hf$-yKϥdVqHQw%tn8j_i *IӌF#Jj ff$6p&gŊ"lbGIZ{޿pIS higX]%HXZzqAEW^eJٳET'НzVvɯY> ` \wUL$xlg. U UIc멩wZwJM+W b_Kq\^ :oxC3|5,>߬F-1Wu|)owSl3jc/ӱt*sRf4~/R#q~H,h#>N**^gEEu*3Os|}}x;mUg!f$P[\ g@CW~:Ms67>r}<05HJzsڗ.!TǑo-%~Jc֘OTSuRA2M3 q~%h/[/.N'qIOi59SvtqZpRLkDzB+ ~W-5 C <]I}~tWT'OaTN6j)ޝcqBwuEL8E:ުõnR < q KsTOdt2jRz1ѢF7Yw~7r8Pm[W^xh /Z+eH5^hfk6tSsU?;vdƥShoصcw,Ov\n.^/|N|}7wD *H"貶 VnXۤlbWE<^cq\N_`oQ"p̍vgS 2 dW3>kX5C[ X%%LN'a Z{lڧ3xI`˳fguE~xHEq3gV=V4:M'7 /B`9s]Ek(AϚ8Vo ^CA~rh"-*2!]}8:Awa% kZ]jig+j*h*&c͕NWdXeU:>h$ Ŭy獙qZq9a؞9.Tmjpyx_֜7Cu)3J>ZXEk^+NPwboL1EU,bK4T97᛬kU[L 2i]4ɗ&йBc@c Fx'M1/Y5 /bIcY_MUL7LLR?Y&XXsm1\LEEYS^`Ey[e_ol 5Q0TِF}?N.PJ]Tm胮 zZց[ %K']˱X$恄`| _Ӽ*FR'[.m`fhcJ{y$`՚xP 4:Wh* GJ5fY6*x;#ˊ s+iGճ(RP1]lFtǮX>7@羅_H 4C:1L Y3bF'VXNXܪLJ@:x?Ww`PA*fEÕ~3qzTxK+<k7VA$.#F&M/ rj@ K;,_Tk?,4x] w][g<1`;0.%iѣ' ?$f(h=Lw,ir3ˎI֔ O`ejYk)N8ߺv즳;Zm`$I4LG_Z\ +m=l0W FChvF=}8ږ:{J+q.6V)~,`**e1pFPk#h\s aٲޗ*bؿX t)AQ]9gcTu6;?XŲ] 3eL%j*VXUetӷyq6Z{;&Tze_&9^f"6??n7/: 5`&(0[[R[؟ۜj@\2`UUHgө綅f*qaSNUv-Y^zקpwhZޮh>ȵP`IH&V,>O$Rtξ޻^ J$’}J*YEl၅0mZ 6(9|j%L Xp}//52UFhWHԻ-SuΩk51!h3 & ɈVLwN&.79y̓Z!y`.i"ڬ8z%ךoWVK2u~DanNS2:gZm"dny N~yzF&"NYp^)L, CRʮzV{B4C3%T`^0[*3ݱG汋᷿Ui4Hh'sͯ82ט7VsLg27 mό"&UꞪ >[/Ѧ#5v=`V Ky]<^pI=dx' ͹?eiatqb]]0pؠT'۬l^;FfE5e3qJ90^ ]wv,~/Ro/F qztkt *UE+ͮ0Ȇf!rEby2aFg29FIbf\;+˖O{0p@,<lbxV!htU24ϲduPO&5kkZ#Ϯ^쵅V88t>(mCt jܨ&0Ćsd7D}UYW&9C;v _,_93O?`[gDE)5켇/^Lsl`U)}&i|3e HmbqtپGIN $ P1; Eu1T38VfF~E/Ex2.i| +uPAXG8Lٝua༠AzD<)2֢B l(c-㬒tJ+QyԍN;㘎QnŮ 颃+X *Z[k!6Dc+ 25z> Uנy"gMaWneFɼQUPjt+cgOr0\ B +aBp,+ɖ/ݻ wõ,$2,5|kLP[47jds`֩~80owC~`czӲu So5JY͊am*"-;{cy|myT'YGl:|x J$ܘJ-^X#述n*ϨaDcE>ٷO]_E6ieup*~ n̊EF=eljQuYMz(`H-? *]AUl8d/T ;zmcshGEԟ_Ͼ,*\TBzSkN%ǖWDm8[e˱iFSlG7 G D& sR^g],7s|.snFFWnMcص~d pmKʓ6XDaD_ьTJhr$Ni?[I$;VQb|NTݺa /–tR7eeO;|)lT$%*dY\ʠvAH>2ܠdi* ]A[1/ͫaj=zA 95yP_&a*^8&,Ij)%"10wb"y$LT\!mlwYjIذaZ"gӹǪMuԞՈYX)&`h5*]1|pKC$C_ڿ81&qc{,M'L05 IC۽{EhUm^t1_-QyD /qT&p~|i"_/,x1IJ|j7 X}6Q"W0Ci|r@5;P -X(%m^STұ呧.i&Qhװ&QL5 w)ȜC޼*^{&lIՉj["Ovd88WM²R6uҲ9WWq0-M㌆_9s _כP_9(ߥ*"913-Cqs ךt[k5#ӖT:N"Sl&F|ӤZ3dyu}_V^ʎ-zS"es3i{W SX)ǔˣHG-BIlc8XcaۘW*ڟ3f{/"ؑ]1I9PƳ=u*Sɸ&8)T1d}CrcH!*.u;苾e-yXCgXb_2IzRҶthgfiC4`|w . 08X:GzI3ϠɢRUUI97l<[lcԧ6Yl"w(Vʾc2PQ/\^-L¶yG"q\uUv?wȸɈ>E39cxo[VL򵷬ݢ*<mx}7<狻\gWBrU\ee٢y M8$U,߸\6׽mThMdTk쯡c:ԒAa2c߲ٽGu=[2M1nT-EM~f" \ :8˒3ozīY8Up lJEzpB|p?"ZHut[@@N&˝0 e>fٜb24@imۦPvupK벳/ Xb&GGcm*Dn6 zx/fG3}IIIXc^KKƕR7׺SÐ J XT}E`\N?*U֥jݿI7ȭzvJo=~ݻS5ʑ*r ^ED #l7BTٜ""4Yb Lzpl:~u%wx>zB~wŻxe+ 1TK,UXRq ^wvP1L(.|K;ph̤y\H%=y;ɿ?j6vٰE ԗ-=e; mh7,z d,JݺuS7 iʓȜ"wU΋'z R_4٩=*ͷkXl,]# y %X|d-Drg4dIjfͥYM-)EKB;3T줴i ~T#!1mŖgcg곋jN/5eIs\bE7>T3{54@ڸ#af9&%k6l Xd\b dY˪H-L/:ڲOMhI=!,Yp-Ub9 ӯ6Ki_FUxm^wR @m#]k*#_F7`XaX:n)'cD%Yڣm_"%|,A,d+J,Vf0Ďb `6zx`&?I['7jիu}* I+f3<^w;z)hLqlUJفy[d-RÛ7WTm.jE{We8<z`WV t"o0qӥ1v;cɁ&X/Aq.@p5@UrBltQSt/)7s:VMLE۸xo{(RL{Dt <ڼ5GQOu,У@Y=0dDFNg<c•.׿r9[}Jse&\tUyi{ ,_up~Geo-lO"-C\! `*7rn-c' ![#GY0xPdN O!q!'k2]pËS.lX+7o\ly+) `'ٖv/A9CarqRE3Ď9 HLb0Юe_ lqS.~Y+Y,D;|n,uoV tS+9՜s4pXAsѢ:+nw y|!Q:L~4hALqRhTУE=l7u*d?Lq6D7w5cj$=9D@<}ɢ&GZ;C+y$#RQҖBGyLӕ7fڴ?(!7)B'pQ+.Ѿ5o;d΁?@ȅzs+ytDqee oC$wa”)}p\S{d$%?y؝zƚ;c;laӂ9vj_58j2F[2rsn8BO/GPjATRY'xVZb0l.3GXtM짲脢hW&5qQz Wh{Cp'ӯ0{&HÌǘJ-pL~^Q!q5&l.U@ صm|*wqچKjګOo7O`O.fJv2a ^NB^Ր6/땾 O ^7Gwɞt&q[S~,ҙm[s&.7Ǚ~ܻQQzc@Ț!2?՘dO5}w2&fH6[_Ҳ aƍ hX-# (s`v XU>jeL= {K6w#5OK-ߤpB_-^2ˀ,YеIWQ} /9Ү Fy,RBTwu:o>pDm8bO ОbIQq hrf3ꢯ[3}9 ּUpB>:Dm]^^6 E($r{{ _ 'r%$۟\M'VIubҭrȏ*\}gT;$'K|%6j/?m2H ϟq`<L"سec kXWhJ S`MÙ`a>h fDHT4ҳʚfaX|p5I^;dtYMf4IcH֓L̸IH)Zlqt}˨ofB`$'"/Z _cx${L3]WWhҹNhrV  ).O0w<+.@ kn>(n9Z{549Iqs';>܁2lBye.6b ͍YdV䚥ӈIWʑSFn3{'y&eeТ'Hz{D `Te `ƅivyx0BTyKDIQ'@QYGZ5\9T쏭8NQ9`@C̙{gQK(+kճgs`.*odt&l AAiaP@9@n9HCG;vlaMqU2joބ7g"OݝA|4iR(4?[R=]ӚK;zצ ם#rW]w F;"޾U9{EkcW,֥2w\)xJwG5-@uI+E?W5sV+ZEclԢ&5V,q[U *$~LQ *Max `&G-hYd Ž4)K٤үN͚rR, \ d :M-fE(Y8.M{" Urm9be'\-=wa4W4K(s+U"+q2LׂfH?ԭ}R l?Jʨqeib3W<"sN f33>RpfI._]Ȩ51:Iʖ]ʡY:Vm.@<;;V}ZE=ԣZQ5 x]}|{蘒R%CwtўUݺc$ fpv!H{iyG\D&D_lJ@Q0S`iD1F*ź)D7w]TrjC'lsy?^{ma81XM(0թ#Dž&m++SXHIJeJdHztZTTMg\ i0I5n2.F3 v />現!uՍBDu>ګm?VFU)^LƵM4XZur蹇FtO\őr1]=F/-5MfFeygwўt^GSaCzfd4Qjx 0T33 yƨީ2V7`TdY1(m`Jh^>{9\(ӪW!vG+C`uSfQ0h̘f躻C*ǪJS~DLS {E+ KHM2\"/)u\{#O [ʍ(]|o8C]S=^+o||\%_|ʕ6T@oUYr6qKΔ{7lݯ~SfRcP ɪixPipVCu~ߣK&\Z SOƀw7pKM@Ŗ  IACM"?:&IFyHT _~q{'f"iu׮MG,O8[[cr1 |/rQy~}7mN~RDh 3*K'Z z=#G&lz\֖rzK/}.f '~$9RU TMt\0%Koᴄ${\*e FV^gJxBDT.=|o,x`^d2?!,{pItl9x;:ߣ*>\җʨDaVcsMiǮEJT2TJ?e@j7*Ȩ!•K7NxဨrܙE[KNTwUm,yR Dnu?}TdkUZoJ}[7ɺvGKM\5Ӯq!7q;RjrEz_?,fݛkv޵Qzɟ}HH4 PBI2ip[3a;}k[+ؐ93#d*cH0dL .`j`Mz/R0,x#tWA%윱%ɓjg\C߉ F6z5#D9F.m0Tv $(Oa85sM2_U:ȹeMTMis**UN BU[/}J5j{)nrͻnya.tZ^xٶ7Ho5 Fx[n6zغnwO?IW;G#tg遣˩Ow}s|65\"*Ovu#_+xpc|3upu;M lh*Gߐ[=3_%Ml"}u7g}DN.2i6;GjU_>TZ#iXhG55LW ) Xh7I") ܰpzN`FT|ꩲ|͚Т,,8g0 a~\ 8bԌoSC{whU9=J*VM 9y̚d̒1K+|~߭\6= ,$%Y̟愈R] (L}@8@*իţoΒ +&DROel{iT?,7s~~dѤrJj{ꫣT;\UOU9ǢŲgȾNn s丫-G!FeGtozJUޒ%q\MV/4G쌉l_LyCL\j=cO;NwkףMkztȶ})bX--˯8 &]gn{}]61a^3I˭u*}R}ݙ^c`U>1"ƺ[d>\3|M=VY>5.&V=~|$?QFʬА~ELISX$s>w~s@ |ګ|'YNr eeRj2QѨ2i#]}N<+#e'Ovj43)5IMRQ$na LK$o]￠.-<)ϲJUH3b&CR=%]=щr3h )0FmVŏ<"$T*ב꺨6k{}IUŲMpXwGL \ewYExnc!mYՓ-7q0-:]혓N Ⱦ>=sRxuWֽD>BRͮocwQQ>F\׫e5)ER&{D'{ۅŸr/TK1i͝CU֙iDJk֔D>.]DnI4a&Umli[L,N G XՖ1$_Erރ$kb<)v&t55!y/BjD9[D-U|=EI >֪,UTrcy/ F^FAxD9V/0@ RڄGK0g"d)ώyVn@:wbMYrʤﯟyt́?Clu{9Ҽ4_YsR6NtSőq+GEUGï|\8¨a}"o~wC_PBj*&yBaլ( 15VtN9wK2Ț`k[|=ŒJiud A҄rb̟Hgʃt&)B){[(lY'}!dlhO)`9E"lP&ag.d_d[a@`6 FGKA0W^Ҷm%{a-!yFzU68H\?޲]#zVK=|Hke?BcGE_+N [Du99i੾AƳ;߯z^/5(8$!j0/:$W/MJk ,#.ѿfADX 憑Uиi$L^<2ߤvg9 b)$XLeJ'쭪j WU,,$o*M:#@y_.,MKʒ}U#ATD=*@eN`5W[Y|}p`3U@Zk؞0u?m[b'E Tr9A*e>S+Z9`Lʫ#{_ΌD4ʜƸ}+؁;=Z m']UGJ+H}ù9k#m I4vJi\CѣGYNz[IAkN)gbd1*iY+rvupYY >1O֯;7<,U7)Hx# /gΔ&s $x:$3Ψejr2 O+_L.S a8HxKTƮrփw%rc Op]Z h%7}+FwR#Wܵ̕/7})+gcJNj95_\w4|mjf8|?)F|rrܦI`{\)&H 3;V&!Q襲QAb%$l)v(BܺHPDQOy^|\Kг<m8jϏ?ʛ %ÚspY;ذ+qc\uU]~kyNE-C˺…믗7ll&:F:"Ij x_O.q_Q'ˆ= iˆzd%j놹ְFRcwonIrIL$Vf@тU1ixxZ;07I:R*EGV;x,x]\zCH9|_,fBl4QӌQI)C1hSK`ġ8i4t\Ayuz$dr'K˥7TkLjwt}\\b{f7秞ps_0FbB6ScjS5I d%[jM6bFͽU6ru ^lh;tFa{I<^Rtr:* m9*6UDsVP GY 3Y=|GJS [\Py@m,O$YY{FqB;Sz wVAJ'z $$e ~*0,/w{G!'{tLK [w2wFGY}U0i=;W Tz$ms?q>'70M W  if|&)MD]j*I/3QO>E4vf*{82K*,3  e˺x)  `^ }:K+ l{M5Ӈg-I΃̀pNMu0[@FR Zd#>U5RqJ5:*A)ARP.5 >)rYc6*y6~Qx@[\s5jz4sR>>r4~hWXg#PS]iݺXpcax9@1o7wWgZαRM\kN!qdb"-I 8:' S+5U7.kĆqP<fƲ d]! eaB@Ę> cNQ|OL˺{R@ Cٔ : ?[ \*s `Tt SCqqظ(6Dp Q?聽KS 3ݻK'V ?DE^1[ɽ)LI6/:[ ߑW@((b ȅ?kk|`̃^ouã斔D>}j;^Ҩat,EST:q. )DPx,ʁUtWΉJ_Gխ8"" )s@QfBZGԦTs[>XDˢvGz>aopV4hUdFfc +ZZB|ӀtQ;qQWwe2XX6d̦mv j;'fpԆttR\ AW`-w `Nf5u 0G~f*l{$KE)_C/H#;W|OPOf,]J<U5浇Jm=, K$AJ 9v>zNw A BJi JM^D잶@0&ʤ}++K C$iKtact^DUٺ猪2WCj~%*,Q!g"M bYE<-L=@!siVFs-s#ډ3fkkQ C)jtL*8%7lpN$TTYsnRe+}E*(_c O0կ/(aߡBU֩JY irY {Em6+4:d0{ΩkS=q=C'}AYhfSWn |KB0|qK{<E4i 3ͣ۽>!;Me0CjF`7|8 'Dȗ`IpApmrM#rM" ѭк1 ,,ElZ( ,[B!Wb-?vJ^KRg3B)auW"`̄(ck׊#2ܵSI;,VÄP3$Ƃ )&#ٰ=QC%\p{0{0R]A͟h'9ߐ`M%F.HԠ?EcScBSu",gT^9fÕ!YUѵ |p:a!]T-FvR?ýO9a- ʳcA-0tr1sVil8))Ӌ!aֿKZ$ڶt7(?R%uq00WaF ah)4gp=Lj2L>ռswO^o=f%AҲӢR^dJ,T9]^ =l}}w*p.ÞXtI9]AvQ*957)*<`kvDunԿ]{HTK)?|GeJ-8n v- Id8ؑ q“L=&֕[/JGZia嘱c]g{uOH!ă"c@RlYs0f&IeivKBuN*ms}:pF (VY4Wܹ3tcyV^ U]K%ڒocSO 4oӽ|ft@i)tmLg I\h@$3oyW6tHAMZnI*ϸXTIxѪ S[d/5a<̣$rNxhS| {) e͚jNMFj @K0KUg-7nI)jOU+bqD~ FA\tȫE骖QI1'*RkI>jJ lYKI"y$vAdu^a3us %vgyuJo&O ]]0_H1c"=qXHD"K%ʈPz yKp(QI-m/2lx88x༇Ye&ZzY3eN?*k.$vdg&y5ivߡ͵A+lnOڟ+dUOx1 B /;i~Czm鞼rjC%Nb$k<,1=RmZeeMU<{{|9Gm4hˇNj܎DƏg0:ԗ@'UZ p &\`bt6-3bq.]l&aZJS)R])v?<%Maý L< ZQI)>'LM{TR-|%uCSuW/1˜zH0dP`;* ƿs {[0|=rH P7 }{xmޒKbyL$o .~4tZn fQ l4ć 'i!= +S*oJIi*)^I $X H ~_-rW;Mуʯ+Uf!1,~ e Ox^k}O>)mۗ{QGnSƉn%5+;}m"o=/͌:I9ȧyQ?*W*Ʋ qp 7a'jG_L2t`cQk ؂fUb.Jߡ^۶چc%5%j鵝&>|BFT$`>Bj#!.$#|2£Tzo^R 6q8faVP݃WM~ugϧCcqQq~S&R3z ږ}PT)Z+zoO1b+,lRz㚉+`{Kv: ·%l7"o:-XǠb!y&" U[rBGBLI5zW |g1r9Zvv86s}e?2@$$t$jؓl nU[?eTЭtHb-_VALH Rp4,eZ&So=^=9ϗ+UL¬s3`GaIV5Na˶Zl8`a7rg6EW7.)N>K:O9\@ 0>1(>"LĞ=mطér,$T?O'H3G~eƕoS/imU9bOΏɣEyqk2>uBV@,sOY[rؔ:i B !fk$54t)rB6p?&B}l EےSZ|:h*yŖ46KU{G䶓OI{iV5۝K%+/I礃v+%Ψi$B'ef̟l6)SwqgBR6^f?$cqcsJ_ZM ~ȐY:z2ͤ0P\gԽ( Y!YNLS/6RJPHht>mg9UhKb?Ӥ}KVYߠ})i-jO 9ͻ(V+ոݷ**Ώ+VbP%e}ibGK`P5y%L|Q=W1tmo$MR0N8g}GUn5HwaB0&JǍs3dA2HSPP|lv'y'>xWw <lUM242E(ڂt6BG3V@*4xStT)F6jb#lpYZf5Qi;8G5ۄJ޵gOU+yfj} 8X`zHja"~f6|x\*ɛzo+莂s,l3\ih{jjTMyQ!Ax*%fk}hY Q/\\Ds-~È-Sl2@q >( RvKVÐ(٨6-)?Hh%۰m| (GCxrR`b`ݫK;7_U-wҭ A6.)IF Z+LyCZRu &WMu{۪U 34IO8Io$}]$].c0er<(2Zp4 ̢tGtD.? \ngJ+xM>)XU@RĠRWoPd`^!;u$8QŠ'r.|U\I%WSk]tmq|: ]X~h 7im3|x;HP8p0!r۴i"}^ mƩO?-e*ڲXC!iL'\t)f2(Ε[F.lYk}BW Tn.Ѐ[4 OV5*_VbEVZ'cM0FFN;M^R\؉VSGj4{C0[))* 9I Q 6l{ήJEns=xYεgLѽcot!xavkZB.RS D~y5q`kXҵ7n]R)A3v* @ѥSNIJ>t=\9gg7d AsL1bs˰ЄPG!x_A' bI 3qj{OImNt̰Z3UCB2zNx̤ 2qFaffe<֠ڭzf[9 ̋5qHeIsH C8;]rH~g_MRazyș `!6[|6J `farXൽUU kb:) PTxR<]rFn*@Z3O*lLa۽OC ,V?h 䏰YFIs$ѴX 4=itS͓?+'WPfT4ѷ{5Kjs繆AfC¢= HCA[j3 ʑ 0c9wt`7OLt=dr'HA*E^ œ3oV`@0;U&#hQ[C PS}kZ`(<8 D6tn޶:N&U2X0ZKbM$&jj^PK(5Dk()M2x` B? ('T1X'{P+zGx?%pSR@Ii??>V0Oˈ.mӗŇW^ N*vh[ޒ"¤S÷z YnLcjvv8lSO gIoun[u&M2+/evQw'Gp `IGĺAb@Dp&$q`0m!SƁ[``^Vi?@d3}bE1a/ b֫1?ƛFtrE-?쩠&jk͚9i ՎUt곻*UJhKj9!eUĒھ6@GEy#C$+fAzaxuI (NrO؇thp!.)2^N^E+~c'VJU_s6cy7L;$AƃSH̙ZaLD՞8%0R!) -ul8ŎXf*I Tlƍ| V{Jj})%v `ݐ2)1 FHjUT]0=…H";'&=Gn2*e,x"D:&+d'f-MYT/hUǞt$kK+Ǔ1!,dx$aSXraRwvӦSHqPn +%Q!X2zjcۖDI*d*7`(SɈm+-R>]vu*O4Ԓ2FF[" yO*;*5 \𢛪=!J;ػʮiu<<٤Ie6ٴUTfZj{qyERJ(I(jK|0+x (HaQw߹uց5Ykq5k&pJIFNj)Jr _Vj,Tm͚jd!ͽؤp3dCA; ^΅@SiT zR[x)'1u[`Z!$M#Z]+Y& 3V۳c9C38&_TaO?u&5[d d$40̩G/7gӲ0OKH[ GO&+ #ݞPHGI!)صʉI85HUVEp%ZUd7G>6( <]&3j&i*1E8uZ:YKF^ BbV[G$w)Û{A8pn +mf?Fĉڷl> J;~GA>B:$Զ''3eBa0Pi'F#sAs )ڛo &ɕ;*2//  |TNQoH^K%a$*@v4@3߳\R`bs?E`F s. Eaw )|rYbKI"$ l-`΅l0q2~̢*]#w%9喜+LMiX$/}BCO8 2R~[}gIۃ́'94a-VI4ׄ-]IM.4¤r'XY8x:  :0Jw)Ϲf1\m2{O'6x&={,[⻼g(1b~E%07|) Œ_uuhQ/J%+8,Z uL0͡AmI7FHxPar % I*?Pr:uΫ n~1m\wJMd!o&m5k7P6cƌLLBP1[wW+v Cb`X̐i\vW* YR$ Z.l7O&LZ MJ:;QRmժWw5gꂯ 0">gzK`PJwU}7/)tŽM2?E2r^룵䭽@l2GMFlYP ӕ-TRBwC't(QK٤K5 L'Y( Vwk ̗1yM0|isdl@$=ph{AroI#tGȯ*qUogՌ'X!kOTBk&uy5/4j2 =H5N),{K7*jPK#^^`NhK͸/.DV5iAQՙg p% `[B''s2 4mQzM2WV1:GKRR 5rELe .*fBڍ5nږj2 \l\^dlcJJT65T )+oB"˵qN43IB^ƌշÆ =(snBP%\6 )|*v 0PQY ߖ rmۊ!%=ȑʕReI.AݺAD  SIRqU#!qxb[KeTRbSkԨ4(w{H}QHIբD6R%P8jL"rۺ fSFVRMgJA0](H]QHf{`%qj5T4t`1ƽρx*ۢ r" I-_Fd`uY(4dG+S4F%ps^Л [3K}S; p6le†mOy`fq^^)J[9/-5^BPQڒj [ b*SxPsAb 8 3IfK&'DN,%:׿e2/?B$uHۛ-DI-Rd Ia=S1Kl(*6&8d4}=4miЀsT AcL3)qIa Hol62 {6}{W RL2FW(h-)Oj߱wRW&C81b mp$ qy@dNB+aW*bޤ.Zn:c)1@.-fX"< \Z/(IAG~ ]qN! ڂ ]Li PqldSy($Ձ'pbN>Dn>L.hւ7.lHNKF؀G(@ @lIϽ.,r=Rs Lea_3UxIENDB`PK !1>_..word/media/image25.pngPNG  IHDRX0PLTEtRNS@f.ZIDATx|y\3Y&$2#JJ{-Th+$UB]z{mimZpIVm`D d\X埐p|ϳsN@ 0ǩeC ^͆ % k^7  iYi6VMN@}g II˝rLwh俍aLDEІq 4o=8yUOu& 6vʡuP-gb64y䐸"*Lb*1{MP_Z4lZ{2[xvJvJCSs׫KYdz(H@h'ض9Y΍kPt.kLj yIl (ћR5pDz{)3W3`$ -dAbI9%W R@h<;Xo+NDAp<(Q]Z+M?} K%~ϔ TFCJH|If?&ZdP]ZLn~\M4;e" HZc\2BIC],J!MKڏ~HuKo/bySX{s^̚ ٸ*! ZK@4Ҡ+Ik zlRStWS.'T *~{8xLbtB: fCCK* | TR$1ʟ/jz'NamIׅr>B"\4BB]\.{S2}8K'q 3cCּJcX+2zyٵξL@ߏҀ’㙡.x/Bܷ^y*mzni؜cɊsbpr½Q*SV0Ņ2<;>S%R 2g2dgI} 5hM8:çwDagG\FF[}z!U3|>g&ՊS'Z[~۩>`vvYH, z/kkaw|YNkc歛V+[gINjWDۙ~WtY79qG3omƸTb-hYSg7iӗq1i\4W}~]'`!Q^u`;\"(?ؾ(C`WqFķ}JWՙ#]ȹ .b=d_o78&zovq)gUgQtfH*Â6 [Ƭ3jUyZH*J/*O!{R\ie|k+{*9wE e5J>mYFyIxP!3^BG*gC&z06!=$sL (\K-pWrI<6.S ؿ&N*D&Ջ}3W@i7llҢJe.K94] ]%P jѤ=)œnР@~+@[=8Yڔ$eR;H$F[Q%3S] 7Õ<=1*Ef8=pX Vc8%aW4]X47=X(B!-8s)'y2TGs`nȸ9<8*Ƶ_ѥ$<ҧ ')9\v g6W8jO}5=8"uB[qx8KM~N_1y;-)$F A@ H0rkdž2are᱈9~,f[SC3A\ mH2^qz U<T ^4^l^ NT;UK,fB_36{M iE= P\<.a^9ZgST U+(nnO䒄c"o5hCQBk@Q6\rE{QQLڢ.Y,={ N] ΔMfWLɹ$}Kol- ZߐT;ӿ]z\ ,쳤K:.sl3uӌ:IB$n jg$.O)uv{MYӄ;+3:E '_DBVp ix)Y߻tg}; P_`1n!ӅF5kcG8T#s B0/Msp|RH~"#\Zb@zb6@JDm8lV# 6tF& hZWp)9d?R_e+%ysf_a,ݔ0G%:9l[}m5C;劕^_ |#6/ 1&Y9iaW.S 1%N9ZP< K< q"s#jd%m.Nyl6JdUHZxlr5*Wvn{?=LE.fMПǦ.7iIRhWHW,Vtu 9+D`8; OR Р.\Cjv983S$XQ%M*)3Aj~&+rAl)sT\{N#2o͞ ʕǖ _UxSTdU%>k7xˉPST{X%B,?&aR 1?D EzHaqέD_[iPr |z,I:x 7!=#`;5\Y UY3M׸dj-ߊ$c i@7cv!~DBf7=5)?KB3מ<)M݇E{yayga9ԑhY5 [Y݋w9$&vLV`o͡@6?$ Zg^i*"pӑ/VN/;V{Vy9LGM t}|(5#"v` 7?R\Or|hvXR UJbOkXvm҄ӫZ0-*LţIsIzB̝gةI=94j\˜V+-"FLQqL'h$[yεX2;-E3=ˁ%%-4=)=.2"GGs-j_P^)aC!$9(Ӕr@Q҅Ȗ?x\Bꔺ VVد?6C |ᏄO[E3'xbjШNᆪS׍ڑRU.c&lJgB;o[ dǪqs)ZqD<_)K6H& 1O4w+CRJMwp]^i1?xPIaѸ,sul#b l5a!6AlymMNCs:49 W5#Z=9]&Ȑ6Q_EM,D=u:EV&d;3CVqV#x$niHA5}' 0i(c2tP. b_P"2o^a.F)RJЈGPRt2h+bF0DevGD -W.Q9,*yH8Lj^^bl!Y)~AED4~&Dkh1Of*aՉs^.@q L4R]mbcpy\[ɩ7O#ZM?̏^WoeN;c YWZ)=K#w~h2mVlg($LIUh&l%U 2$+uR@xbq `7XG9Dn 4lU#Vx߆ N鐭ᨁ3i,ݨ|Y`B/ϰ9 3筗^+{0zP3%ԯ#Oq5Bp?f"56G.UFl=\ߍw\ou9'MlDf抱gN:6׀]B8j|9H gCޕ%iIu>ea/s?"iJʥݔINeʄ !?WW^/U.iowvOn:@n:0}ûυy~WD`4Vrqql YjC[z@cԉ:;R{\G~f-1V[=Ǒ 8\jf~тL3 8.n1\b}s hӕIc]]Cl::? T%W)ϑ 7H3leM,)5x$Ej> d^yn^aFjمϽmjDUՄpZϮ`1;.gK/eyb$WWi  ̜9&jqjz揠{-es -fR'D\Ys>E!CTG-9Xb. rU/7;Ujczaf菑X T;;܋q(Z2x0G ga<$z%g?jPjA>!oW Y`GA2kȨg^|픵'{ZIKW"dg_ӄRk|\<`x[xV z7 l2IPzj"<<0hT"R쁂4 +v(B.?s":qa^+' dFHTx1OVq0@P€8{c"-X=ֱAj! ǥ?҄M&$("d(-z7%w +Σ\ 7A '8ڨ3(-+)JEJ Оd OK\+lutbCd.VIks;]1G7TR7_„Yw%͞sb=--hW,rbݪmO¾!,)?͇\Ҋl9B] =Q6Bj%)g2h[ԝң|+5Oj'U Ğ[ i-E1M]ڗ1Z1o56fF5s'0QXiG-UQƖd7T6"S5flp&sFEc:W{^-Uvj$[w{z'9Fj"q##̷M ݦ̼=&*랤^2&HW#@"`dG#`UVLSwm+L.;8F7etEbф0ĺBc\U{>F$ JYg 0*`UHI±PF%qF+*( u(R {G9dV>IGUwT3S9SϘG^i^vK?Ꝃ G䈩\ӹ=Fr>?wKrY'WX52GG_0V4yeڹ@ոrG%K%9v׮gf4ܺ|k/ǷFw|U_.SW:…:j#}ۘD'ԧ({^e3LP"AjW7$bMIw -$K$`WD$JHSa$]Л1UiJƐ:adԆ_ٖ*\EKu'ʐF 524cC'θ#3c8 W2j!@{k`[̩;؅b,09wM֢}V=mBfDB8[PI/RP\dEh sLƅݝczGE-STEq%1[)tD lE(gxQȻUJnN\K mIc%7\0džz\zrVcFYJ% 4ì"E"~@{xɃCzqU@7fҙ%C𦅧nd )aZ]$-{AV"pBjX5t67&2$9 WWd_-'<-FpȤ %YN]NOHӌLbmQyXG"XUy{`u-& ,'eOw*Z/؍ &)b5od ``؍Bm{ ,Ew[-EGQvImvdi*_=ybQ1~&2imc+ʳ;Tji i\֬hjǗ+su/]cK5>bD(1gTsS!҆K<}&DW񪪟yIUwiid|BLsP-[>uHȕc`ӍɒT:4`@2vg&^pbFm*Q?>y(D\ aq+k.SpH,lɁ#*2+d\Y'm{I]~cUU{0uSl|WSB`꤄!Je;7L*vhTSГ =J&ONX$Haq籝a_K?HDq3#ЫיrLȷt ƽ!2 /lPr'"_di?IMz3t`΢dPzP(zBC67R `$3_xQ z40G:M.fO_QF\IqV[;T$,ZDUxk6x̕y}}>C"arSeuAz5_UQf|r.G`<ˆf~Dbcqxcc%?vYZYA'VL(Ql(VV e$a$maXC փ^Z"q/6<;c-{ea7'`YH սAbXFiٲοӍo2 #mȧ :sQ-U8{Mj(մB,=n7{.Asz&%/420=<=aF e^}T:Idz  1s<]~aDӽ5Ic;ic;͒:=mgF{mzwEY;I|bv:Y/\(v^_҃MYw.byˑ71Ӎz(~x&Hap#j䊠k~i~*;Wur#BMGcOcAkMy<"@FU%\$`=twnҳ9Y}I4э*8F*|4By=΂MoW20M}7Q^?mnɤ|80iF%qAEjay׫$b+6ax;3Jlw@ TWuqU tJ9W*ZNYiN;Qk-Qzt$TLɬtޫJ[Z`>H]|LYZHy!ķXeGbĕjj#C:KݼqUTUᘁA\)#@n!69q=|=LY엥t~>RQ"qa;sK:;Sfe2:v緾J|> RaE>/Jy:cl[Nm?>%!& f +`q>3m_A٫]SD=_$9~n c;(_#/n_Hnbe:lq9{755#S:IU&d%s3֌f~~}#_qxKSpU3m6{rD?od֩`S'뙴ne3[7#8f vjt;1xlS``!B$,_(` `0BJWM R{Vv&ZmDrWw3%EqQ}`QМJ5w3xIyzmFM6P@V+D"ڻ6f)Fe`\H3En(iW vI-T6:b0e|MBf6|:ĝ?is߉cGɸ$Z94./h [C'QHدj,`z>^ׇDJp8wB@g}8" Sē;ץhͩ㫬ʐ&kkXvP j\$Ĝ4JY"(BBWJ1d)v&xR}{n༦a6yCRN3vyo@R`=:;NNVmC9S/hJqr~58eϤ"{ҋ~;{408*ƗR 6@ wn@Q_=1f8~w2#YxbE 5o*]GZ>v~ɯ~!s=pK|;ȼw'el{a=~)!0Cq?=g4 ۆAG8Gw+>jupAЊ>ڇx㒇ށ{Ct7~>0O[÷>H ڕ82KXμIENDB`PK !W/eeword/media/image24.pngPNG  IHDRIDATxymc>ʫ4*mm<'Ud*RA^TRhdHIJ$3t8spLc8fT4YsHE}x{^{g=}uϰ~neLf˟ݭ,e$'dd,ee,=*-orQM)1 2Y崔_\2ݟ^qK--rqy}2eJ? ez)ݘ-5 2Y-LSU ;蠃~u+Bw~Y6应?-Dw' rWė0e)|C=2#]w?8ruOyJ7裻3N8qW|^Xu"{nj@|tOӻ%šm=uGi}Xu[8$dS@#;;Rtć2wsQxt>!l7#lxx>ӽv啻d=_==<&;[ꎚ9;6>}2䓻~tG|_v Ū'̿˹ztCnU.=ޗng/ݞ{-xQL<< O+ niwbu|cK!?&FvyPS~c7#,wB'=ޗ?܇sEn=</+Qa?ie}Xs~}s-r^aԶ=_?{=af=&9N6}S}1@?=hCQzTy$'?)*ʉ'{s9_GюMwen5zUwO~ kÔwYZ[oM~32'򗿼{OH\S8š/{ӛzGq+qh;{ŤVZw `կY/dPQܓ,GǑn/~<$GXsX^}|jnVg}qF|'!ű, 8SN9g-+ sڭtJ$'T@'êlp\k}΅gtX~L>e?yЕ3ft}\!2>6g>+1^>/}KX*osyqUOD HjaqfoYg0rt/FR/ ē,H(Wշ[vݚg?Oug^wW:i7,i}THh Ģ#WyZ@֍$wN=nwV_}5yM馛6 Ho@8OL|fW{q@- N9sd׭{71_NWxc[0Y|vn؝{l]Wv?eܟaэ7޸?RYg`&3Id _t n w(; +0%/ٜžZ_GHoⅉ831 GjNDY<)Jm >ڶg? rJO*#CXG>(|VٙE1II\ʸa=l.DG9ǩa9g9gVlYpΏe%SA=JĨ،+m k_Zm٦uNj۬V,[`u)g dYB9sK8k޼@/ e0\[Jc2,:mڴ>[S"Gg8O#oeoAY|4  x^%Ue«i HC*W^y뭷/uwHl-+^ bR# ?ۋ -SUq ظ?jFL:JZ“,8P΅~ Yeƾ|;{5wz;؀o5;Km<ktozӛk sPʑȻԧ`8>$1Z^O~|.iL}iTG 0܀$^}ɴdGbunI%{I71-آ{KbR߿}~+ u&Ty9uG?_>Ǿ"l$>yoFelvݵt*RǺ%?"˫>sA8>'{WYe[,[EXP Bq V1Mx MVT֖G~2:0hc&l҃ TD|߼cj%xTǨOJL1Z5t^,ڞGw"͓b}ӽ=xѐv:>9e+GДk|=yϻk?=FCX1U쏡$MAKqPcNq*&IDR#ͻm8 ׫$?sUzUybc5'g)eܹ=/Ŝ{me_:~$¦$űSK!p6a,l' {~M7@)XxFev@e1^%6l["WŢ@aWay{ďc9P[m)|śI|QH2x Ö?;'Yw^?Ӫ \,>y=+]GHWMj)$Xk( \@cV*+]rD6!I&ʔ3'8!N3 lL)MWkT>NO|b?1֚|a݊ C9_sM8LcoL~3 m&}sP75 8wکLuvXsxѼ .V%J/5[}אcLYPkU;/z^ `y@dK<:3 D ȫ7quA|2ӜfM ?ص'>0)M?8MyHk (K]C=D69VDpҎ;'8a~YgciW .XƘŷ1p `/5 px$E:a;4lu]T)Ξ ^sm,;rU:͂W]45u%ߩ_}qvG VMsBu4v*^nOrb>Lꁓd6 x`-`kRMPnu\P{/ X[T2 ĔOcεzi3~DK&44S"_{_1fصBbPi16V&JXI^Gg%> ۺ`\N e^憎*iUYbS΄:Qϒ5֬~[1fTwQ\ `j3x%8[}QD'鳨$e5&~O k8nцde1foʢb5 d73ܳEfr.sMT⩲ϊa/%%Ļ-1Ѿp9 6L%冓3zAo!'^c"hI7s[rP s? `fD>/r ߤ.E8´2N>p>ͦi1<1)V1!Xfp:;?\Yc>{ Es]+bHNxM_fV}>̊8+a8%ݎsc>[3gks+U?;_Z&\ 3W2V;|T!Gq]ޟ+;ri zVғkHecеZkbz|VmO'Š8$T2%qǡ$$&r$Ƒ'>}ucl0鈜دߊ?~Eu!ӊ ja$>:S1Ka &yDJ m:Lr׽e'k&^aZu.a͚_mڑ,^%^V@J{=)h'sLw}oFƓvk <{OW6ny18>5\#0\2ΰJO3*ۆ5~u_Oq#iE p)<I?0AQ;DZu6@WՒJFX])5ěO )eԑ>dʔu׎fX1~+jWwpfGnCI68;runFX 3p=VW%pm>%q'' OC =oıOGW GԷ47|mICmZ}P'|')peVZCW뙁D4sT2'L;18O0-L3.3L!tS^:C Ρp:ߪ' <_.[~qA>‚Sg[';;̾yL.*M^W_{zqh7ڤLN(8.ߑciߞ:~'+MG!ύgG;%D=ώ>n0yV}y`ٺvh|[woWFlMUuq¯r$և{4{^MTd$D,f~w>ϽU;}r_`ef7K nsh 0R q{ 9p5qo[P? Iԍ%o:7Qk_ sLb೷ڪ['0>l'O >{vw~$w '13rsJy+os5vz;t%L-#q),PЕg؜q ?$ p~aaH5z ؉Rr"&|' =^Ww^UVU@7dc9ɔJd*&8,;(ߎ{`tf[ ]c0u{F>bMz` 뷜ȔcA8#cŔ5<ݳ٦;2AŪ'%%ww^Ġ?mi۵SW Wo`!Na@*@I|ryOB{:3a`{O>F>@R\43&O, 11$uK.֙gXI6Ők [llr],x:V9s6(Y}c |7cʔn^%ûޗ|$++c52 ũXJvz_V/6KĖydo?x|0.y}h&':. n5iܝ"͕G eG ZξftaIJC51ۙ f[L 6"aύKڐ%ۘo א5t7a1XL%4CWTg9]f-W%76jOI6rtj yOLV'!eճn5 J[u0evJŮX2[uDqb,WNv2z)k O˾$IePD  cPYɵ;M $`Mk{b]l:<;^c81֌#sk:d!$ćx1cy؟{="i-TwdԇY2ѫZ 0$?pk?9iV66XFuDž=f[aPjcJ*W3-vgE䁉qό3y> h):bga oMP1Qea6>ۉ L.F&w*Klm׽zCX@մ~U3>|NXzle\m]?L%CŃ@5v:'tπyġ6:`Htׁ Kc ܧcd];~g"Ο{xcm2} d m$S|s;)$s˞a€'2R.I1l97$ܺ;;5>;]y΢K%2|hv[%@/$NedCV31h2 $p neNE5ywaa^8ĵ@ƈITF- b:#k$2i5ύ#ɔcg6v8.8ʕ#V{|K'=52'myF2pT WzAɬzٸiyUVNqwa'-cLX>ailn<{o v-RbLxdib.`xx\cĔo9%Ү6{)CFE 4Fs-Dp( oJ]~}R&jKs2j`ZB=;eaKve䪝= ذd `2V[h_ZTυHމ@ƱOmS[-'*p wXMv_ޖΟ#.Kx۳l 7[?ծ>j_ HɐS}kOV2 6QDaQhq8=s3^2PP t-X a('9/2c0{x3xpR$=^Otڈ1־W!38IyjǶc#R&qC"P' g2dka;cqc"н^J0:Ljb@xp?A$LW18Pw'a%%dY[RN3+O5Lw*j;qj%rd2.n@Ǝ%j=m^BMZÊ\w_u1t]O Vֹ^[3]<@v%Om4 ;uū-;CøljuDkE;0Lt1N`Ӂ[u|.붉$Ė~guƲܤ ~>jXJֶv&P*u$ZO֐yM)o()NҘ9/ . (ֳwz!c]Iڶ( nˌ\|Bӏl#3k$$*Ob8ŰtEޔ&VuA91Ny#6m-oz- IO& `PG%~XSN>nU9_;%c62V\\;O)^=!CF?%1U;TM̠,`{N7,#Ρ]P9V2aZT߷V`5 GaIJbaOm+/)METBWa_E'?p.jzWAZ-.!p#g@G X^֧;8}a +`d@g 0qgl]wY1W'n[5XVd$iU8ztZW\ѥ4cڳ$߫ Z=lِоfe fȚ4pZ"M] MD5J `gbS;~ܲI6Tq%9Vl J>Ԍ|&Aݱba"K©=Q{&ub'޼$rwO8xW!+!&㴇YT}Ws_w5^d $ D Rvw ȁD'HߟMҝw_1>WSV}饗CeQ`416T8G؏9I<-CÍ=ܬ6-Pa8Es`j6 ʫC}I}2WP(5)vju'%o8{7-鑓7EƓ@`\X+N#j9OuʴMOncXs3lmbwVCL&8WY;pRbٓ\I9;v-ɨsh % ss*oj*-J!7?u=&m~ O"x"?+MdVVz LfTgx_ijAHPcn\PUo>y9=|iA .// K %a'ޱ n?ָ< lHf|?S2%{+ߎ23y;q.'QҜv-hˣIYXC:yHnql؋0, ~Ckb@`b 7o'O+Y0=̤u]k6JՂr[hL/v= *~dHQŘ*3T8ְM$nCM+;pp=Sb\d%0]m~ MTk+I h.v! uvkY~WjA=0{)WF ۯnK֘Q|

ֲs\;25IkWl^5~) P|()qx6aWoX[jW,Of_qEKsv=/A6+Rf^?:wU0)`ʼnuZ)p\f ?"qFi}5js,J{N]…Ǿ> m\oM1k1hSy~#8n/iˠ[ pO\̋![җW2/(Xf4b"ϟsbaLΊ^sUOl< HUIeuQbGG8+-N,K`Ր9ϔfndIaf!!1f]!1ej?^~}‰#r]:NDs sq"᯶UfCȵ~<Sls8T bsYqsF-̦ <&_'7 ,+W0|zVʞshcbc$pga;30`]ɱw24RWDʵa-Ziok ldW7;`uAo&ܳHa2kf2v 9׫^,{f^cm^㻮1=@*~Y9sǞ{n[ɭJc]8-àb<}(Cc? )/Ƒy@j{WGwY쟌яv$فHZ+mι|B^Ys;ʼn.d|ߧk'mIƉm #^m(cP"kC\:\س榬6+XI'H`:Mf^75㥣^urJe1maܫӑiE$b^fG~,11N;I0@J8I ) g NSgsiڿQi(cĉ[|lH|m)TbQN1^׏9)yu}Vt 'lZ,)0d (h0GvdUcfν>~J}Sd1⼫m1Cr@=L>Jdٷk;iOwvle8r; r0$;6=% Tz7/Nfq`ydo;RK 9 /ny-'<{^<.Cj1d^l^B*KtWe:i3FC㰖p#}a3ܜ Ҥ*YfV {us CZ;'8[,'-]lmNH#ԞЊO"Mҍ&zq榀a"g9DʦUŴ,v; <|^>a1i ڤ6@!lݰݡo7;?%Z(Q8ÁSH“,)~N~3;m q $ Տq./|b<cFS`l LZbo`{$9#t.[9A-lp45ܜQ孍h/F.{E=+.`\%zH:Oă3u/*aTc4\o&"g1RCCp3 dr={a$u&6u^X/iˑ` uc1>3[frs2W_}u>m,#ɦޤ566B.1*b6S;Uwdp'ı>)O静a(}fܔWu(0p$6%Ƌ)hvV 9xh(GlVO+ oqhDUvqS/|L4(H4| 渢pRrmFaԊ!yk^?=RtvN3"I0 ŮY$wykV߷t'<*&PlM1\m\둣DkliO[)mza= {kX׺e#֧L\x]>5}7GFI$6g~[_cik#sFSMNl10&s;ѲŜ6kaZPN%V=&p#qjC.mjWM>顽a̸5w94j̓ZIy%?ȱZYO7D$ 3sj3]aav!~;]6I2 R[ªd3P7[urpN>3%L 8Z:WNS/~ѳ}ͥfjwקgw7~ސ)#P5ڭk8;2X]FHWuqNaF{^ϼ^?Ykk5dddu0i|ot?x( sǧ(>#K1.GG qvČ<2[,A,x{)lB]< 63l+l{]^Wu1V99wui;Om8˺sܜ39A@6X2g߫ +C0 ZSN:%esV>QZ]޽b_տڬ(&w *06' 8iﵯ:kqtIxq^rzJ>$60ӜeLžmw,s x>5d':̋ n~ r D}<kR3Z0OUd~x$ͣ,F15Yԁa?b. Kzea A~ϴvḆ7bي0855wK섰Y}#HWmiaÓ,0ʠ6nI=Rxj]s*_s,K]mյ_EO{[%>܉* =bö:LpLİy<dO p3൹?Q6xkl;4ӎJvHX "_7=*0Os5\3nK.U6ڨ0 Za0TZ1} qV551? P=":3魹ylK_y}.s8ds?u ;ΝPe飼ZƽsRk'tvQKTz'J64Qvpmp0L]J*Ǔm?آPI;:qE,Z/f!vLR^=N54@[-kˌ3oU^Zsx\8VXyyakMT6kƌPV)y/ `Ct 7aB;A'X# yfʑS$8"r[ +iV%q_&Q2/,n;]j]l/N%0Pc$vn`2N̵E6¡Cu5 3xQ0(c?*r1Iqԩ!bwcPmS{W-:5Hx`g&Zm)I2q1{dSľp0꒓>rYR/l<1VLN6b5 = ǰp"H^Bm~f`IoSHzP ^lS`FO JUսlH;r ꩽ80KR#@Y8VXO]7kC!2t?qVdC{I^ΣqU^+"fqY,)xxJ:MG20 K@igʀRsqIFٞKˆ@F ${Ί!_jl0@Esa BԣN ؎>%i/֣X0d)À9G㚔H-D䳢:}3_ke3Ǭ>0JvwC-68tdgM+#c{Ib1ھH_lnLʁoW~yOm=kw tqv+zC Bb:7 _x[J5a:=8RxYasb|} ,uTC2eoL~*Rg|g.԰JjSbCL^ɷ 5Q!`z9|\#9>@];q(MU2HW,W%>'d{eLyitsTL X#:䪬1/48N؆.9,˸41v^@i1CZ]W]U`9i,<,@p?1UO;^X_O@EkڤxCQ7l|nYsnMR0[لi}%8Eu\ pֵbK1;*?.k,'Xc5ACߐBW%&0ei\ ㋱&l\%S1 fbdFY0e1/ 8a_c5>,tˀseDe1J2 UZ0ۛc(@O'2 ,]q22vYX WF.kgS@G`Z;ſ\yKNs0:҉o-dGcrvascDžvg GԷc69 3*4->hmPWSHSm/Pw|˗;'eÃgm>rvB NHavᬖC4UqFu l.KMYnX{՜ zŦBq$Wkw0?Q0H)!%1n+eJkF C$4`≟b,]re ŚQl t]!cu8wyFaّ ҷv{0_2V㾵W' SfsNMk2vTcK8Wm+؎Cc_O{#z8^{'Fzˡl&N6tn e9(L*s95Q8Q& YrP6%9GWC٩yZCzkp}M 0VDY @6 qZ1DE#H.pyιkHCm3iqٵ1wDg~q0q, R C;9Zu6puON-%ܣj" /7zHՆs b|?)]֝7~%jWL.IU:BN;<7^ e %q Y@"x!,0s7xc`-qSQMkE>]) .˵62dUGd`N{/9)g{﵏: O>k;eĭH>$}jH8m:ЫD6d NݾzKU$wv.m$]S]@UNnV鬼h7͙;;96xhycw;ڒƊ ~zqJ60i2|E\0&&imXLX38 2UkVU|d9Z.%ú`\;Έ{f=^='ryCu~cMb,P(HH=ZAGpt$ ga6$u"YWZq ,HQq7݇~ĚOl.Qch;6q\z -iȑ{a^?Tg} ?| 't'S:my~=.mVź38FUI?p25}^ܻq!F`nʤrdS.9UGp ^?͌Ef.D=&O͋9]As[L\s^h$hjW vÖrӗ[;1Wr@1f ve1,v(5WËȹ5C(e yl5vjVLLj6X7tfƜn\!xNǔxs;|)KcLi%˧N: ƫ#`:σlK/~Y; ku$r ԅSMq8Vh_B¹c cL?ao.f`,EBN+cܻ"3 `dfHYC1i %a5wmI[,ďŁ漀tm*9 W[6ya87aTvy&EE%֏G7#^Ô5YYI|1\~F;Oěqi L}'aWZ$0n1aǚډ{P;7ԝ㝖s=%r-NR֤C@V\N-aENɫ~[Fyq>#cF(k*;F)gI#& B[j6 H)<-~slq׾CʂX r#+ow ;q‚>к}Iqa0#mNXXk\aC;JKffځe$d:呛GyҁGűp69Y{\Xi\ˁT"y*g\Ƹʛsf.2YVaG{ez%{ed1619p&h+uG`(&pz5_!$NIm9s3Z 9CJBZ3=hrG%^ٮo15q~/kT]qSs3s>ծ2;rsoeQY8(c\{w!Sd0#=}c1q=6? ׎]69z9 (^ye+#9טJX$8 F{`)2c3kn9G9 >O6zh{N뻶ldi!jfkiATͶDW:V˹{au9탣#nl۹m6wU_^1D78$0klj'`(jрi:uzXpaN's8%9 r^Nε] =>Tp~@Qҹ x1$bk~3_v;)lL0#K\uWh0^ ; 6Q$z8}2chΚSZ+bdΤB[N\6mj8a ޜvrtQeH,5v; +@k6A0\|vÍks;]ݴ$8W'QS-+8f8[Vkޞq:$&L$m>INKWĠ6+u<9lhw߅HnA4 c0ݥ]}l'ί.zoI/@pџy1c^7sd=dHvheheQyc] [Yq;G Z#* ]JGKc9 U֝S"u>#tOЎXI4cCWr{^uU?۹7" 5S9g`o2IݷM +;\n аqtwnGbi9ﬨ{{Qi<6i浕 8Y'wmf Cىw8JVNP8Ȣڇ5ŰS$}jFFGm qW^Xx60s}~ =>C-/`X>MpN;AV995cD|}LEv굏M 1yt=&Ä/1T# ݳ&mP k{1:Umkp8NBdðau2ru J2Im6\$, R=Ryje$|f%->349oLXʼn֎7&>dH̹Kx≞DkTR%'Ը-\t2pId hAMoT4v0 x,赾SxrƂy9ڭQygv\S,i!eep?THMY+@_÷OkYn !j멏`ku9uHS=KB;6qh+\NI;ECT&Z~־2Ä83n7ڄXmwϿ M[SM >G8 >o 9H -~:|- jeoScWC``k@s2.!1PCgfh~50I0BSB<:IﾱVD u>īԄl^9~oI۝a%Np(W/X<ü x))p!O 4ũOp׾^$>s#֮d_wq(I;ݟ ^)ڒh"Y]s_K]–;)qɆ+֓44`5 SGsNwIt6iIjp8v{WLZ Ǖaƻoٺ^XSqIxԝN8\AeỲ1aUpCmtm#CZr@$kGMs,!4)[P!? xN-iڝC&3ssLdɽj:;@ڥR=^[Y[>;we9M4 Ũg(+\gh"іgv{3a(q2Q#R{WZ -@*Oxt'i^eaG]?=kWu"Qu6_:-p0ā@ '0. ܓ::h?y=TtL@p?#f񪝝8)L6 carR P%Xk㐄}{9qr25M9u1O! `|1 Ꮙ:56tXqj~G[h7ɷ{Um>تx"o1Ӗ‚ZJ``\:uɢ;F(6sQ`͹&kU@j 7F6 řa t"!:gX$R^V]4Gz}Wɍz87i '.hmV]3hS:l}X)31gNVoH)e|8,ʨ}VLsG6FP^qؚ0pTKq*Iߘ3\A ^[׽Ήy gA91eCs%GvzxzF48ë>"؟_P}uvo^Quܮ])M9-K뼮HF }=uD=XҵkA-q(c_xܵ^9m0,ڂÚ;p"|Qۊy؝KK낹sOy\KQg~%j~/YҮǫ:FivFyFsu*V6-z^SKܽGۍʪCnOU 1Fa7(~0+C58$WW?砣k 3\=ך@g\ #p2v*6|/Nv&M E5~0#Gw6g>yÈk6~hkJɺ.ۭ`w8$p\V&X6ؒKvS%opبfl7ܟg[ҷ:͡k;\5µS^q~Gڳ'ʮ`r$ehm8emf}۹XW0 Lgs`{t-qU";w(:d=&R֤SvGc3Wb.-DwMOFOd^M``؅09Wc^iFs?1W-`9)/hSJX F kjЉ8) p&Cp1lh1\1S4 ##ģb= |{i =6LcI&Lb- Rk9dd=eH#b?<0 :`2!>dĤ.*RpO@ 2rvi;_W|{ݽ2mWqdom*@:/Ԯg \ Ouן'y>x@XQdIQ&W)3 TK%7))m.>('Nw~R;.9nH('"Iq6ֱelnF*UZPfd_ۙC +}_uKn6SFܤSk!?'YpNR,;cs O@% W0b"V& xT#L0 81z@M=PX3921Fzj?M?$9u8L{66 ? 8QX~Pg8qL2{Ę?>o 'DݝStW%|.w'V~*_nnAڀO&s+ka>(ƕDs-R̄n+++B.U}trpnh= :oVfX7z8o%(hcv*fOy<:صݡd]aqjA{ Dch $N0셹fGK">i0项rbrnǘacđ6"`ksI"3b/`UG;\# +/igɑQ&k(wM-aágfu+-9Qf5&J-E;N"anڧ 0lE*10&)0:%N|'OR:հAyqnca_/n9cŬt{z^3ţXxRNq[klȤ Z`R*p9XF ضP:WfzѶ8E9iWmq)&%}=ab%?>wnI 0iM֓7˞kg·6TQ8#8ON:Ig80j{c|}ɶb_ims #ӮmalhBau츢#u^]nDzSÂ4-5Gx\M[mD/PBOT &8f XHs*rgeb9J04Nűf%֒NcUNmo#XT @bEq6 qA9d: b& #(ؚPɨcNUֽQlb "kvV-9|`F-8=/}>sjhW9yG^B35 ᢆquG$FX-6FZeY-']q=2ns]?}#X[h`V [h%10A*>Xr$<Ո֐b`Ҙ І%YNԺb6]Ϫڿ/GVsm" |ή~BK '_uuE>}JD{ۻuGε*vE[,B:pH?[\%TcbL$qf:wVΏb3ayX|4!5>MKXGo̹W |hu P~v`NZxa - Re*M.Q}kM7ԃ HiJ@lM8~I#sm L8FDbJҖX8#0D &ZEF%AVƹ- oKd]-Þ`_!3e3)JGM4gq k Rc?1$ T9,ćD ̎!{yg 3?\+2.cL1"G;HcWavL;j8l eYAWrK~2}}΁9L)fyT2v`U/D[pN0D91VnUF~x[|O.S!Q=Br>YXyAN@Yp⵷4)^k* a; ^kv9a̡U8.wx\[ޒj6ؠ=qLjw]=p-<#5ipbJ"e,&7m \X?&l=0GMY 0&׍Vc{6癩 xXO95r+Zq4q8Mzq5l' !ie3@TN{1;2| Tl/ęg9ڪJW /6۫U qe{Q#T[72mߖ{|Y(tvZHⴅ:FD) 3cGiIAA! i =c$p89!)9ᜤ& !$p(7c:l̛7k;xf~ֻz}.fGÑǴXϘ* E56ji3IJ5͢[.x]Se}$(-&[/^^ӴEivtTTNS}{|}Ic]ˬ-iQMV],.>\~}<&͟]͚_(egA Ӳlt$ P{Q1^{d2 |)zAO8JؼMϙs6ڧ4)y}%)!P*JN9a sApjUfE8ZU#7h=w7\EОL֕d.P`EE?PႲPWՄ|ogΑGM|> jj\Z}Ryq8]H>Q4yG)w1ܪ dN( K$xM ;u|QiXew)븷~u ciX`n{u`h-zI/gٸ;BQkk’"q(VG:Xu",t8>RFP$zI4`?,JY% 2Iq*JcwetR{ǎv72=/;k8,rҔ?e|&Ne(b#m0?/GI0Zח5Kw9(0߰{ SS.;w칡8 rm[)ds9DL6SY$ur19;'ڹۮmHZIM)(|oFEv\bYu4X|};UFs[`H"ZT%Wuͻ`z7+Su][c{}]& Ȧ#z)Vcwmu܁v6&5yg)˯=i3 |{.`(z_ޫ~\G%ZVXu.A),S״m&//RvG4gҢnze_b85ۑlKڦ|m v3,4k9{=w=&TڥoE\EJ7]gi2ۦlWYC,Г<@a1*(V j'?3/A5GR(H7>Hpֹ?}O-=\TCO.F!ɱC WOȚ߶gu严6Jۋ#&-sL0Q^k%J+%n_9o,2ZE1ѹ{!Q$9&ګQ2c%P='PJ k  ׁ[\d\Ǥw$J* l|43R֘^#BLM,0zNh2Y!P =dL| )roRGNYs]m6l{妀ާ55_w¸qh_y_y8"FlY,<4}"&e~د%@6e+ZJ}rޗ>jpXi\t J|nӋ*z,M)T}*Ԏlgâ B&EyqYK8/\ 1A=/H -@:Tmo-nwv,(4@~H][^*Q ͘{?"K3~EЦ( @("Y?Es=heZJۏd,4ڱEtS0IЄ|Ӝ_C޵~|J0=|FqP1X@IIB"k)js"~^IX@;,zڥZ5 S&}3s\47TӺ#%3VΥO:hӔKK89ajOMmN8=1EOǒSA'7;{hx `"J-eG&ZmUdPh[b,l/4u۷o< dh:p&zc208JXC`@0tQb~El5kۋHWOv<}i/mi R< Z rO 7 ʟ|sG)X(لaY'@x5L*{X%yD_5Y{6EQ(LMuܱ}aRC*rs0@۲GJl،+Kh cb|]XܔE:߾|& ͱ[m0*.$說j7Z$ #źk]e5., 4c¢)~hzdy;>Rg{YLe}ӛ62OKda-v긷dڗf^|@>j}_dg-Q"DM|qDe@qx5;;PdqS Rjq䂱"%KB|5&vTFzqca8Yyjn/"1b*{gJ:ѯ6N19Zuw$xۆ=2$(TٗJq}wO)w?yT|e_Jo>]JY7w!>wRZ%7ߎ@Ȉa:߶=}7+21XUVd;1f.y<\_$2"k=âSD\g&%Zyfܚl'J- ) $1C"!`_',N6fy=]&r̂N5> ۿXVR{n},JַE ,EX8[Ɛy((5>[`>P8߬@1w1˵ IDAT9|rv@gOLQ8W9(>ZRZ{ >Ld7J Sȳx싻$@Rґ>]kKY^)87o6>}U'h MhC\gXT,AXN.B%iz+M n>'0vw3kZrkf~de->^##9)KXEϖBR8alhSIh pA࿬vpC/E1?<2\/wTK.5=P`}^=|g4[4c|>:Qz?%A/CӍ?ښ7j@mS+abe #[*4reXdX;79)($ Ovp]c&m'?:ƛdk/>u/ <Ԙ>pqoG|'}uj}Q(?,?ZyALĭjwX 57+ʘYkR~Y|J^wJ|N,9׾hpLV-I@PXҩ^=>#R6,kDO~3K9&T A8Y($E!#KȢ,̊ Hh5a)-cFeܾ}bǎǷm)CJ&e8zCj_d*ϊ~aEH?Y8@Em=}Vf':Gkav(&zDΝU OEcL`(uJ ˍ-u|a梨K43F`S%EA8Wn޸95E*HEXv U$52vRd{mmט&mPl^{iek#&уqjە(Rn*AT"aWr&jQ""7{̎ǚ.4` E9c@ B5c ,Pߞo8h#d\^wH'ی1U2Y{lݗ9)D<]ӼU$iBn8 ftm .-&1z*.6/[݁nNYkt4P}FWA"~3v7E PGH'DYk K=89\cNQg`*o]Eu} {'S"-RX~>w('E e -% pv,l',&HnČe ɻGRu4&|Qvl2(Q6YoWƺt࿶2{5Yr+\6eBX|d]?%jUtłRs M<&OY(֫eG49B"UnK[ei,ZwB^S5 iEAEuA7~oE}eYﯿ-zxy ^`{eM,:]";ߺ-eqL p_RDC@+ ?LM'KsWSu獌TWbxsY-`ɟjfl| :m;wmV5]c~][ ƄOFINiE@5Rfً&`"А}]Yeq~>ppmIML).Q+`$r|nB?7fuAtHڈHp1{:W{&hV6 zB4><؃q䣂 k)Ca,7IzIf99_@J}ظhiQYml+[ϴ>B8TBmb ~[>Tu2&WgNzR|s{N ~xnkyu-r)4 +bMlZTsUE!YO Ј&+7PU QCV})G2ݖ%3>fVw];`[fJ)?Z`~_~VH C`PԲ = $VjmƝߖpF*'ԋec>XWڎ-нހ{(̊{l)mS@('ͫꀉ9egSCwLAbSv'$`UaҪO)9X˜VқZ~7f-۪3)7Äu= F35u˴=VE [Ǻo 6I[eYv;\>H\+|bj3V8RAy,\; X].t+:ڮʏ%l K(ohmXsu'' a*˚%xWyg@9֯h[/'΍Krz8Wh EB~AQV#ZHFSsDXony{ݰ ^,2*'͢zh%V>,ηYJNEB6* Krڱpm‘^m"N:^P 捻w_+y&{q-c/&i1[kxapζ/@.#:9 /]'11R5h+y']5>r’2ԫZY[@Yzֳ=S:,gyc NmG뷆}bBItyj:=fmNLV5/<0|XtTaeZͲb >%*fJX”fFYcWVCq=k^u1~{ƞ ۯf"˾;kܧ_y ;Ǫc_^gzK̹$B6ǹjȬ:%*͘7z$w*@eQlڕSkb QjTt.j=e>hϔg>sxenl,֜@'`h!{߇?[(E> o,d5?JߌN[˚+h?hk"Amfr,rSe,U맶{:r( ÁЩ~|“ADŽ@{<"Z[ XE_U7: \G] ܨ>S(u"S=̫yj (N?ᙚi'Rt瘨;=NSzc;Jj0Yo֧2EtII{]DM Be $W˵mprtttRc lZ|1} L}XԴm_cַoiq(ul-zgU6.ߩpmQqc 4֍֏Lߔ>Л /`gVm81Xh,=ooiX54_U ][:m1@ڙbUj*_IuBh-'odSO|eFgBkgR a cg@PY+rOhb HՂ)@%|xmwDRO"s8>]Z\G 2 2ŒI0 ḃ&Z ϼJnm:ʘpd"2:}wj|\\i h.>" ]{go̲Wj''lZ,1K= G ]KY|ȧN():%ީ:KqXisuZNn?:@Q0p@DE9>g>9_o{/J#~EMGQX+2 +X6(ŗ{^mkV9u$YEXv=3G ̻nah?8[oKP5-ɢ|`E/, 㲲n0}Jr赬e5VC RBi*+RZJ"YH:~-{Q#!DTNl;]Z[koi獬}`ZIkUEUZ]}Pe2+B/?]|}͂b- KJ絬|BK0: la0lx'_-?ֱ={JI\kpmD>@ˊCm+|uN/)myHYVz h#X?]碋}7io~FRwʷZ*q z4T{8@=lnG׾bk9 ڄO5=Џeo{r'P7*z|H>2PQ޿;n10ڌaood=>A,`X*<,J. O$ve-1 2Idp2kYJUUjV?~o+J GN(Z>@D5h]-968nv+zʎ_/kp@ @cY[ q[qĽzf liԖ* l[p.Dzw:P!1:_=X}-RY-FGQatXӭC5 }L7k9UNnIENDB`PK !word/media/image23.jpgJFIFC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?BNmfPRI\q<µ|!i&d4]Ԝ kMbuIu*|T&R 3.b\-sa,iO"$0%dghF{渧X`Xhs|űF3zFjfHpF}Ӿ!h>Åixs?z״<U5csM0tյbKi(SwQg\ 몰[X}ΎVO*`j9O!{iv׏X|T `Lv]~UxMm6)Br3K[xGȷԭ\w֚ =E(ʹjMhH6#KF.>Q)qJR❊\R4 \SK.; .)ؠ W*R\v ?vwAX`HE% p O$PX'SV@۲~aŒ/⚹OB|Hz Q0*pv \r:YOUt1'7XPwsR Uq'RyL7/^@:OE(N SMuRRv B@ Z&JQ+)#)x"oz( mzR̆ 4=CcrCB򑆙S>+l+t)qQ|Su4++r 1wv~#[Ƴ\u#9?7\פ=ZDfk9&z1KU~((Q~(.a.)آLQv( F)QqLQZ(QZ.>4S<׾) zY Qu<ĖnK̄A]*'ykU`б a\Y=Wlyoq]h  RG<8M|n g LjRHd/,T}3Ԝf1kcֲ g|nTE!ؾg sO3w ˠb{.i?TIz`?v5# 0z {o,+]lc_M(+Ɗ1?+ ZΕqRK@WﲷͿҫm2>o>\WR-ޠ{W|O$'Rlxv6pJzN)z<ڠ;ΘXyMJȉ!kUeǜoOϚ2+U-j7 ѻ3DOPOC diBxEdyj@UԶ*ϞbI949>A!s}S RObjnUB [EWrʰVŇ?ʥ/Tc^O4:d>4]&ͱ*N.xYqS;U4Hi mu#~?bwdv TV{csP*9bul>?֛m8qAE5eP a5]U[3HA#|[h˚8J2=#0(YמJ!Yኑ¾L.WQ $Bܟ3 |`3Ke[Y;S;QH>"S"ka*71C"=vsH (겓*(;KM>L#~$Co6O2dvVv$R<Ag0舟qA-"9eVLR5ϖQ Qgm2% }W4kJV&cESܭs.B qR0M":olS 2a{V*Gt8yG*K~&UJ)G>441USӀZ;c+{۟ƚ/eY %y񕁩L`fݰ` :Q,- {NQ!1_4Rǩ66?RV)$1ހy*:bt,fL[MXYWJA"ؓ7< *mf,;aC8j}{2K+>᠘0i@suC,'G;a^ dC;+w('CB*NHOS>1:UcW^JmUoߟ`nr!>IOʞ1IJi _o/?}d R; CMI6u4=| }8ѯ HsrϏVZ.Ӈ{ E:ئ) ,_PiU[_TdfPL6,G]  +Ђ?QJ ylq$~x8\ݘ#h!Sjh{}xa^u#SzyM<"+q֌S,ҿ[x%SH6$, !ϙo_1G#zoO6\r}+=G;}'49hؠSX7T^'Ǯ){vx-j*|>Hlg2S eSbU2H xo&6K$PɞCQ53ݖC6d|M_=YFj:}% 4hpL-"vHz([IlvzF{ȿS7A|EH͐Iɧlht}Fj^xp}&sr ~t'c> Qij9 "tL_HQo{`{kA?Lz54wWVI.黚AcA-i>}E;:Ǜ7сSݟvx V[ִ"/lH?93؊m'zW |bBR\[R r*$F  DI+y2Ha8/uܖpxBlyS(h̸$R=kNSU]!3ZjP\J0֓L6~I@'[Ou1Tt"'W[\qmJxx3\ F5;w{*d T[<\U9,n$d}jhHeUtɿF}cEx`٨dFRc<MP̜!3EcBeR>b*0ćԎŏrnR-'b(֜O&3A"g뺆.=&Bz2ՈDTONqh ?,.jd޼*K LTDCwjFaDoBjaQgo!e"ĐILKcosRC4gf^MI.$E'סe"k ̫*^ SJ_i+4k~%@(+ ī"+*3B衳0ȩ`A(Vgj|w u\,#f*Hc)6 b*h'e=4PK !word/media/image22.jpgJFIFC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?mQs+mOe Fڜ@m5>M mRlAڂ>6P}Se mQy%OX6KK]6]QڧKT)v{Qa\e(Je(>}J;;X;Qs}kkX:DZc髥5i.ǘ6CH9e"N%&Uu6}AyG.1wfpK7nE&+y~Ԟ]] URي upGrIiy>X.TKSSy4M ~y^s}\҈K`O˥U/@\Rڗɦ+Ij''=\W1Iz'dsԟg>OjOJ.1Is[_c g>}ڶ~K?j.1~Gk~}ڋ_J>qҶG\9?lRڋ_Qj g9Rڋ_JQnkk~Կc.bڗճ?j_Qq\?/g~Կcs jԿdsV=~E}~]ǥ/ǥr{cods>}ں?J_J={&sazQ1Kg7j>]/ǥd{`LKjd!GlX,l?dw?ڗ?ںOqfL#>{&sgWKdfOQGdo?ڏj~ʞ}}YgQte_j>Ⱦ{p,Kj>Ⱦ}}Yڗ}}(ۇg7j>]VҏnŜ}~te삏lɜ}t_e}ڟdw^}ںQAGc~Ǧia@VgCH:y yr393Y.z~y:g\5C6?uClS9|hn֙R)9bU W5RxI;G,yҨ+ړ̉SZl '9b 'VڲRpĐbFPzQSY'$(c44*Xs4x'@,yua*Mf* !;q3PtP9lg\/ gڱRŖض*:\wϦ)^y4b)J"$|i%#Pfo1ՈhC6>3v<ǍYjù>K#SanqF,ۍ nwE=ebFd|ڪ8$qN[9#p֚dܲnXC+g{RP]).L\?u<ǵAa$޹=B 91^IwBrjk{ZUI g t?|[СqEI-2sCGҖ.y~^0=*ldYriqt+6OxUnLw[6yF8 0O^Hb=1nsSZ^n%Xle2*y&fF3|~()3bSo85 @WEabg;Q})\w̴IWb!ǯzK fyfgɋI&- 8a+[K8F6wL6sVnc0J*@T3YV ;x{Tyykt펢KhWmRB 1H2H9Z @&f grp/ׯ*~hbq1Yϭ#ɸmQE;}O4#`DIjpɢb'a `(bzS%w~ qEJԒ80xmюآvOp.l"ߕ0 k E,L >ԋjPY1#Em%}m}[\(L/01(w4VEY"+K%H,m/LE+dCY{)M?1EVHpvc!wm®yϹfI#`vw^hWCNцU|9 c5jU_-p1EܤaIB*FHչޭ/:l+F'qVR@j2,H>QPGPK !?)2)2word/media/image28.jpgJFIFC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?_x\ڴP:q%ʈ.Cx]YEH]9Q5F5/?=Ggq.`q4ѭjMojض2m]C #Ȯ69m\݋]U[Z Uq3\ 8,mnoeh,iT.QX@qT6mڔ7}s 0jگ}NkVg nGS *}E~DѦTi9=EaWN5)7u]MJSYj\G㼌Nı<9A޵r[CП\ZiVvK]@ynG'ێZSW屵 %JS4F[`J<$Jΰk}x u)63??Ac#A{XլQTWК]MA@ʢ[X$[u<#Ӂbúok.G|%:mA+3Fs^N~*ï `s՛S7o" zMi]L7r% wVuݛxI ͓+n$Б܎N=k7OQU|A̦IBtUYMƯܲ}x9Zg[.L5yA{J q<7Cþ!UgrwYq# R.vgAO[mKw@u8|+)]4a4dv-Z b=IXsY7>&Ԧ޷71/DZI[{;3wɪ/'A\N;2:կP˨{=ƞu@m"7oK]mql:V<$Ծu ChzMyyn½BESl6k?7jgN[o֟5F5Pv^M#JhHOlsʐձǫY[H}~!1={WK9\㊲^g<ևYt}nPO%%0qY!Y_1ծv,pƊ{ű+QBczQrIٝ힍\G"8XH5rBpFE\_DOj>|杕ݗC݅ߩiy,ʯKc9쳌L׭P~r-Gɺو }}*ʶ1ڎ۸G *|fjKΎ gwQJ{猚^PFC^# uk'Kn4A׺}g pK{):52]7 <\t{ |W%ӬQ$%Ũ<꧟z,K!9\+!$N$#p8 $}}.ԧUA;G BLw+4mʶ?= f^ 9# 6sUd5%(Kdx1DvOVzDє-#iW=kh5i=IH&NztDg;'YcV}|٬1>>xUg[,nZݰNTk־*յ#i*# (\4`jŬo3,L[k)8g$vN9>F V?ʝw^.PLTdsmC T2*mF:H/ u:WIq!,I>:L/JЧ6fReh{ VTJOj1CU-R%Qy%-#"63\>!.i*\#+} {8=k5:˩%6⫑x?**{vO9+❠ys*G',~@ |ǩ?^&4$S Nl WW7WI4=Ѹ/9RNurӷLqz[NUgoWm%'/P<`B8ǧLt!aLozS[ yޝOZ:famJa #VWv2pdOW[@rT1ˌ_rP:zg\}usip5Œ2C6z~k1x=5ҭI=Ԫ2Oé\R[+UN]B Nt2F[G]w.6Gc]rcj`rŏS]*}#q\H! e>i@|<LX~Aj#I[03䚉* 3oloB>|U٬1?_ :^ujd5{#./=||o_lzJܵ4"_$gW6]݌/cZ4EomP(Uǰ{w $,۟Y ֠ 7I!>nG>SӠ'5;Y_+(8qz58k08Ab_Zh>J*l09u>ӛT!5g]z4V?tŋp7=GO½L%:5I“]zoogfYKs}O\y;P$~~jABwgnZ8EI]ITmAcb|gں4'ȅGy>_E~[28c9?wCŇJm8Ƽ_=$*I@'c${k^"Z#e>q~Ҫ\l1P?nAq~@ʌ1S2KN G-j|l0nV='K˲8Vvoʽ 4I[KBZ2k xǫ|&]D@OE'`5kӻV^ h;]ŵ̋)qhܕ-ڴ/!OAmֶ|)k;R@$ctTQJN紛/ڃ̾c& qPOzX~e5szv#^.K[Fv[PI`I ]E+6 mO]kWZmrs^^xĈ]6FgэYl֏lo՛⺥wY_k)=1]5N K26@qԓԓk< gJҊipspӡXmzO@+Tx)JVn"eitck TK)aTon@RnO8]kVDu\HWw&B{uO.(՝@)'|U.W߲=U E2W^Ů+-+ VcF#v *͌OrBS򬻉m%;Urwb5مMjvUfx-iK9=M:t212C,Hv!ְ51epMJ(T+y<(J7q-f `3ӧ8e2j7i(ϒrFOWֵukjmp7)c<Ќr:B-TLk>Qt~5lL(fS*V]M y7'M z{y]cO`;ʪ͂~}^ǵiέn:p޾riJNRz֌U8Oa"#wx wFvT,'563~*P> r&4SG?x3R}`\j<Ӓe'^zY d 1ۘ>9]3XjGXDܤ`!sjh3Lws_L:*5,v<*wk-, ¨e`94:n$vmCN܂bǭ8'1Mz%5MǷҟQ]D]V64۫Y`wfk:%ޒY4u80\ױ2Fy}׷׉hm"k(;6FgэY´Sȫ^l2j $)U wYk1 WVЫ+ P@ڇ'(OfWK#G5P2"[4*8R#)}Vo|A7bsnCNՊR%+UZ0ݭ:e33F^G`QF{5ާ3Aqt-cBϿ_4%y.֑X$D)gW\6|+r*qN7WܽסoP{KǍbN{ע~4 [5iv?9(d?> +q-d 5֦[nrlpkigI5Z 6SS&Kl+lΊf##AZ0t$\5i<$0'F2vh\GtWk_>hs<:Oǭ}OJpMs] 6k?7j`3@?w6k?7jC^ feT W'Ԟ/tja^mRy*ǁӼl+jB?BSoN+Q./-#E *=J}J9l;G3yzw-ް7tdKXe>ŹN9flEpfNSbmV4MFZVmm8$>U:e^*/пi(GF__#QV{8l`ǯZ|IiHap@f ?S\nnepJ a?PՈ^+5'ދKS8ŽK[Ԯ#V f4]9Ϲs]ͥVQ ?de°!\J#iv&6 OH|m'JQVKCY4}g8}VӼSosom0k'eel*aGCF=#K,V l Lӵ5ṉ,yjp87V6b$eve_zɖ@mZ^EyVV(N9FH>>([jWVnvU%O*ps W'ᛉ|/}%svNÃWv]۳a^Alk?5 !$]LbUϵp@+AJĩdǫjNS q+gQ߆5i0<7,¶oCbJqRv'(暑#Ҽ Wb̌zڸK&!bףxCm%؀2ʣ=:6˴QzIn^B=3 ȮH,}ށk5I #{tW֪>Vj{ =vJƹfn6]է_ ].͏R˹G+k-JM-X&ԕV7GAZ}o=d\i-x)5Z5olo_H-.e ٿwҬxFgэM:)3N_ nķXrѯV3]=O?v<7AyH(~Y_½7;T$ 1 k?"O>?< ~S%gLڵ iF(e[g,:fFݸxg?vj*ڮ`D 4~`l)+``ckYþ2ƧOEjY^Z"3FnrU8[xsQITk؋m$UNgQ^iRZ[Km>H$'AnC]Ӥ:va ZFēמ1z4 3|E\ZI-nr`o,0 $<` 移оhrhCPj701F, VaQ{{7>-쿴LF)vݜޫomn,N}XB%v0x8@eMVYi 6\V݄dbXz ,>)k ~zd_Fl6V sNTO=hZ/kfY򾛹$$ 7t9-BʰTҼnkW/oq,OBznapK+K3XlK!#`q@Ώ7iYi^B]cʐ@%3 }2uu[KpqI>{:jLT*n[1_BgvV>YUԥVhjvtj>υg4:44I 릥o*.D Joo$U0]V"'!jĶ@zVEč^$ơulmn5DmP!sT]JcICBG|ړԚ:\H[BRk)-fۗ;@ixC/ﭵ; %dLgBF29N187u[p,@U| p^du+U߳N-_[icq:u2ISD:MZmIG@%2NGym3tZoawkg O`Fߘ{eghhkP&MBA$1d(B4fssTK^__ͥXEh𥩉fҫ6F1\~֗'R"۵W&O%qBv 0+ODwoW:PGo9¦p 27^SzOZ-n+&,e!@PxQ7L/>o3,mUV*m{nZچIyE[DJ1ޤsA'5GQkK盍?۷uݞs@[KPK7Tjib@ʞnx^摨O{ej7LԠӯ4ež0O$`mg#ԵY%9.:9ګM&_k6}K"E"̻Ucc"+*00Ih֕-}egw( pAjc3GY\VH[e]H8޸+kInuWgnaje6χ.mUP5*#30!=noI{,fU ,pA4}IK6@ܐLJ@Ut Ե[^h. ʡ(‚@d2Q@Q@}O_,W6k?7jjFgэTupN~O#uvWWv+PN:DYW%s {1d]IdG V (FAZ#Ofh{$|˳ y ,q KTjKec%P8,qAi:tSHgҜd3"+:`Azu4\tI }/ M>!{5¢n.H8ZŔc1ry$NDil q-O'J| ]Z+u/M;,9xA6hv25A'89?:PA%ɢƫb mT1Pqn99Ҥ:ґ>wtOG3.H1(}ltA*Y8$?=8Ʃ`KyTXʻBg8cosMbVլqNӀq?$ʣN]i*ĞAm4`s&[9bT6 b`%F#Q&tQpsqzn`s:ոtcUKD"Ef9 c#zkԻX#q$I &@j+N+z3٬1: 䶝&r7 tuxz6JMw,z 9 85?!?ƳuiUb}jW AIy  u* 9/@ 4_OO߉|d,#UeNAFu;t%!v Ncl_OOςBT?f&Gl|q>QJUoS*@sנ/@ 4_OOGx]b'i!fin*ʦO^b1 HZx|hĿMΓUECvr.<`qTo/n/Yn3 p? %?/''ЧI;:6sTWK?!?Ə@ 5^ڟuú9+ĿG %=>i樮ςBx|h^=Q]/ %?/''i_x{XG5Etx|hĿG}j/''THs̉uGmo$6R O7??ΫvJ ddmi85J1N1jVs(+pw2`W*#$Ԭb\ƧzY(j+UaЀFihI$(()@qIJC5ߗT]9s`l\nx=EYkHS%+luF8vnh-e"Y۸N3D6ʑYJUs(` =Mq -+H؍+8N:vTq5`@dgg5M?wav27`gh|g{qr8ГsO6O. NKyq}?81T9! ~\qj4":͞$mv <8kVZi {$fˆ+?TXxg2@Qۊ*()JI+qkjkj3jHZ&v%$)y1QQ$kPϋ>/??Š*ldy1gQEA`ϋ>/??Š( |_y1QEX?c(ϋ,Gt_Qd迼 ?c( G|_Qa?c(ϋ,G|_Qd EEhkKcPK !@9; ; word/media/image13.pngPNG  IHDR?1 IDATxR'(&$*% " dyԭ6pyٽ6]l<ЧS̈́j>֚QTTo߾Cյrه>~ɣGn߾_vԩʲ{޽mơf?Jؿ?O:q_YYy榦FGGyڅ #G8pdϞ=i0F2@}}}{{իW'&&/^^bBp]""O188x֭3@Ço߾e & \x}OFׯsP c00IVUUO1T3g Yc={b~ ӧ-ӕ+WxmKK 4X_?~t ?X$1Mb}ͅ" p7oewXl c ˗/Sj CُB5766cs *1*l2_|Z[[cZZZb59]F]tܹsiVPVapL 1$7@s*{m- ,2l%BُR8E6<< FPC@))_XVZL4\ 뭩)KM_?~ ?;;;Zrf6>s n9yd:GGG7)#===T[[u'wO`+qd60aPj\GOQCTR5Fg暖 0z&'')8@Oꌺ"G†q󆃑08Ơp%HX_?~<)|FB?   ُSI5,L4a[{}4sϠV(0@رc5551X}|9ײgȒYF_?~,sܪL&s$>89qdå0/dR"8}[g"Q^^^VVE00[ XWb~ᖂcf?Jm b`~*++JJJgsps),،'tx#v˻)#*#[v,(qvS` _Q wGc ;0 1۷o߶mێ;yg2+qqjxdde0iNj+d:|O1Xf10LRjY2ڵy4, f۞}4Ex{ZaUᝦ0XRp Csː~A1f?P6j=ʣs+?YLlpis*@AY%Bpxϊb/N3L@'i#fs%#|LjO\W",c@(GO܆i"br.&!HޑeB NlBͅC_??X*q/OeFl6 `|||xx77 Fm9y #R~hhhrrrnnP(ߘ-..2 wQj<u5m<:΅hOmi?L#L.333KKK+++kkkL7"Wz˖ֻO?^|`x}o>7؟^|`z}Oo>?7؟^|`z}Oo>o>o>o>o>o>o>o>o>7?^|`z}Oo>?7؟^|`z}Oo>?7@_|}}7@_|}}7@_|}}7@_|}}7@_|}}7@_|}}7@_|}}7@_|}}7@|`x}o>7؟^|`z}Oo>?7؟^|`z}Oo>o>o>o>o>o>o>o>o>7?^|`z}Oo>?7؟^|`z}Oo>?7@_|}}7@_|}}7@_|}}7@_|}}7@_|}}7@_|}}7@_|}}7@_|}}7@|`x}o>7؟^|`z}Oo>?7؟^|z9IENDB`PK !A4 word/media/image11.pngPNG  IHDR?1 fIDATxwOTGgQc{ ( `.bÆ X"v ލ=ꗹ+%'87Y'q23ά=~68{Eś7o޸q5k /^%O>]]]]YYy%_~lѱcx|3fddd$CF=WTTDtLG|͛7o߾@x§N:~%_~lΞ=bA&m۶zjɬY2cǎb,''6ćصkRWWG;w4%wRڵkpMG8#F{x -Z\RSSG-95|Nc|> P޽{<%%Q;tB'tEG=}ɓ'ܹ>EǑ/?0 !f&e˖͙3x5jȐ! J{tݻws̢CQT=~Y9ׄǙ#,43f ~wV2K.eh, ˄=ɗg~Ġ@ޖ2t>}ѣgϞaZZɓCuֵ,2O0n˗[~TUUŸPZZaIs?~aàwڵsr!aYYY ^L9z(3ZIsss(3Lٵ555Ǚݻlqr"=L#FإK%.ӧOrc.]jllP4q/ ph+///?~2zm߾}۶m%dmƎٳg/Ys֭[D!_~q2^dUV aݺu]YYk.̏oNh S6=ztM\:t(#uQQٿMM˗ݻG[Ǐ_~}Çlhh|uu5/?(lժU ڌ i+z̑2qĹszΝN"F}0p 2d̘1$Ǐ_ |#Ha|1G̴Q`Ĉt-y”~( =z o>̏6nHϟOh1$lРAx52g 82_3@\zۖb8̏ +6 &aÆ1_S5+++|W^AqݺuǙ;x̙3322=eċc~D 8ŋ>|Ǐ[SɃ6ċiI˖-/?*33 %+,|wAa8ZUVVo.Ӷ|qGSL ;b @JJJ #$ٳgx۷y9lڵFے/?:xq rrrh1%%%Ο?E-w2v\A¯-\̏,B eL _4iӲ× s3g0I4662h3*\Wuuݻ,WEvˏ3?OX17n8 "gO/3.$΅.CȨqnWl]ZZJͥɗg~Di`ʦLZZ&%q9 "1K[  \ٳgeˏ3?ZPþEʐT c8qą w)Fh1eee|K2PF8E&P=ܺ} gee%1j0M:KX1vw:tsؖ-[h4+W3ɗg~x/_?p|?^~~zO/_?p?|^~~zO/_?p?|/_?| _~ȗ@|/_?| _~ȗ@|/_?| _~ȗ@|/_?| _~ȗ@~x/_?p|^~~zO/_?p?|^~~zO/_?| _~ȗ@|/_?| _~ȗ@|/_?| _~ȗ@|/_?| _~ȗ@|/_?|?^~x/_?p?|^~~zO/_?p?|^~ȗ@|/_?| _~ȗ@|/_?| _~ȗ@|/_?| _~ȗ@|/_?| _?p|?^~~zO/_?p?|^~~zO/_?p?|@|/_?| _~ȗ@|/_?| _~ȗ@|/_?| _~ȗ@|/_?| _~ȗ@~x/_?p|^~~zO/_?p?|^~78(1IENDB`PK !]fword/media/image3.jpgJFIF XICC_PROFILE HLinomntrRGB XYZ  1acspMSFTIEC sRGB-HP cprtP3desclwtptbkptrXYZgXYZ,bXYZ@dmndTpdmddvuedLview$lumimeas $tech0 rTRC< gTRC< bTRC< textCopyright (c) 1998 Hewlett-Packard CompanydescsRGB IEC61966-2.1sRGB IEC61966-2.1XYZ QXYZ XYZ o8XYZ bXYZ $descIEC http://www.iec.chIEC http://www.iec.chdesc.IEC 61966-2.1 Default RGB colour space - sRGB.IEC 61966-2.1 Default RGB colour space - sRGBdesc,Reference Viewing Condition in IEC61966-2.1,Reference Viewing Condition in IEC61966-2.1view_. \XYZ L VPWmeassig CRT curv #(-27;@EJOTY^chmrw| %+28>ELRY`gnu| &/8AKT]gqz !-8COZfr~ -;HUcq~ +:IXgw'7HYj{+=Oat 2FZn  % : O d y  ' = T j " 9 Q i  * C \ u & @ Z t .Id %A^z &Ca~1Om&Ed#Cc'Ij4Vx&IlAe@e Ek*Qw;c*R{Gp@j>i  A l !!H!u!!!"'"U"""# #8#f###$$M$|$$% %8%h%%%&'&W&&&''I'z''( (?(q(())8)k))**5*h**++6+i++,,9,n,,- -A-v--..L.../$/Z///050l0011J1112*2c223 3F3334+4e4455M555676r667$7`7788P8899B999:6:t::;-;k;;<' >`>>?!?a??@#@d@@A)AjAAB0BrBBC:C}CDDGDDEEUEEF"FgFFG5G{GHHKHHIIcIIJ7J}JK KSKKL*LrLMMJMMN%NnNOOIOOP'PqPQQPQQR1R|RSS_SSTBTTU(UuUVV\VVWDWWX/X}XYYiYZZVZZ[E[[\5\\]']x]^^l^__a_``W``aOaabIbbcCccd@dde=eef=ffg=ggh?hhiCiijHjjkOkklWlmm`mnnknooxop+ppq:qqrKrss]sttptu(uuv>vvwVwxxnxy*yyzFz{{c{|!||}A}~~b~#G k͂0WGrׇ;iΉ3dʋ0cʍ1fΏ6n֑?zM _ɖ4 uL$h՛BdҞ@iءG&vVǥ8nRĩ7u\ЭD-u`ֲK³8%yhYѹJº;.! zpg_XQKFAǿ=ȼ:ɹ8ʷ6˶5̵5͵6ζ7ϸ9к<Ѿ?DINU\dlvۀ܊ݖޢ)߯6DScs 2F[p(@Xr4Pm8Ww)KmExifMM* z(12iCanonCanon EOS 450DAdobe Photoshop Lightroom2011:06:22 23:20:02 "'0221(< PX `hp  x6363ܠ@2011:06:21 19:13:502011:06:21 19:13:50 $UU5GBhttp://ns.adobe.com/xap/1.0/ 239 85/1 85/1 0/0 0/0 0 EF85mm f/1.2L II USM 0/1 1.0.9 1430307632 2011-06-21T19:13:50 2011-06-22T23:20:02 Adobe Photoshop Lightroom 2011-06-21T19:13:50 C      C  " }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?Xj?MM9BOЮ5x,Ƽԯfn&r%h%dk[=T/o=}uL`ZE2E}_Njj>=⟪Ttic KjYi"砮o煵޽S S;xIGւ$`bubrR E!һ/4I?}5XS05S\1smc\s\~ҡɩۗ:lPUq cc^Sxͭ70yև8OOǴ>a֎g5K㏛"Oʴ`KZ\;uy>k|.ڼ/^8;k|-ⅼPYOAWra:hw6޶47±Kqdu]v(uy*Cڬ-T$shENGA9̬Y9ՙb޸oiQ֯KլAmpξw8vGh6!@ss`r?z bq89WEJV+3srF(3O ~J 8|[vbjv O0Ǔֹ}$XqRgto =)%䜎sɬ9O#$MJW51ʪ\jʨK8<2ܗaا66IWjsR׵)Hͭ JE$!&C5:r WV~Ts|*'oyI)V| JCji>f<XA'4r::d#,*6rTb]oF ұÜ=qTfw8Sb֡YsqCLkTL/pF$3qvrS-}2#˘XJxiIu܁QGS^*q8?Zlj,~1WJ?0JlHL眃\&2n\Lc>9Դ${vhmMWp5o˒0*-n:5'* 6d;Y2qV]# hEXӷlOjl#nfFְ)J杫Vꬫ5[:zd\rflrƷN}I WE`@:脹)`y"5g`iaEnYL6~;n=?hZεǥZ|i7טԂ@ըgC%id楽4+D7jxqN/izO7X9xR 7}4LSbG'5]\w;,y]Ƣi0*)'or$M9 4q*;8Ojb9Ҫ&4M9e<$a6sj]R^`='RY.I皯 Kj8I;IY){G+ƬssݽX%Ȯ9'?άsRw4V\߅=$qT#TyךkSPJ4'P'?¡|2:$T۳ڢwץRq?:q&Q:ҋ{2ʛ$^ pFj'oNV15Nf U ީ]ɵN22+hͲv<}cꄮ$#N3'Tn?&OҥaFJ^W-g! ԟJ'yڴr 8rsSEyr{b:#nSԯr٫H\+;ܓ}~sef=)|T#2 )"/&y9JwjlQ @]K˵ zX.,z|gZi;Z)T8~q+nUz}j~kxϩc%9|ɩ=r=*!Z"NPsϿQbxOp9ުO)#]jW2rĄjH).犯3U9v!GOs֙( SeN{Zk֪O.qqL54-3P=kxA^z4ݓGWͩW&PU{ޞ6 _~fT`ַ|:#Ւ$` l }ҽK#D>X9-’I+68jRpzlDPGN·R83}!yA\G'}}(,Nm+BQϋk$gךxݔ-@ u ,/cy c3 1*e('E-ӌW.N|4DG1ڽFc`+L2P\ǗF}N̐IָF9Z=F du?őӚ>.i$x>AyZDwz9i!<ο{p.J:h>(.zoĹx9Ppy-7]FZ9*Gۼբ}A#}ҼӾ1sz~2tp</xi˜zK9B-Ql*y9tJʞ /lW+ri`F+w.et~SdOxӤ( gNg .P*wdT\M9Qvek,/K`ukDf6!T*x<ךђE>}qzptROJk̻XnqGZҐNj7 "Xn׸#Tr[SMK`N=Spw$NʞIҡ`{c+sV42`X}9IN[=? ͎Nxs sOC),v s9iaTX\ՎLg9VV̷1ϧZKQnV4E#A,wUO֤9 cr\A)aC7Iuzln$>=;Uyʜ֛=eœfyr?Un5+O j0=E ZT;={ D yH5 ǥ]rRC* BX峃T vn+:=GlaR6#w,o}3$rTjLd=zM1[AHr*RԻh<zk>F8rA^Cq wT.pR;ګϖd)=z4d+sӐM@KB n=*i^W'1ܕR׽[ zp jf3'+J[~:$tB.WM\ չG^9-r2qSsgMXp1qi<A*;悖CasHxϥ,qrq!AY6 \D J'=j?(8Wvдr@5jGp{S]uE8H$oH{8\s{;2<zy *NsYS$ZI& WRzYNpxzK]TeW~H$~uJi vS&FU9z|8=}ӨUTOº M!/"  V%0畑^ۧ8[o$\DŽT!p3\UI~JHwgJG,gFd!'=q"C y{58,af↾1_3|@׾ݬ>q׿Fu2,%5([X> yq9^α|3:o'5sfP:3Ya1t u%׈ e?澯/ȭ,#<*<;s~2^ 7]нme.zO!ā+4χik&_,a9\2Na/~G5qm=Gv0m cʩZ[v^іp %N Dxuq s͹su1\:ILv].2kQCq5LN3֝q$sT4bUzUsڲi|m}%d`k856 q5ˢMq#k2i3Ps! 93&%% c^]3$SHerp{e!W(L(b9?O8Ɍv 헯6qھǘd$IGCV4yC C$Zvߖxp=uB:qw yIQ`5)aCZJ'ZY$qҥ!#$ TMdVƘo 9%'j@zӖm9m͏lВ95U&y#>zHܺ=jt~2zU}͎* ͓bZ i=i\9ϭDf'!A.t,y|1 \(ӊN;`Q4)fBa0#W?y=P"DCw`ZjɧG*ob@0?U*Mx/ZCEY@$0}N,1& 6sUZ Ea6XzTey=ђ?w֠2mY} QP=#+ۊvT2[Iz<[+[5^A:Z;|ݺS984ɤLfj.$9 2O^i>oOZlҁϯ5U<ȑdK1M?1Uq>=5sk[e&]kwI?W@'2d9?5M)~]%?C$L=q985"$vB[o|v*Ȕc:zU8V"6Lus w2wF95{zU={p>j>drwsWx{Yw99V9)ZGL㹝5jsOZo W5\z~ͼ3ֆܼ`6' (`[ɩcqzt$Z|vp@֧XE栖2+E2Gʡ܂Awކs[\c ]h^zjۖnkR(ήZ7`v=i@IWmTƱBH!p<Җ| ջxvmIVԎqJҳsL0V;GZww& XrSGk_瑜 㞦,ZA8{(ʩ3UjB3Q\k0kJ!AR^?Z6rو#* T nVN E]frF*$TX#85z qY{t9n4-;p85f9+:)p*X*{eвjsudNvd6[UIosk>kH8Tn/63pi~5y/Sҩٴ;{o x&NHL3s4s\]8N>kE-ܭc9mlcb rG_JQ074vij\mMWUeҶ~ V_DyE2:g$ta2gWݢ|1RU=?fK7>se{Om:m8$sq_Z߳l-0?ٮ;wC9 `rT\L&.3vكmLjS֤mkZ;ո)Qy4bd&Lj_ skaHǭGsn{ ]η8WQgrMr ฾Ƹx7;v~BBh|=Dz5W6QiCxNS0+[x9)S<"95ut\歯f5j;A<Ҕ H;*X=)w=*|񥅲01R'~O K{o0 qj9.:Eprrj,m^B3p ^wWXӒ+:?_Z[˞ e^]zс//syrxUZ 18ϥSDam f]C=׻%'U~Yn8'5b&񜞼-z9n~cƒ9AzRjX%'Tc_ΧsCCbzOMTIy{{JL{^q+NjJ6Sd{=u) s׽0py5~AlLg=}Xl`zrܜU`qOGhVI2nUX&sRg֧qra!J+ Ҫ#{S^s$%2OQj88'Zo8ϵkJ2i~_/ qF|֭D[%91n'$Ig~n}*3qqW ]#*z$;gh#y==yRq39%?#?Ϋ>}wF=j'=ZqTBԴ dpM4>՘94sI*XS22 V2@?847v@YhG4|**sP2DUStZ{! 8oکKSe(sRq5.b77tjM5$T WTX]Cw7U$qWOds;Uod< sdr+E1txo&}g L~s?oHG;W 9`F8jtX4ׄ]g!$p?3_ӣ<9)Ng EWd^}a(ĠzWl7zW/P"p;QӱɄ8TGϾ&  =~xR\uqS+>n}E6Po3ҹSP+5]D)sڶ eQ} acҲDDmsMq^sx fe-ϳ^:߼>뵸^hxC|I߶OqqWӟF]<_V燚Fjy+\^qb3בW1? ;=z7 Q<sB zגx>+gv^R0q)I^=jВut##7xcIZPVv:4Mnη!-ڼ߼ϥmC# ƈ;Ԧ_Q{{N*z8#sZl= 9Mc̆rX޺g㹨ƴ\?xH.Rv*R掇OZБ)02T09Vn$sNF@;R)>*?=z9zt5#JPz cπpzո9IV4yr0>S7?-Lt&>Y22j6s*6'߭0zVv,$~ Uh1t52I u-9.9F,}?*LOA cqB{#ޢ>\R+uKaxO'ןZ2:їՙ$*n9cSl{$~xH8c>XR||+>NOY ⢒^A\$֓W"K&'*ě}a_^y8e ۜPH!G 95J(D6Aw.30GOJθbvǿT#3Z#6Ɔ‘ҝ|-ϥ?+HD#|Z* -YH_[ SM J3BDR jN?J1I֬}NT{QU?1_74={)ӏZzޥ^Y=X7^M8֓88NYA43֞NOHwn)92/< TÑ)lZE_ ( |Z Zʌ 6cO y'9׽Z($[b<gcۭ3n9ERV؈' dҥD=9yn$=5F[un`E CUӿKZ6ɽ8h[&zsTǯZ9PQn{r2{qP[),+z6ksZV`uqqWa\ucT˰ǯZIuD7Q?sMĶ`V R1Tcub0.*Ŗy$NsO*-9jgO4E_=Mc=lTԡ`&\YkF*IbLf $#®_ɜs9ZNy?ݨfoǠɮ)uFO$;y`sֶFnL$=* e>n I'UwoZIrInsU'?)3mU$9'<\ꈘai0뚔&ZU#ŝDQllx}]\ťijjqtO ǣX&=hj1*tVeX_QT@edpЍ6[|Zg  v>.PMyT6Y9:_]U7bn[pqB=J k|OLV;< \|fqUekXEpԴ5f׭{[hqj)7׾#HerWOhpЊQHq%rLjn~OzƞrxO^^;0QWLL&250Sq^Q n/ov`$8+ֵS! ுc&.FJbfҭE>^{,H_g+F`ztOwl h과Z]U¾- M_s<R#{'cx銃X8'33(5+lc^@($u~8]>v 9cW80n"s=K $!X֫= Qֻo I5fxK{ |I cZևcs<UDu| 3u=Gz:0ǀ:`V. 1]R>X!t4Q']=+W7CUꡑpzjW81l汧shuYݣ|zWEn>8? 1Z88XN6<\ \\65+ȯ~bi\7zt!Ҧ x')GFy۰Zd+\>:J_KGc0rz?Oӥ>Y~⠒^@k "5L&L}yIɷcs=:!&=j1v7^ռ;V\޵f+)SPJ ?ӌrMSmsyθ1۞~r[dT"uw5$s|ܞg!\$Ҭ<s9lVv-%;ljA/#Tp G=O"yz4rcUlzPХ+?J4q:P`O&FA)he!%$xQL8Ȩ&Sp8Q'`jzQI=* &<\g ӵfOAfl|UI;<:F=gsSD1؁t| \܉> =A 3m]K}1ޠ3 '뎽sQIۚA=JX$:zcjq֕#8ps֙ @֬ *X *E-^5$x$g\U8GcSěGNA5:z7zV RX=jzi>OZv ڢ~M7'*Tթ|q߮=jxz |EqV4~A޵*lsgFCܴhr3#QM;k3em$皝9_jrd9=jnhb\m{ <7o֥E×A9h*j6O=)%lg5IOQH{S }z։vpFu<ҥ/ q?ZЇi5-o~㨬=De)|/@6҆ lk1֪]ϐ{ze$㠪ez񤠮b+]>3+6]:ՙ`9s6'8LҾ3N\1n$*W2~5e&Uq2jN:՛sMQܐkdZs3=z>GݞتHxV欅$cTlʘӅqQKqe&I#VyjkO}zR9ns[EJCglUozC׎#!*Bǐ052wsL*Q9[ŕ XE 'wI݃*n$\ޯO`IlGae:J&n#h +ļ[?ɹbd5mSSL~=k\=XTvgro%?|Zͣd#ּ%.\ZnIu0pN+usLa8cɰN۱i1'y;ĶY$$8<JP\'ud WjsU5N.L²QlrA׭^mG*2kɵ_Em$͎97Ꮗ"_F>.bs^;jTrh\ N4ҜzS⸖E&b;^ߊ,xw ڿ;KtdA|{Rs3{8LE{' %*ZXPF5B] x A< O3D ?m%($׻NjGKjЖ_ n0]# ^-ᯊA|%IXhFkF k>)xbsWQR ~u]`2auy7e μ-XJtp>q4Tp^g˅Lc{V4b0ǯJոzVp`\/;398'[^&estJ5y!==&c5xd*^HN=鶶vAF# cҾ7-]SGPFѧLV5/>Zs\7l_Az9JSHa%1Ғzbi Rirs ߇v׮EynU[3Mha.TyZf^GT,lL Cy_Nq}cpU;9{Clc OF9CuRSG|Dc΋ zR}p5 NM,w{; o &a9.8*r5Ox5'k:9瓚C83֔W1icOxmpN}i*\Hln彩MxTMPN*:CJn]˒ʹqJ9qP5?9tTR&{y%nT2σ׭Vr Q3sԞY9U#"C߭@O4=):u>ɒ2GNi8q!I'B'@~lPJ7Oj.osǾ*m׭Xgj22v8DJB$ւ:fjl"&#¸9f9G:c7IS =*[Ӆz~I؆4_lOJ"9{ !'$c=iiY\{zړu*=TaOƚrLd 3;Ҕ9`֩.Ę}i $cB7rI枲==Ud }=6CagNNiqϒb.#f3R9NqSqOdGtAOlܜԀ1Y}MzzMγ➷}0yuYw5En;?ZcOd9. ǯ%"'roydxԫ1یFxϥL rF*Ը\Yr\ }@G#oJ=ycXPF8W!0p1X ~P &}?J;TW;@$sX[j$-;>u%x8ɧ?/XHw5Vޭ9u OH{,±t-;SMo{gRgAou)s<;k^n;ッY$\dkCp g͆8@8X' \A>{ҥKrMcCJq3ގ@籯&~c׊&GVLQ5qBshͨϸTc==Ul:U /23fqƘnr2nýezy& w*1ҠP;ɪۥ;OJ3K\l'Ukm9 zs=N?*){zqQ\n\p9RO<Ӌ9h\:SOgԠnslvp1I QBy?<7=x܍c#qU5$u#;#Xf)NyV%r-r@H]ǎ󮄙Q0A=@Z8膚@x>wvҞ=ilq2x*>n;qTV֢ܰ~&zKG4nwQHŸ_֬J1/:z3d[SS=Fj$Nk+BVw,8ךɫ}:bh3Rz9IoHsz"8z K( L֛ #څ3j|kxĆZkݐzT K gNYzը6I<${xs,t~^i21UV|IF|t楼$3I9bs`zUki&|Ui N{u?*21$jas)Q={{ֶ1%iLC,cG$⫴9>+h < 3drxi& 3V$S>*2`gV&L'73ω}c9{ 8kľ?kFm3ҿquyi9ҹRxwe:~0mX&%[׽xOKxHqmQkd'yx\W<[0TiЧ =ϡ4AX~481Ri^'4op'WE{.exjAr)|fltgŠ>#x]ۺ@Y+?]u|r:x}X6+N՗S;RކWυw.$rܣw_l|]c1:me" p;u`!]"%X?<=Uy367*zm2:Pͮ$_(f\:~uq~D#GQݝ}ײut7*rqޮ[Ġn84F\ :D6ȯh N_ IoQ^wmdnO|^c:1IW.cCTݷ?D elfLQxkE-Z?4t]ZI>\O#³p8SoN64эH.zj%-ިÃGr^,ʣ= c9k& F9c`HQ\ZOsVu|f%g'teR,giӡ%$ Tni/URx8ɬI%|8N'SoBXGHI>9z~IQ-ѫ/Ud#R'nJ2$i'gٞn'ؘ:V/U<%m)Ҍw>I#)'O.:J?/acϵNۙ? ~z"$J{DLb' jm m\pἊu%u\2F05_GO!kUC[=+~4b[iN9澋1&nl|eAk;ۚ~(yŀnֿ3L3bgM>J&8SU\s䓮9؞1My!X9x5`J^Бu֗nauHNzӾ״dfk"oMu쌱x&DN% LP?f5@_J>ߡ4r3764=:gGg5׸95{9Svhux늧I3r'CRߟ(n=j;2)!/=F)\irYdj?7rC׎8f9=*6֒W4'ΡV9S'Z6!2^)@'ځ0=w z0qzsZ8zPiO=Giqڞ “^?Fzfh#6qis~L(Q3ýǧ>o֡SϚx ՉY )`>:8ɒs Oǭ7w?^ri=E{,I'?DOqNeݞ>6rHM.Cڒl{~ -dZq^Qy\qQמiDLCIm<?@g94ǘ)RV`OO<ԉ0 .R}9HBO/Q34, 9Oֲ`Wm*Y4*xA5Ҟ%ׯֱ^ƴwi?9n#5 ڜ/ӓ~Z\qfFr3S%yTysŢsz ݼj$s\_ď|QۚJRo8֬1kQ׊sht=*oc\X2sS.sya4s޲g\ƙ y)?Ҳ烊wڽ~qpͻ=EE$ zisv:ІғCқ# f{ʠd3ۯ@d (?Mש☳=j)fYEIJdE;_Πk21L79+9ˁA8wCך;#? n@piqMR`99<7;S;JEnI&XG>V#+zz*x q%дW*DdsP'in;RJƛ"8׏J)z= t8lEbԍ7ygMWLui;I-Pw?U;[SSOtECҙ?Gh9*6N?tSW3r',rM(Pss>RFE,i1I$8T {*H_Hi)('"y=17KӟJCgZVO;$ /Fj$ ~tG.Z"i/lɤ7AֲjIT`9z%#sO) \͜IdݟZd]dc=jm1L$?A$ۺ}*).rޞfbEMe A𤅫2Nq($>qHgNOPJx_J|@= }k[\Lcˎsr{w|GW_SZ$DK*l$vOU'>+hŜܲ&3ޔ9Jsޕ9?Z:Էxq&Gznw5^Fq֬^[s^A3# cT )8S㬁db{k+v?i{=u-|˓?J BHWkef\J\Y[9ZZ#tdqH+Ǐֻ=?6Z pQi\b~lcȬ>VM}/vsd^},@^k*ÐAԳ|au>fe*?#` pYjWӯ ixG, vZB94$=gQ/jF+^2)5O[Gڲ0~ zPأ;q5EoG^\*0wEuIpK׊б-zU6zڍݹ< ?>8 nI ޜbXDJOTsq&5Way>\ױS^O-~n򟂼iF'G@/3E8.qn GX5~՟x#`x($4|A{I#aA~O<2qs޼'=V.Pgp~2 v[v%q|fXW8k˻zv]lې3df=ZK{+8 SYR|:!RT[k;s^*EqҼIX} DC_5%.-)˒#Ͳڅ uV{G+KQ[7;.嘪FD5_m|I@:עpMǨ/*TƋoߕy\z׬|z}]"xa;gqJR79Ҿg!p?ݪAZ~3T}MƤJD1Ripsz'ڝ\󸦴UZsښf#;H?T$烎ǽ&|ڗ~T jr::nKw.}OYH9*dbONԙ-NpixCQ83ڕ^ Y&88I#?֣n[4&ԽJLVcǷ ?KѰwa$#Z'9B Vbػiz{RA[C#y5մ:Sn}OHi,jE.pO*o~_ʦR[CDi!cEHh'܌TsMddO^INf 5לOjsDWdv6yrRn[JCb1,o5A#9'ʧq$Ғx=*#9i]1:i`&I IRGn3Ќ~1<IA!ѿpJrôrJ6`4jG=%APRFpycKUaj\Sҟo=$fG֝,.@)OƜF6zI;K<՘pt|Dp1Va4&i';n'J92)9Jk֡g;SgM+hadAQI.ጏJd ,1cufSsӰN FO?T8NzWJ9b J.ޟdKһ`zj͠ȣi%!q.䞄s(+hjfrc>ޫ856ز1Vr:i!B$9 $zՅ'IR4&Q+j\jyH1;g^̤GAF5FqLmBgĜ%EQ$>(-I/^^i=3Lm^*$2{Z# $}*z,bA"9/Bzw~ۑbz*HxҦݚH2fy#Z"R!8au[[.@cjzCט|`>e('+NĞcʸ|m$RC cKw2ƢBn'f]ԞA5"S(\*6y`]\e|a=&گhK :_/ 3ּFz*#޺!^TZkO.0FI^_"fAyt apP=W ƒ˖b{^qY(>̡eI 3E+^,)Tvgiko"S^+߈+ByW_|BXx9<׌|nkLWګ3JoQ0X(WvxNnCo^h Onb \OZgrpշ3p  Su1 F{W'5=>5dٗ,]ޙO*K[ue`[`sC] 9]h٣z7Cg/1`\^HڕSꎇ]PZKˏ:Dum{υ@4m" 9 j45\GֻLG 9Ksrn:aG|׹91~fO&pm#G`7ige f! ,%yOC?L݅Kͦc9>]Ҷn1kÿ r?O]%22ɯ3*v>7FNgkOeszWI?1ZmBx@]znQ:zCB;g百KzG4{2u*1[Ia+I\1ظ㹯͸ښb?-͸Ɔ:qJ^FXrkR;O. _so?>TԛM7, ]>EP3ӥXǽt^Ej'r>kS<N[HБ WZӏybPv+h>lT9s ʭFlZBo0C/ɯ0nWM[q [F*hjSǼZk+p>' rdRx `5?l>̦|i4f$i<܏{Uݾa(-Y>UsRvQw(9۽1kv?O"r= 8o,rW+2P߸9 GXIF;M^1^t$sJ.:16 3pu:oz2g @1s9[i5mq=jLwv'+ıIL(p$OH>%F{TFH>Z>ԅvr9i?'ݚV^;J5@ۊv nzn֕~T F4ɓN+?#qU8qVq{izd42-`J|i8*&;z( gϵ1nzLngjZI0NOyUOs#hMwGWInZxl1n̘4)5ez}iԟZ!;<}='Y¿A[qژxZ~9?7J=k&XV9$sڑ~x曏@jmi`95]_ss 6=)7O>T;w8'TQiش.@<(^㎵P8𢶊-=K&b|Sj䓑TMM[[;-kix%qp-,ƟCWxNOn}kdzԉy}OJG̍jXzǎp}jDtjӖp[g>9֬%VOZ nhA;`}O)H*AJE+wG"::vBA8z4YK>j%Iq5lgf3i=NfYyDL:A JCwﻏU}=*GE,A 埞=*-f1ϧ5$wtkc>{PNKy wf!HD"܋7@ҫq>VKcJ]sz!S&G=~r򨗎r9Jwcѿ'L<1$C>UI=7}jx-HrFCgsSʁxߥO6$ ZfAl8?ihơ˞)Twµ-"x߇8Jd8H1+U"c'g*t58aNjnO\~MxyEZmW&xF..ICgqwe{UzR\KZeZlzcMzj\u3Q5{.R',I$4sKq90aq3R,?]1v$ӆ:Ugg' M'$`TOpsfy2IzTlI<Б |S Kyh#z<❭py2NHiYЖQ?^h-.ӏ+Nk-H|7#OO3 7vu]K|E|N?pU}9-嫔O(H_; sWS8^g%>Kpq9=IMIZ 7 ]ZPsOJ1TUj^wnszUPҸ15hRRH?ju*t=˖ǭn[[~Seh{m˞rb6l[~ ]-fRzמ9|7yù\zS4dTOI)Rv$uiڜ1OCG2r^o۟zWTnvT8#咑~';9h}_{(w&s\79sFJݭ+( 91u\G :9MVg֥Nr@<*%9TapI /1A$~rIj"yk2q)ߵK1ښMMxꗮrx T PH 7`sڑ@L,^ s*E`1Q`P懨ING9H* ${ՕM,Wr1UYpzrI9 RarszA&3prxsBadBL#q5$1N\FR ґ^sj%jxzhzRSƋSM(i%u9s\coZ+ݎ_92MҢk0 G$Y\W%y gG$ɼ޴.OR+9Hܛ ϥֹe~5bZ_JˊLxHyy;mwM\lsYz|Y0/֥L(QqڧY}@XMuFzcNb)zU$T9'<&5 >zoo&Oh[O^fqɐsH͞܊ *qS~曡qSGRoήyrUʅwtڵJd1i3"X9!G4ŷG'EDp4دv# TA#4+P:dTn)c#+bӃ?ZI;8J$>G'PĒAR~Nj)f1d& ɤYLlI89ߥDc rqts6O%3ҡrdz⡑[$+ܜsKdsTC*)t>2c1$l"BČ=:$ۊj>GZOzE[Q/sV&ך'ZR5ާ۽De( IGJtE_rH#9W[$v1 ZfBD%?QIIoʘ`V,ޥtޏ,4\94+$dI+JxTx8kU"Z2zRl䃓Ҵ۟TTgNryF\ Z1c9NsKC6C|ZIsVb AZ&A9[KuD)A=9dLڝ׃O1ADUn' H>KcI<9x9ϥH1hb"qR=;ԋ@,RE SԏjA#X zҏzj$ jtvnr*b1zfXܙJsz桞Ć$gWaO)%ֺ,BNk9(҄C9>cﾹTe:fkՙ\1>85ǷGl@|ďc\*:HgkFzvIB}EU7>@Oo `猼go5M|uF(FS uUgh,9JԳ`(hySt'.s]N 9 Q8R_TJ|✭szb|\owƬ~N+e_ֲ jQ7 s_З:EK j*9|4-zPV'sr&PjKxc͝K]55<$+ZxL9cWM;Vg־ qsaqxh֯+3WW[LlWxƩ{sŽ?V'>[FNֹ-ȾXϣ.?Zs^:-~tq)?;~GU|B-UWyᏍmDL1ַ=:@|FkbRݟC&o"V>} ףnr}/ g5.])G@i4Ktw_WG9 [=7eK 8GR؃ӵ}>+?,Hh@+֤#͎V`mM42ttVSYGC ţ俎>M,XQڼ+?!u@/"Ҿ .q[NV=$1ץyߊ%׵x\}6/m6ɞZL0xzk#ЫSmKwry&yLx~Hm t^E 'Z3* $[F3VŻW$iZ4Uyn>t=O> )xTﬖR j;~;3Rlx&Bw#1RIk#s,D5mW!9+(6y)={U GsE+ýR>` sZF)ScRx=Dv7W 7ѮX=tV70֗)Яv{ 98֨ܖfZj OHe!zcubMSh6ұ#VڨF J8a*5 }'؆BӷҚ ׭( Ϯhla'|t {TpO>i=YsX-}HLRGÎ}(1O_z0j*9p~>lAv$gWq.@Q&n %gV);cN>*,ک\;~4eyN~cQ>j)[k-! ?]m ϷV`玝Ҳ#pjR<6#^85lIV%8+kGI 3Fn1V ˞r ⡷9RO#֭[s͢d9՘N~Tm(}דڜ"d~VO'i=:U&; 7aqd)5:*K=RuJXg!U=zTď#Ҙ:I=FE7PTR'jXTB'oW:;| ?Wf$~U vӥl}3z>ğZ8ޢ^NkXKFqӽPt^q#\Fa+3&gē!'8ɩOOzֻ1cL^^Cs<TH?(ňI򦿩;ѻqi9!9x>$40~jA&AQ[DVd0#%+߽QlASE']{]Fűj_^*ݩҲrsJޫĤjRV:aeynnx61azb(gΈi8nю*ޜE#yic>HsQKEF`ֵRRdq$VgU?9=*V^9US/_sYHW5:$d zb4Dg3M;sH=+74poiP3BE 1դ`U?xue_)QIGR1}ǜMs׊?CT'm 1m f߲*YE8`}އֿXHmI˿xNOT/|ZOvOzSQ-λZO8Oe!r+4Ƕ]j_jA@=@)i>pyU]#̓ 6nӎq 5PJQ+IЛBhzwZ#f;z)+~ZȸN{2{~t{7E@0JMBK INIsݝthp>,9pZvk|Il>>U]s^vk@ZaǥuPy`xuZ "piS=Me)#)}b[4zN[wn?* xNbJU+WcpSgjN;m`{]v[ >+r )*W:zT"V?WF`8;O1+8-gkxXrzx$!/;W;qb`lk)XW,Ob3ymW#(mO0Py],0R3.Rܟ)x|>/Q1hy+koa6+ۼ#(0~) .ۏ~>n2ʳl%XR:ۿ==Msҵ W |RAS[l6_C̚;\o\ş6eVFy O.PziڦVtdw9*c34̯WMb[{9CyG]>i%;W3Ԛm֪]|.q ~'S8K֌X>>KU A"Xx8Z7~ɸyW3>B>|Jһ [~nV0lZ;@fOlag d*<;yh^-G|1 ]χ<`I]޾_CNT2[9]Gp˹мJm!ѨA zKo[qYF9nֻi QЯ/-;F=s4lua'EĬ u;P.^~6e7JJ04"*3 QҨS?it:|ZOq{toF$Oj_M +WIIaBweBܾ*AX >#zM@b+rU> c#+?V;Z2D_Qӫ8Jvp>ѼF wU|gŸ⹼Dgdc^p5 ^8s~ #U -WK_P^C,n w^|Ƣs Qn!+(担H%lVe#sɌj8Rr>7-F׈|Fգ#~3]/Q5&Re$|iSjPcӂt㹗;n79 s!H ӃtncXىk>SŻ:aF/XGCXt>Ɣ1 Z'hc"?=Ncʑ[0Ws1Ixڄ,^VjHlWR*z=Dg9ҡiH'QM&bɺ9A9{;S 'Πw^L7`;TB|y<1RK,4疤ʎ}jxq#Obܑ,'T9zTlNje^uKsTX.VwGZpל cN=+&ZԬ׈:~sڧ֢hq**Wv}Lt$5i^8)x97zS0=8\f98#4bmV@=AUzت}qQH,qaPZw)hWfp@ϽYhȦȣ;[SL1^OaNߏjI1XkZTQEdq\`O\`Uęn \ݍ~sSy/=jr ҧGJj Y?l԰I {UUw#~GA\.jL8cֶtݎ?g!Μ3:B>^gگyʳ[p9<{W$R,( ֞j Ac=kjŭǨ$繩@x< l)jo=l+,zԷP0z݈} ev5cJڹ٫ TmdpjqJ6zݰj>͓or={Uc>1sQ'_ƥR#^N)z)! 7^rM41I#XX3wpsҕ2#1DU zdO6x#Z8EyEVHz_$`V#Ln;#$gNNX U# +G֥pAZnc}+O$֑rqBlve=e'P>z2F01Qs^L9namU.툏uo8>wlyۃn+ 9sީI ݎMoMgA'#'h>Cf.-2ej3)Dɚ2 T0n`9Vma Q+1žMLӈ48Otp|})p|R3mxđG9M_V g,1֛h[W-k>'vщz--Md#xZ<:>o۵rfZyUkeJ G@Sqސ'Jޮ&g9Aj|`D2zVѺc2HU2Hlք"7sǭRmnCV)Kܜg֫L;9;UY8#ӭkbNSVAYw@}k RZ2{͞@ ?Z*H'ҳz놧-I\w$cҩ\8PqެL\N1ڪK$Mt#LtVu=ZјUzja.d☱@2('9u$P=(nm܊8G&`gJn@ƑWfz{Rz!ǡIFxlD>\ 48R9ңpUZZ64N3sڜ7NwGQJ扢3_z'0ybSRE>;Q^$>20P*RþjO"Z˼F,68|j.}?~`drG)àJck >ᨷMjzU_4u]w5خ$˦j 8+]4oX3Q| t>WF czH_=+ȴM:с?Bh^x*8tgxļw)6Rֻ_02xk𵝕*й^׷*D9x敔׮#Q+/%qi]ht~jAk,XR*q1H, }+MPx=k$8.t~䱄RhS%?275RsJFF3RZK>a^7 ^ǻa*{wm."ZR? ²FGsEC厜WW}U[q.Lu VvQ6 19ueݎy4X7`:MS 䓟ŽQ.PK?9w>#vzQ4J=T3I3LIvyUCzV]LO~u #J[';4Nz)MǶZI.G/R¿OϚa򊪎X7gk `q9=z⌗t("R0Z(:ǒr)JTW9 _>2rj)bܿ^9<;V2{E p9U\_DRq֬mozM'Ei7Cp8C=)7t9]7 nAn"JITKtsD6ՋqIؑ׵I`{!1Y#y;j̛b2ǜ{T͸ި sSے@#_JfŔ9=Z.09+S\֥a:)3p~kB vyaq?Z׳>hj~,0r;zjc\Uh|qdW qsQ@~\9\RnG:8c,qzsRP-U@W8*mY]B*sHhz/㞵m[ֳv j2.V2GNLY21S\JC8J"2 q\Vmm۽l\FFx&a ]11z͹u<+6>~awmHȚvtƇ]jhVqWab1\xP]`|ğ\V6iU#"Vc2ÐJ2FTɖ\[PϸZFE3sBJB;x ˒s]VT 9Z08KÜzU"/s:O|}C:kJBcr3OtCC)4ٍz r;dkfgvz/#9;#h:U'$չyޫȤ}ktgBv1s 1WgwLTq1v1Mc=O>%g&gqP{\㚕NR-KAǓҚ˹}jDqC/Qkf,`j)!>ÊG$.?K(ȿ7TO9sǸҮ+X=HӖp8l.JZf2du<(Ge['h7SHT~ VAXpWM5+^d'oP+jRMrw3#Һtmz莸=hi7X0s1\A{sA neeě90~SV0 cB|=ۚ>O?QLLWSe4٢;;WNQd$sD|` <㸮!|2یzWG࿉i9*[ݑJzejP\՛ثH\^W1$#ךv+g>RZ968_Xp=+|kg״x|i*@ï<Ypu39mҽG`%ךi[q^+mI=zִ{~nBB#+B:p˖j\[K7a+™.TB3uZ_%dN׳ϡpv&NZ<=)򯨯i@ 8x)lGFXb~\=2?QTZ&2 `jWşgV=+B'y6R40|oGy$׃|YWi+ms]$ J^񥾮|ol+_t Tp^󿎼clG_mts]tTve\Ƴtg^|)N%Yc>ue3[0=dNաDNFqϭzF%=? \?&nQT.淵]pyީA%9gxt>|~(ȹiq޺9sqpjj,(0 :(.ngC9$5}GS8C$+էQ{ǫ/DA(韥Vdr/w@9S[V1/`ME:4k+4xy&yƧr}W5&E=ke5ojH4DvWǽs_xESSv3, [MWR/[Dq2+>_ 5 28mlT}t|@oַ41EdxkLg`HkLxh*|E{mgoSQۭ#GQWoN{$!zVO.Cb2zt"khNֹ=3(!]5D\|Oi[WhkkG]:uHRr r-n*wNkSuwu=8 =+ ⛡X|ֿ2*Q~I#I'3v2ui'?֫<:Wೊv?m'bn0͌n׊c?2OO5^K#&.9T^vyr V<*ow3Q;lp`G+3XiR}}lZɖ=÷sҡĤODsI:=4LcPjJ fD{U-֝,cõ;{ &*-*nA98'm]`dq5 N2uɬi89HswS͹"LFs;v*̃?T@8=J"ȪpOaZ n|1}jd7ZsN sַ 7# p}*zRFkЦHʹwrg^DdcҶnap?"]] ք#ګK"dϥW<7ֺb Yǖ9Uy$bd9&h8+:<41=jY:xjDTL:A qNr>n875q .R*i8[~z|K3zջkI+= ;J|NU;wz- ;ǽh[~Z#=BiR6Ri ԉ/FjeߞjI-AtB ³pA^W rH_ƭzCRsUa0XlZj6OvJ? nk|$һ15*B;pTA5, r+&m2C1+ܭhpYݞs+V&ˢ̹wK=j+ɵSk5nI(naR͵#[z7kw]ZD$ {$A?w+|kfS>)j֧Wc_g!0<תO|vȄƿZtLЖ4~p OS+8TGJDvhҺ(KlWTӡMY#`{Xm-m;bKXOzfՁ`Oju+ uA-M&3zט{WNy`9'=51r'#֦6޵ōpv>'Q-efK°bԲÚ/3\d?0 r~oc18:žSܿOH;\Rm}OZ̆$P*ܳch^cᨚ% pkU!'c4RcqfwZ kYUخcQOb貘%?jWKݾc'Jnqzer9=SR2>Oxcks+3$RXNEɲAֻ ;A#g8km_&![Ȇp٬9*=OSTcu6۷pk񟊅LYּKEz=Bjך=)>IjeXP 1#=6.OJsos׵eZx+0\A*ϭcUFĕu9n!+g/5_Ljř_飙-Y+MOCβǏ4|fq0= HXVus4fķşIxWB}|~+|F8<`WCĘ?^Z'D1 sܿ2Kvw<4/xi|D&]OZlbyާ1N$k>#y(Y5ccUFmPqXZ?QmSۭexjʾVt3߄&Qw=,V ӧ{+kT.7vv6X19>T`zK=Oji oOjS5d%V"dғI=KOX{gCE'*'>zHO#Fcdz{4RJcFXs*|¢h{*9F\8"8'ˌTRwryUIV*1 _SI ; `3[BV! ,@ܾj6fId#<댈hSv driJ{S; U{ y;f,5,Q*0rϩ25l-\֯[C?6?Jo3:&^rC=GW O{WFhV 6}j<O׊ cp+n쵡vn I=*-O?J`rтSjzˉzhsJ&fcۭL {* 0~3YY6Da,sc?ʫ9M/b=u,z=znpsZ+mM{xuj9X95jcϧdAtwgڥZqV#ۚ̊m>0ykfrǃ|VlW~V T2ԸT QwYqu<Ӟ=xf.,8*1uSY7(c4/|q-2Ksx% 榎K}˭0% J'~(,yV'SNyKA$<\iz֩\Z*ߝT$ Cob #.zvNLwZꄬ+\,E qk֜NB65Nv&0*q;sUylͼ: jjg֮>nNGU%S''=k2ԩ8ESNO5YRsm{n2xfi!p^45=zT֭"yYh^V1W{8TK#VЊ%˨\gڡu9fyĻ{֩D3K`3ޡIqǒǜ}jI$֭# 1$$+mU+O*A,iި\2IU  rIڶF2W3#jz.9RoZ608?Zc֠i} to׊c~=ȧ,ۛB Jŧr󻟭6E-2H ƥtsߌOr3K' E&0IcO/wzVѹY!S> b^9fՙۂz evc XCcμ9Ow"/^ (`θh׻n zd޾~Ykc. , ! 3ڻr,x߼2,*Odz7qO@𪈆x(dkQ'i!Q.0I)62W .)ڲKrJ^4>\ԏXψFH"kFzvtzԩFoZ?{UmgYcXm+f8xR=]]n:s\3|#:2fzkai:SkcZJiȡ6^$q|XvUY: l'뚇V[g+k'jv=*=qbp3t]CUu򔏓&G*A9ⱼ_ceC 7ޝ>ֺ]ou8# q%MSF[=+oe3N3֯ U!< }3(HAսWcjQdy<;~,5_QAҵ_ᶋqE9\t9FHg$nx0s3Ƹ3Xigs<iwsOz9BA43\jp3ۚzFsP+cpGJ~Hp=k7I7g9)Ѷ:P瓓"AIJ#~'qڥE'^%@}y#cFI8[zuK3DtҦ.wfCtXՁv}k64 U9;xS^߅f. sڛUpTCOG-e<2KGN܍ޮ(W%3P9'9f9TrM kt=P[*6={SON*8[bȀUp"Ruˀwk`u끸OC֭6F8⺕S^z9ǧZ.GU+胱E VLp;=,+-{S<0j&W+NjぁT+w qHW?ΤٞZhL`RغY}xɧo-pi0;qC>3g-OjA&;9[JZ1l3;5ee>`?:;V4| Pg֩pN 1sҴDi T2T8'%inNsҺ#'"Ye$c֫a7gQL)$Cd pެP\) ֋B_s>u5qVzpkX&DQe|gE=)vUnJиek>銪n2~42ֆL g8ϥr B g^*64EpOsңy3[@(OnآIw󪳑}p*G'֫\6v}wj`L@'U.q]Q|yn&MϽ=|',TxcG7l+Ҍk\<7d;5hKhPJt܀@{PKC-I\cp3=k&T{נ+'T\1$1V'Hcycҝ4V៎=1rUνWMTk %Kc>gsZm3Ws)LO8LH< 'Ƽdy*UT2 sϭckwq[vrw[+zM*/A)۔e6Ĺ#}CƐ\~񞙢H{? v!w_Sf^ >YW[k6`;)5_o#"s\WnA+|:Wb+[Qc^sXּf2tujHtpxIH'5-95~:H3fAgtq)Ym#kSҡۮ{TFq "wҩ:Oj()~c찙8"(lÚuyP!'/y,I*KDړYw(Vmψ 09&5}l1\c!޸fP՝όdꤾ5ך^v~{+1>jy RZyZ6GbZ,<-Guzt^BȬ* ^Ե pq(q<*VE[܎VoEҹ_]2FC6s޼HI㱙MWǯҍ(4j^Ns޺o x {ϕX,SQX?hR%+91T_-pn ¹+SrkHVd~4NrMb]'5JM! z-o~TkK2kmתM}&U]Ӟce4s^yVH<';՜~[]EĞL_gnO22kҼDַ!lzMF{[幏+,o 5U15)WI)fTG>2vb3Jկ-!泭'޽N}w]:iʌ$(=Z=5ҏ;igOU$y%UQkُW)υy8T˶3G OOa@wX7_>tohk[K;{ah~Crew];/K|s֖_SUeNIooU>96_ 96)C:>R uZkmuTPԱOEŸ#ګnsO񿂮+"_Fr9ץlmqf;5}wQ޽켏{YCrH`k5bQzb6;G |d}Ϻg8ӞA漙@%R?xR@Ho֫R<}3Qr71vJ&V*;mH~"6rޘćZPcԙp d*_ye_=)g9)#N# qk)B;''zOL^Tdgt,+7k nM ?Z":q6Vƹ*'rHp:C c:8aCS o5-54@"ӚFCzS9؞M mlIi|t6]8X[;u2G׌w)is8@=ѕR =*E[<:S#c>$ @juMO Ұ`ءݞ:ELҬ|dJ gұ+qG#^H-RkvЫwg{/Qob;T8&8''7Rg>՟!Y}n2GII.߽֬B߇F%bj)d8i((N̊ 9vaIY6Af;S5l 9|{Y*p*xy`龃HMiISayR,=MgfhDۘg9U=y4&W/rǛpH0g&1JQB,ÚY@j \H'֣2j6FaOCTK}nqJϸUQ'TR˓CFc}'1K$GqP5Cr9>J [VWݻ\Q6)j9>h \GIʛ. 8Upqժyc$fpGJd*zU<)X`נ`fɨ֫66{$~URR(0gKww+=Iu.e֨w5V[I>?s]o:T3 Yp)tiw^ hIef+i t8mi:(=Ku;Ih8Bpw4IogKq f M%#'B1tO-`$gkN>a^ 6.I~YOxV'n0D>_nԱ+(]Uh8c[KfXs{T0QUì$,x) N+@"r}wI'p|Oj5ʰ𼑠8:bGd{]֍)8޸_۟< z06Lkz}Am`j 3P3|OhBHEpS S^t1^4N_A`C]gx?Z5f_?!I]_|F[YhNd:fVSX՝wZk j丞9ӽa= ⛵Dz9'Sdۜ©Xx[՟9Y-gy.y_X”5lj# Q Z\].g5֏eT7]ǁoS=pxXhϨúXzWZvwvK{sלx8=l *DI<ڼAR5/MfCHoKZQpw^+8 0H$!Gk<==̝wZJ ֕,qxL}9>S ÇhS8kT*E:KU|yg@czW2[HUo45'BHP+ u 9;3:)4[$^#W}͔\ԞԚPx~zW嘕IgJ3I-Y_?^~;O?ȭ_m Ɵ&x]n h0^r`OZl^}&>k2͔[;]:+#WInx_Eāoʭ*AjnǙ{\.ZV z,{yK޶s46qzҫ{mnz4^i&]4-h^xxb6s_|6~AVFҔ,ZSdN=kkƶet9K;w\E["j涋oǙtv~@)sȣ+wOhoݝϾȨ1LێGj6O՝y${Hq#qW1ߘcf9AҖ[#o*o R^65{yQJkLGG"-Z<gޙ}1T7$q]ʗz1ûݾHGs^fݮ@>k;0{W梺jq:d5y[=5*Os࡬i$O t׌{l,b´!qsS.QEn paiJ>Z|QR]Α{5 2T쌈M yNw;c׵~#4 sGl5N)N2qTmǀ1ұ ,M$`E秧Jn'$tⲔr%ӷJ>n$eD~cKENӈ8P=GOdڰ q%\cOΦF{Cd}L s=/[$UR-6}']pԈ'P@GNv?wSFOz+"؊pi3KEo3amzm9J뚞(s.AV ֜-zya*C@Slg%-J-=q ӄX5WWKRnT}N#>(qy HH"3RG =)̼qǥB8NI=3R$XOAN"GL~'E(=~:z+Rd$udLDgx[ҕd ֪&ܕ9=1 'OΘ$矯=_w`Z6$䚞7]OSݨCFڬ$~ZlQk^SSRG+'2YQr)=*oT~Ӑ%ܜ֬$ۈYIuV!yGRLY2w8𾿇JK MJ޳q.Arw@~ Q\_֝Lک6mX+xW2E;IPysjv]Cwe74qsT<̌v-JDįˀ3ڠy{c ~h/g^~nLjZ^sQ;z{T9\qJu^Zau3qj!%z+\#rMÑdMAZ$4gjܴ]ךq |VuItϥt&c5tUd)dMG XY,MTM^MNx5Vc$'A*槜֫I >(-gx=rs1Gkmme<,Aq"'RMzc^r9=j\VW"NK95ZFNpy2@ӌ]II'q=6?=F:H֥DiPc$3Yr jߎ3Ӛ6lr3iѮy9=RCjw۞kÕj`cv ?RN}j&_JoUx&C&9ɬ a^FIH ׫Vm9j.͛<-'7slnxUTv+}k˼{QWI+|KH{<ĺ^Vx9gg^(:0"^juk5> 5bOrdWsE)7;=!897^C[1hk5 Cs3(HZr-o+$ڻC^_e~Qi q+,)cN;<5T,yG_wd ^]g͢nWF5Ϗˣ;:6u^tlkg,#׋w#=*kEfzאxW g( k~G~*J#ˣ_tA|܆ ~ckB쨔5  N^+xkVC.'YS-ws i-_Gh Rap*ԶqҾS>GG/~]ҩ\lLd=5_ 1\ޥk MmO:_)g}(\mCNAֱP?C،$;3ҕ7fZmdN%j̊bFI<=9Ͻq.$hk/;'*xKKAH;w;xv8{HڙoզuPޕWMx 'ҸɼxӁk<_[˜ﭳrj-3 #g+pI\pw$󗅾>}枫<{W3n`c彈 E}%l ZX~{i't<;NҌvk44{Uӡp9Ne 3J^u$ԙ/*i<#cx`"GJvN5Md(x/ry?Zը_Z+&:7 kOݑ>ھ8[Wːm z?{VB+Xu$QGE#?>stgÞ/$4bUFrj" m8F4HҚf&s"r8ZW~%ܘ3^xUYr@ުBRBaWSإ5)吢'; n^z"x9g/z% W=y{X5:NDթ x?c3*-{I"9+׮|&--0T| ig88⾾X:T^'cJ݋9\/n=nx7y. ;QүxKjrw|>>uZG[5||ڂ_J>7Ge2s_7??a˟CnL%u¢ϩ_ 5 HUԚ⯞&_1dg:-l<c (2G.}IOėAEseynDT~k>$Y%wU<+\~yJUg=_,-_VΪs[I9?xTd7Qy$RDDRtSQ<gu|MI_b45/j0%\t}k|c}-j^1`z]^ .݈15JA"RAq]LXYESվXUQ7-P/_f~Tcֺh_ Bkk9s<Huhdg?~bx{>#<W?~<[{x湏w @~E{ya7{>3\WG+!㾷Y]H2+f-R1Q5|kg[_v>+SV]7)Sr=Etn# j8MNg󫓺Mz|CɌ}mn|!?mwIc8&]\w+E'5ztC׃e1S$k=fSja'9k|E;qjh̓ڳo$M÷>'OR\nO52Md7o]H&@s88ݚ 7 U8=1f@Xo|.(:sTRpҥ\@XІR@9~8yI'8]ӭsMXKqjO&G?qz)~lrM٩lrÜh@{i~qy&#oqUCR4~x=GrU(dW-s3T_R 9V?>^jtsTF#":#=L㩡IX#;zSV7tHRA##5)X5*-qiـpqLVH֣?V-=j9#Ֆ TFћ?H,ў-xL8zVZ`֚*2Q&H[|*3_/W|') ӟʯ3;LeOz%=O_QN ,#bFk:&y9V,25j$SdžB,D$ˁCSX=xUR"N:Յf>U9blG!z*a#%ty=iҭIpA0rD3PxK8T@e::!&JmAo֚h.GA[F:q}*sȫ2|*FfJ #֠H$9fo\g㯵"I{Uc&'";) +6wA5f;45ZYyl{MzԆ߅Cn$h,Nx#'YȬ\~cևHmqj;UOTڛM`҅+gڳx{֦䑊_?s׵J%F(ϩncM1 e9Ng~i]ݍiuIޑnYQsyR)Omv6-G9ZVޱ.01ǽ^N2ztEqzѳr5 N=}@4֘xnrgބƈdwӍX~xPξgho-ګȿj"go UYy֫슲FHy:*d>حcܛnWYwɂIZֳoҶ92/ <#qWzȺ 3ln0RIsAϭRIy<Nz s J[R!Z-Le.eS_ s!%知!r9'0I9#5IǼQczP_ {[}i[ ֚}EV29sғڎ冸q4 xֱ<O= 5ubIASϭ}ne 4On!%"3dIgP =U𭱆NӒ=+ξhozױ# &;Jh:m1Wf&$ \' ڼMJm>կB9+󥍔>vMIn$ q_HWmTZ ,}CN8iBxVhNǥ||AxgºO^ZIΞ0_6NFk\8VXXLVa $<5M*#E,yzyes#[# zWg%8ATsg%[[D2Uuqº}Uy/V|z8jL&3UV>o)U#k+Rh֛p䊒N ]Qdԡ"=}?:XhΚ?axXΚh6sz5iNe ~U̳]xs p:ٯYqK]FNzJieM Ff 'ֺ]gHbN\,n6+Y|KmeI鰋qCQ5 4d{ּIfpzNoek挖̾`uCH[T_nZyGҗGC k6oOנ )\ۈۓKkj7.njE'Kie6d3ҼQ•ۚxKk&_O$f_YR6{Q{1k첐H}v3ָoNytbTOz.x{/>Oֹbݰqҍ tٶo5GY V97I9exkOz:?~4{ݢ{n<93Y^.EX.-r<d Tu:)qhQ(;Ap*|psWgmp˪ʊRه5Hݩ&I=O{đB$x t?G 5ZCG|OiGNJ^bg/zCd: zEbDg8\ƭ:K č2>*Baww'1ROZjcm.IQԏAY7x+]1Gұno%RahU.zil|n9( 2/O=ZQqWnʑB?\|s\>@$YA@x옊W&$4Vl,h!]ܮ}+Ϊ߽#M\.S?+,`ڨx]cEaci:W7E.9:TKJ{{]Wݟ\t$Q~wNI8<2hS̎$ps_?PkY)gN~c_IkLvDz(<Xu̺_ُ&N2r>b}+g暾}۝8E} Ѿ x+[`1scV-`xFLm#WbĴDY ;rnko.-q䌎֛dtÞOȋIu@͑+i+fd0G=*_x˿Hٌkka٠KlH|1R.c]sV=W<1'ۆ+^;7m ~X^A[qkC$amscK.tˉ!h3+WV̰>ʶ}|]\̴Yџڝ2Z8p8S÷ m(^RpA jxj Iui叩wt,l|y6K^f=Uꜷ_xxl5u|0*T3U\e~҉9 bKԫ! c=kL-H]-/wϭg#H\ҍLSdG> A?ʰL ǭYRGβ :~}j3QhCW4b-V~D7zWՄzS fr9'Y06q;UIv'*(´,ɬ_$cZдr=Ϩ+wŽ~jB#j<TFxVU}j*Vmw'k~enIRB1:sR k' l+rY=0NMP#JVD 7?άE/=՗6yi #B 0\sS9R0{Vnu±v#Jr^y]MF;sSW<ڀ<*k~^@eQG9Kg=N}w^'Rk\a }X95=⫝̸}kβTGe2ĦF$y#i:c(#NZLmZ&LR_iobO,´v<:j:ösK7S.ҪiF^ ;2qھ/R~W^;Ϳ ٶi`ZךS&-"Rp+񮳲S85cU}~cT"g:Ժy~ ߼w'WZ+z繯H1ffR5MiRw5Ϯ~:i'$j `շҲ>V 608va⦏|ሡ=O7E %( =ߓK2(5/nh{`u8#Q{j+Gg9JE+,ZVA"c5D8CF֖YX"5~$r8%jnUK Mq_I: hT25 ?#a_kϓA8m ~ $?jyb82l]ց5s8NKʹ=&T" EH,ʹfWHYUl(R VprIq*ZhFwˎMlXs_( !޶4U{ytTiӼS Œ4Wf>v(_k |d$30Y{gB]OW#2 ҏ 4i +&:p89*yq%nbI<(!vUcV=gx71c'u=fImD0/uYUf'}O~[k*TzRmJkYʭYڥݬBϭbxX5QGX=č4iwKC ʩ< k߾mF4$AV,s{WQ wF<,&AQzLimqtm bvR: ŵzEt+޸'wx߮y#M-lu$M39R8ry&U#nf3 uw~\12]c'46ח~*=JLYY}0;rѡ.a%Z@Cm-89YOv9vϕ| :H+a{9N䗜JƛEl(,y?z&szbL2p@c=+1gJnEf,.W L[u%sx``{zN2zJx9޹ކ3<ޯ>H5%zW5H3jMÞõ^"-jѤqj5 gZ WDk6H$֕88%'hY|coۑ PV}y:UוV-3j]x9jsS:z55tQ V^Y`rzu)qsᨚ)= jIzO3

ՓZ;Rl<'z{Tnj<֐zȸzT,;t`pqQ1J_*xcc C`~t.)Ҫe/JdONu#U,83ޘg#֡2dsHπ=Z$'Kdf3~7a$0M1Y0#۽MSTƃpvNOskbKEɮ^㚃%;H&惒xTD򗡛A! >sV?g*v #R y7̶ gW A?JQe$_*dzU(8= H$ҹz+\c,=zUDW ڲk7bț >p3_ c8#^ eO>(DcUdpˌS^m5=@ ], ׵C1;OoZoi6F?NդQdsK*̺ WT]ONkx+MrTb=p֪a9x[ެH0jtos)2o$PJ9#sRMtꬍI18HA#9>==jTd}W;qZܖƴ<9=i6'88k\]E$ WIj 2߯ /J.St%y18`ƶOB$79v%H\+Ӕǵ~䊱Kec 9b1U.n}}ҕs%S̱Nn6+XIaj5M_kt/ߕVx\cg<ׅKڭNK_b1l)XGذ<5#j F+1Q|weQ4g,[V,1Gž  r3{Vz+2t14v10RMu61nyJ҂++Hvi&Mza:jlOQXz#ojD}*tzcs)]afv-鯦Ũþ?*_H-4i,D%F??)Ʋt諳ۯ6*Q[{e]esj('| ;̜㓎_ b-1(G4Bάڽþx ,G'ij Q-K4d,npGW֚}桫yy\~di[G\'AW3I=H7Cg5VtM%#$#Vuq2rjG2Lq&8VSX OI)߂0j E+CjHk77mwׂ;xG eܴz}6<;q|A Z RekoNx@ cnO~k|!RhIxѐ+Bv5?uk>([3-wg=}d{pJ&:ݓJ^iSHᏏn5 [Ami Ӆfjoo.5  9gƖ~$Yx5y چ yѪH?}oi$ uhmA<>uV"jWtE|;zAc-L-cr1|?ysM ct~'lj!._. v0q9\fe-ěa[G$N{_ϧt#Ϳ`]LV۠#7̤uF]վ#>T#r">hZ+N7ClP|½sTum]D\.{V0N=?v<]j;+YRw +B1VI cRr6uBzן~ɴ^79`<>W[[Y^N//x2T`zzV1M%eԩJ6<"E,xGOYK}CX[f10c~:7"iFQUzu]kwQQ?hXݸVTWߧaVs5H.ks%H Xp9#U4N'I~ZiwC[y/N-~T-C:f{std \3ryթNY~߃+Ri&wg72ע\ #\a@Fb9k[6֡ u ϯ=Y.\[FRK$i9b@zLߡx䕏K3ĺ`rfXZv'@~H,ג"n1^zƢ|Go}y,&{`:] w0Ih3&@CD7 ~=(eYg9qN[N+9ni|§q2nҊ<}+Ze#E$-ᐌئ9>f rW'hַ\b'd6G\vUyG#"6+Y9`YvZԵ⸦F2m=~n)A#e>3M]n=8\W)3Nyyvrr{un>~8\noy*FLt凹[g z~UXOsk^#Wo6 9*D:P[`ҥYH7\*r|asV`+jcu^3p?@$t^kTѢDnNNzy=}&g$ _Dev'g0մ;l5JNޗ1G0}qWN8YyPU4"$^UJr%c2) )HqL}w#H;{2ivT/?8i$Jgn? 7-8M8=[c9;R~'23ςn,Zכu}5s>1ܖS޻_ @,W[SGe@+ɴ>՟OaOLq^OR}vVʻ>U%=Y*/|Q3%#gf OοJvV`+99M𕦉 1[cᱸ V9Wg yNBѫm\VPmqǶ6jaS^/vD)RO+¨pH>=2}?-i2B湋)v9]qQ>z NuEh*YAJ/?Rl/c^}8nʪís x[W 5Z?ZsԼu: UVƽ@?XpWlwz.#>:Nz39;K]1pzQ][zVUX³5!C, yOsiMGsZj20y\uq Zde'oֹjsay3xb?ftkQ/>hT3>ٯ@!_?x#;\!nGoJ?2?fn}+%Zx,L ~n{s]vF~󇆾$+ɒc^`U[KZ7L}Ud^~=j-[XX-#?ZTnb3\|!n:g5g*!ȯڪk>,f-ֺ/ OKrf5e9?kψ[St11Ύ^qgz֢xVI(z ~k9ޥ|+Vkqѣ!alN[]ۡ+Qy[:sw&XƼnzqң2_g/kOt#j7>Ҧ=񊽎+R\׊ w^Gӥs' }N>xAPXFcRޤIemO.c\"~u+J\_e]'y=ܷ*y5|u 9Zƃ^G@@Nw¿|GM|ybn'Q.ͭy9 4ֵI{!@BY] x\Oձu0o'c)c<|Z7ܿh{me$[P1IJ٬uT'>X=Eg<l`n`zլϬamO[4-,=+[z_ݤ~ -Hc|W`73ɯ<71k&rNZxj $@W)~[c|Cbg!Or;i,̶tĿ_S$'޼S徔H'?Zy&b@H_'RmDINJԾϺ@5kuբfAb\{]{oeU$(A-`M|?q9ެʙ%LTJr5MD4B@5rc{YSC^⻔XKA'yvRNqKC_av~ImM)tۡk{ia\*k㷻o-d[\c4ws\ U`=Ž??k y^l-%|.GJ SM7<#aN$|W]/PH=MFdfPvP9k&OݟeEt0s?a(ne~Ă̲;93{¿E?oRZCmbXwKvO\bp8r_w^{`y$IHd{zoյ/D|70+G?+? ObRGuPic);BU77KD%|xJ55)gryli=M)繸mVH Pg*džm?+ȏ;\8yq!Xg>ItxpxÍkmyDl "1M{ύ/?\k~WFIYmèߏn]i)&Mgncmm)ۖc=E|Bab  xR%>%K&xX]#v-Wұ솫 /ӿKDOmoE`mވIVUD%P=tL.TwTIwI2]y:V޺ɵ;X6;=j5itUBt8j_tQ1Dڧ}k|SaNIωtS!r8~b|G}+ךLjI.,WmOA$3l.|=ͤ\# J0^_g/Gk~ьӖr.Zey*Oq+gr4{TpI ˎ ϥO93\SF-IpCJ0[<3Ts3a(CR9yjw#Zɂ瓒s^b;}AY͘g'j7z@lwE I.9d-4 q>eBѦӗ52"+ռ%ᨬPWSnA\ʼ.aԂX~bGhml,j>D:WFm#ھ,mrS_ -WT=$}x[:tpMjKs9t ZZ4_-9q21|SѰ#R*ƥ8dڌ=+W-[-oޞNSj/رȉ ^xxx>ŷ3:rjK;eGˮ [ WWxuf 7_^e ٤ykR_qʩWVO|m’%W)$=+r]Eu ^WܺSs rF85Wxw_'nsS~US E]i$Ii(uxf)"qtG c#}*}˃b78n}^\r嚳3W,I0 zbᛌgָ1xFy&u,{Ӆ7&4BsWn<;zN}+Q[f:++S^Z5nOFzU) yiNpŏV{7vaLi=qD9cynO;OJ ^y{~4tDט,qj/LWbD;rGj/幤@sP'i1ϥlS/A8N7޳!h} 5M H#Ҙ-Jd@Sx҃&{9ϭ)D,q){\{sSG!?f]'!F q}j}kqO`\Y^G$.NFϽ]~9Hox cyyf~5"HA;,q2KR#spj~9'=ֱ-IU=qǾ*hzg=0zrAray֛ccILM/<9_ՉjVьUfv#֥yďP͖l[& 8qUsSȻX⫸ n֩ j74&G<~8?J+\TR sd>d3zkM$ fIa)xy?hnߴR79OAq(HL ٥T89\: \7WԼ?@8c& .2j%Jё{ѫKf8L7JKNɎGls,RNm,tc35:kS3E795śi&e xQp%g/`1g^<葔1)+-W%+1<_ oe'l/]߼i2xJsvUX~?VOI#O'g_@ojwCs+?p-}6mAb>'dxE#֬GJa{W-?k %n|._/X^Zm"X;6bJ.QGRݚm5WasƜWW^Ga}ij'PvXƓ!NG^=>[Zʺ.m5QBѝ+4mICefl 'gҠU!R}+BdK2+WZt>"xWFC7Q{oï7ؑ!RpuzmSP?r^7 ۥ#/)t=.q5NR{p \72?ַ|g޾)GUTl~<=lK`Up=kڮs\Ɗw?akJF j Pu30Npqx77Tɯֻ '.e ?5Y$/_?ʢ|+-x灚^-t-S1K\9+Ꮑ<Ft4[iorO'>U!?C mf}aNZoo_=Njuu_-Zcp!j9l$ S qToAYn.__4iNrL_/ekm.j{}D *9Ti#ZܒpǏ£abHtElo Qwӡe]Z&"jmXA}ӊk h`mbnk []圂7m9]P6aS!hxIJO,=%5Y'adm>HAn^k2<s\naP"Kf̈P,;x5h姃PH X~udG0Tqz+sG> Pxg*b^:ҾTG dSXfuW۟쯬54`sI~7N$Z ;s=} )PFU4?'K$;.u6 >;dS$x;S PŻ3=l\EɌ9~ uk=I)m>gRyķ!8%qBd#}k2_|Lf/r/s|PCZ9Gt'k~xN%'u*1GR5-*ΜO>wRA(O^kW߃zl"ќn@GM"b*BoC]4ȜއUex_%8y%Dvڼctyfy5wL^,}VE/ _C(i(”uxS|'e1$۲JG9}i~$x}U9 ra蟳^D5u1eW0ӤK_#LfCVu\lWsIۜӭ$s\{W'U𗍴[[bjv r`gWީntK{TkY'$Ak,Ft,g+8_YcOY8=UY%H3]X*/{4hYk\U<3Qn $snx":V?1Su\W1nWjs=dyz8lG>:j w9dCq(G5s%mmw 'z ~Isޭu Z5$czз\յɭ/5(su.0x99گZ5n 9s5Lm뚷A\7=7]sNYҗ텏rOQֳ-2 1=1[ெ{b*80513%Q\"o TԊa/z{Kj8`s^@Ӡs bF,.qQ_V>GaxrjϨ-{=}6ҽ+zw'=J6c-r:OVӤH'ov8k*p-׃reUoklpWfxƿ`=cgl?벽ו $_sECT\퇎6Č]f4ח*mWdƽ:tL d UEsl1"K`=+GV28_1U'k~6rrZy>>u΃WrwHrOPPOOJ5$X=kŢ$G*RR)4vڟNjK0:yFQ$t;U#-yҶT%c׆@GoМIӡZ44/|Y0^AYĎ&2W<.&><^zբY>SWdp?J3XfY8>cZWL1\;)A|}d@]>n~j&yd=Wmx'/VXAjmp2îu +{vPˎCR=BLG.AnB ^;.8PxzXz~I&Dٶ78\⸋y\RE"M1DQ2隼G]n}3VXsW},*9 1+~Mu&OI줺ipsτ:KUʐq^#*X[c-nQUtb-URKͽ-ϽC/#.]5h$ķT YMzU#S%a6h$O۷|ώLR0r+qb6cow*r`osNZ ێ{U܄yVEVc  Hю)A ?͑}VN r\$7HKtǟZ՛ްE^ߏ5; sMs#6 WY~R [򩙳C! I'U- b!'OJsm<n1Z\/$W35iq=&L|sI"g RI9vqִЭ,azϽSHzUo[ҫ'}OUdk!TNz*zq΀:TbVv)U\硧MyDIً+Ϲ/N}ie`Vy dduP;1ed$Z|ޅdQ9쏔P.:KqֵI rf/Ly7}A Toj8xMMcқ$2Xl ~cϰoT>A*$J~þDcsOLO^)ub$jrGL"JqUG2>xT|AھZX f8'R\qUS:T<ᘕH늤 ?2u-.Ojw*ik4mU8 Gfq};W%s28-=k~& g Wv73IE]IҋZ‘}}ɥFex Ⓔ?ILΤ'b>yCs:k `U1GٹxO dʼj½qBqW|@ՄAԐ1_m3\j OhWm5X0 =Fz0.oՇr~?-?uBj6-n׺J3fTR珞G\#}lC]gr7~=[ ᏘO5'4\հp;k.YS|]a DeQd8\Fkvی. A[5 +qk6X#m`-_F|(đF['4DGxC_ \TWx߇hoͧ e|U`^~к,ݪqRRtyYf#UK 7~ο~,j1 o/`=3^CM]Ět,pނs~)xK&2U5oQCϵxgx :=ݭd:'M[s7i'];qj-w*bŦ#pA>9|%]:CL&Xҿ4׏2~J5u誺eNjnn.!xv?{ԓ[^$AґmR4-8=WOu'iL@팓GZA'Nb 5Tygb~hv$gxFz˨B<,!yR}sYڗl&8-3ruUN𯃞7x;~iTO |Ic*n=IAiSVukS営{w¿#XOZn+4Vɾ5<ףɎ < :'ЮVO->d^F~\Mq~ i שIuǣuk{D ܸS'^x$W,gMRRͱ89~ǰMKGT[֎JXǓ}}}`QVt}gW6Zdll<؁Cqkb,59}Xy7Ps!r+S7o Ok}jѵ.2$'>p< [˚>O˳Oc)-neĵU:lծ4MZo:d 2m>rt,z;O삷:`2;QWAg\0-sB\m^)<>^OOC[{ml}@!\HNN;upgˊcRJھ53ܽekw>`¯_%֕..BCWп-)`x'Pv׭dCԵ&)xİ?0'R>Ѵ,,?z??טiA:nYw'8^'pts ?$'==kei6󵌱U SQ:_NX—V KK{0ypq` 5O51]ZYu Umf9 ͹|A=/#}rgR$;6i ] +.s:Vt,e n˿p:a(*w:/sI, lt獀Pmcr8-k:MթҼ/q$G(4c8v\Zy!#'q=? ľ#vf W<ŏ&NN+0ƭK{8߮gM_^Kh)N&,z~IH=>9|>l;}J{ۂeSFWQ |HW/< ׯ,?g>ԭw7z=e;!.29h< ^1˰PnU-z_Eҥ&TnvLӭMj&hY+.mb8{2iR n:׊fj:uΉMgC-ճwR;ScӇ+/=2mcvZlu$ƭӷҲ!;q=}jsY8&Td͛[[ǥh[l }sj`8PԤowN*wd? 1nbś]p9$ R]V`RY;W9iyH[' W~]vOS30[ Qi[&TmcҬc,`E `~Kx\W-~4WZ4ǕJұ֌RTeS%G5* >Up/WwdwNAC!byak *vM.g ɻ4s߆۰QJ g%#'9^yD !PwU6L9xNpS~"A(3Qkgž*0B%1< Pa_ڽnfĻzW zuxedg$:rϊQdo2 /1.Gs猘+'vxq :%L]vK,NMsV`MC+9޽z&x⸣6ari&<̂{Oo_.^k>85[ӭvp+Z9S1+\.Ev}M'%`C[*?y׭|X1 Òǁ5W؞xy(J:K|cK&)^OTΖͽ:ęt jP:$}$ԄOJ_xnkxD#~AT\z׫jqe&HLB]O7ç5NixzO0C46~H1jk;+{%Β@|B/ 7>W?NTuGϳPg=*Mo@܋^<aTsڿt]7i+3Zi]k$?ZStH<@|7_ˊSЌzV#"MRy*LxOփ9<nj^}hY޿J<5OP.SIY`$ҙ9W"Zhk99Qiwi4hIpX<.nC$w= 5.jw}qO7gNՊ'0ܰ}c( [Hۊz@!z2xif١ďj޳}I隞\D9X׵ `xV`?ZqڤsƹeO\*A8?ֱ9jW<`5 u:Մn""r8*x#s\Br4`zOnS+=n0>lzSхluz H e~j3q=zO>sښBl{K LqQyTNI;7sG$oQkv5O>yI??/ޫA9Q2;d?Q3dJcHG,B1DW`6S>nG>t HU9A99?5 WDH*OUuҮ188rJ"l<sq$T $Ui c1])\$s@b>@>ޓ᱀jDr59'9Iq{l{qQqi͑Z| wif!L0iܖgPyJ( N:Էq6HQw#O`޸B?v3Q1jP6)X\YcϧP5FqTg=+Άm}Rw<+2Nu#~n+l,RylO@dH,0+> [ݣ#ߚUpF}S8fq@:R6@8& >Y) G;U/i3-<~YxUI[D"j]V;SRwԽC){8I|ibX jEVpsNi\nb}m)w-v}1YwMʇjuJ[[*Q\~!?ҷGM7_T5ZR5)'$QEʬz$tq%ee Y}or]2x}yᴱ^ם_#ףymc ^TsI~,ueKF5^`GF=Fyn?NJ_.HlQ@ UWiZf<3hƬfoXǩd0hk3[k(wzg/~c| ]ѰIc$ӗtyw5<(^$p> ?>23kVH3W NG|)+Iڹbb3n皿kUx"oV"Ϥs6L!xE 85qvA9=>!x\ޢsc$_hډ^sLu)~Lv;ߓ]S^G9xmgܾ銫궭MEsSI$c<~cZJt ʯ''Wb&~_c](v5HV'#kGՏWx·!bG7ѡ~>24Oq*Rg Q9+}Sԗ t>s½O$A7~W~z;6"Ԯd>[ ھ}f?ukBeKQwpB} 8pjF֎;7Ot*[:xcCVy~iW¸˿j7{啳+t٣ΫT es.Lَ< qК !1m$?uYPC^_Ss{Or4۲Kz_M}7QPGj#]|IxmwCO yn3q_rX!,|i>~AzhWRNYF#{fvtxot[ψVF dq/(ު[𮏩#xUԵix)kt k6bL6<h<=yC2j6U eAߚ冇l~Xh{Fo,—O$p2^E|4Ѵ .f̫: z _]_xe4ᕠ0|xl#>n˨BFGWpf9c~}}2;1T7S[z3 ~~&xv 6 _V?xs=N_iл|eyl唨m6ٹ(]1/w42n/qU'db_eeϼ6>[1o6~ ѭq_2 b8hVʞz'o{Ht)gew}7#*N=+6HTM3 Fp rrs^'$:1$EI%v)?#5 +ԙz)*Jc ,`2p|a{1|׈A}u2ZX9%P}x/oK_gG4BgGozσpؙ)ᢠۡm's뿅ộk ժrY3z2+emv\9rֽBj5ލ[¨vXd?i0\Vp_G׉O/ٷ̃r9r2і嘬?c%xO/9[~eww^կ[>\V-$okzDd/FC۸55^:6wz>m*#/JH}ᯈ%3=ӝ5<&%}zxZ_ܗ-Xz<x@|3sM] MHvI,OY1îcvCgxI&E-WK#|A{ׅi~<|uC[]^Q"m#\װauHm4o:o-'cS_)Un_Q|GhUiJsR|ѷF>:HKUPIQo~k\5P3 ᆟ}>;6T)=}i={N{"cC_S>^a4#=*ƪV܌&0OqotmT c_kQ;r=E4wK}Axep9QYJ7w^/ټIym}# nEhi*;BQS}j&7q#kՆz^Yu_¤f=:EEh)AJ|TJ )oj>óMdX|AnB>d8${Z2H3]}NGs\ក-t^Rd^YaxaӭءG m?}Fww$H>OxkXF͒Q pץ)UoD*_S'ZKgʽStdžd{s֓T1FN5z?淠9}!d>X18Iִ+2̆ux32}uj4 oKgFU2- dj'))e|+|ŋ2WIrnw<}=5Gp-N:OI#ĩ"pG>)1oZt}wj)'In-W k?T*tsXq ?b$8=NEc1~3#it?n\\0׋_ͩ>a#g=*ƵlVpgfaIʒ^.!krۇJjH?S~,6 㧭r> mbzWes̢xJTVP#rNx=[QXC)_\bwѩ}ALב]=K( 9TҸq2RW(5v~|K5;kV('Rz"_񈹑5ˉs+7<k2Iie8j\!{f Ϋs4X6$2xaX2LxhKZYx=.|m6>nHž66Vж]Q+|?xa!r "^_=+0&^Msa#R] (+K1ɫ:#)ȮR잇\n=kY]*=;r2W 5F |w>K%ӡt >vnW joοK1?=8* 3\u_x&+|!w^?7Q *3j%v9vH;qMݞp9X>;m+uˁɬoTܶ@טٟ崝,lQ9BESpkKdr}k>"xzό 5Sr0ץesȡ_ NAf~OZݷUEW ^;oDz'|D"֍?;rӺkC?Zjy|_}߄'K4s< g+`׽q>[OՃھ#?6a:QͳL&*?;&s `j6:c\}yntciy6_cuWJ+ <&uOTcrZ.Q^##''pj"z~y'ҝ8=(E &J}?Hبq J&x#^ J%ĞSJ[hyоH~'I|OZRpRQ/il$x#@ 9ּO U;B)6UZn[:W7^G.( |kl/!A|0ǯZ$ ~ƸZf)rzXB7-gXwQN$=oĦ֬7rJj$:/=* gxO Tz+K @>iPzdZ$1_fXäKJS٩ tfo>0I OFt5*rHoԴhYRh?\hv㯱4;={O-q^uOmum{Jrhںҽ>)V\j6躣uNk~xF,my#-sCk,+Ӈ$ٴiJ=?~K5J>{yrSqſ4u5^/}N 9'*h㱝cT$*(s5!) u쪶0yl):[jjF߈lӋ3L}+4/؟ᅯR#d囇'ݞHnwLGǖۅ>0XW)*i_\M4Sҿc ZF|HZ-mGFrЀzW:\E'Rټ $3nL.^J5)F˲-#c!:kMXB=f kv ޶,;(Qw;׳kdN7uMR]&!Ќ0+j\)EF|/V ό|]S-$ּ53o8|w_SQoݦ+@© WZKo|LV.ۻ̶0;vGAٺVשRtSmoO;?@\#KTkvv]~G- BkR#E5ګMv4&'յ67P $%?QiƫiIok}-#pg`Il+o蛝4pUFOOz.O:iAgY5Y$D`q:⢢mY4}_e!X q+|+1CtNǭyt4ţٖb:/*{&Qmsg:fu1*[]I޺fq9k -Ē {)V9;++ԣ&Yn4v&a+@#oԌW&i4Le9,$ k~rp9ןuy'vj 'ÈTvaJl֋_VDx3Q%_d5sQ]=%d&+h}+'o3#?nSxֶZ]-i Nw ms%s*1_3קihPɴ7\+þ|vTβ$p~ڕŪ[\T>DVSli> _0+Y=OOcO\iL Z`cu5ɭh%Zu>yL >E7t䰙.,t6ȟ+7sL{o^4\p=(j%{8~/]AN8/Vcv_ևCWѾxbmQ<)x X3(?9nk/\?e^26}2KLx=xJZQգм rn4F,q;(cw5_-hgWrk7[t~-^`~+6v4_^wSn$=]s\cR- իX@bF8_oVπO]zԗuQ'} ?0ֆrOL_|=T ic|砯~xa4[HDἦU+)ZMeSSkC~ #[(zyP ^+׼/ )]ҵ#~0kuQRh9D9Sq<__yEҾk1]FaWQXSka㇍B*zQǑ?ґ#8\cf9T~kQ[c!Ӑt"m˜tɴ=<%a׵'WMNSZ-K4Xj9 ၷL[^r+ϭ4BiADМź8}rsEp/lj[&{Yvj(ʕX'|:|;⻨B2k -c}HLgּNkl j?xu񜷱SxbswI8ϭCzlsEҝo.zקZ[_ *K9}kٳFf >,⪪Q{d> DӠ!E ;WhzF>D*^Oz}3ֿTM(Y3)JL!J-*Ϸi85#^ٝUp~GTiZ|k{hpI^Ճ@]x:7,|&?gRzWLRz_Vwet]l|pxP`~VbG gW25xz-;M#9|)ՌPv?r!>Z^#3x~zDžl "G@|h1]~M}5 Ks:4qRLXވ~5ZLPcҼÞ)bqǽw7ul w|?**|Eko:\>[81qM]¿^h6Mu3.hZ: ?7k-jV]Ž2t; vMN'|#ԭn xZXlaks~䋞dg?sin ]O:dh"vO WAq8ZY8U>YKK68?5"+?>:ӄܕ2\[xTLoB8 6FZs2ViT֐܎#lpxs"0 R\`z֚nqzJ )]d~{}+). veKw0rj7@Q汣qVb=9yf7#x;XO5b+g<,p6VQ#YܜJ<sfzn^-Nᚷt=1\ӂD9< ڳ Yu ~NR[/A߽`P*\n=/J/rϞ*'V=ysޟ%ʽˏqOjiTq۞LnIZF2h `;'U|ӎqJgO$2qؓQG-Q{gZ;{SP%Rԗ/j T2ϑ<~UG59'x̄JsLǭmܖI&O~ZLLbO\j3z{V ȉ&PjYy4Íz$Cm:⑘Ӥqޢ'iکv$yM`yOp^H\vc:s4`+ny<Z?֤rQGNMZ:W'z J'm*F障#U9ٲBO5ɴ9"cl_ҕg&֖aNugW)CSω PIMpH K#aXhN5 ΤFckUFNm#V$j lX h +jC :mvzwC?i0OM;t-1mO%n~UU.<`[-ez^"CI\8Sloiɢ|n`AZ,3A{DSև%g'ktA=+ʾGp+4W=q_flI;%bQBۮ8y(2IVhu$sL:{ jĖ*GzNjł?gтEzO Shqv|Zx'%v{nuA8g[\geּ$b*RzBceG198}EH+0x&oXxN2kޫTooJ\Br?J|VVġ;:_+Hs֤uBa H\#O=Ծ&&C:>H2+Eêm1H0x>ῆ17xѦ1Nܜ{uc-F+}%Lrԟa^ XGL%`q'}S<%tԕ5SVM4G|K6>i*:Bf?/J4[[TI %Q\Q>آdh V oA?C[҃C}_Vx5i96)uoxB75 V."I$g#_:ЍZ˲rHi붽o\K%$P8+˴??D\YD?xי]rm[F 碛jS%qkN1$x]G.߅rH^XfR@9{W/AZYTVO$O9*?x^[U#c,:=*._UVUcCN׳s Hc"V/PkP' .Cn.Nq^cϊ5髳 cO)F0m >3D-ڕ* cQ]4y؜ g%z~ 5T֣ Fca,jI<\w5iQSwz]N:nK]qQ WѥQX|@UGqþ>7e.ѻm_GIۣn)QkSQd7w=? %KT*;`a:+83!XN[ >=rK6>xI |0GMj8GTɶ$]\k>E naBIzZ7%&WF² 8 w$񦭋9gY"f?u^׬iZhmt@-ðqЊoIE J|e0F$os^S2^4k<%S G$D =8u?\Xl|gx{s]uJG{ۼNp";צz׌>5\[3 o_B+Ռ7+X1c.쮭XmIaӞ dO+>ǡ>u눒dV"*G?*|u)-yJ׌2`@v%\kYƛ]5Qܑ.a aI3u#Z_=Se/s0agڹs*j̖R ,|Uzq -'Ԯe7PU=\ŝr x4r#d ׭R)rԩk-W,F ]izo>(pjm n=kةGaFߪ>yJ-_~im-rУ.K 0 yk9@ߊ-ƍ:: -t>W~K{M_pZE.4?铓y8+_KierD j>AL2Ě_Ρp#֢ӾբZE;q ]?|GAE9 $gR֨yUP^1z.]QYrҝkm+|[ `Y~g!A}j׆%;ҽ ."W>955+]:B\]c%R7OW?V,ǜ]Ǯ8]S/9)Nh}'ixaZVWA%>w)[3\W N6=u{g yf'QzuI H;J>VZD!- sk(:eSGsV~EM"+6=QH"PZͼk:}X'9jln6xi],$MId蹮n#a_x|UCǿ$?ub YSGCC?qn99mj J|ʟduJq%MlfRF}*ޏ\)K9^Eg{9 e>zc*9Zu lzToS/p1lTp^ʯ S[}q}kVx‘:7uh!M}CYfK2E}SB{OP>] {8yGvPv^7b8P?ͩ(ݳ<#w }&#JB3䏜V?:׽~Ѿ _W>Άsj+eA3_>xz`'d nc^f*\)o{G8J(ߡ m9uS[i ~ATk[P"`=} ;41aJL t)AXφm&5Q\mf#?re#G$ek`1u Itlzֿe٩$j2nDdM>{{נx/Syvk4{FE5x^ARnmϕgJU-jC"jBsd9V/C)|- #+3mEk"&P~2ח^i9Q AqO0w@ɰ;`pFGJ,qT7$iGODf$\S ۇ@}6rqεHܗx'|sMD2y4&ޜzUGB &Lw>j)m! G'1|c OZ-Aj,cPQL6~3=E5s~ϛ #4 ޣpr9U3 *&^:L'Ɔ^''K+e'w_ju A<5QsinyVpzu5ɵhI#?NXꎬ1E=Z|(5R;H=8Qϱ= sF6 ݪX:68 yYNHrqwFͪOc:#ҰmoJpjwy\֭'R:Hm|2jQa I@~_}T&!NVI{Gy p|,M}Mf}1Z:$zyjv9\I C"}>x$NO^+3~ /2!#׳xëd12ͩj7:NjMCV^O FBZN[7Q ?n85<3:]7cCܙ<ױi2'=+>2GAkes+ݩb]*/ΞUlzo^u@xHO>7yM5a0wg~} -ms^ ̍_ j\ڌy+]UQj^$yӞ>A7=nq۞DDyI|EF1֪k0KMypmBIq\^T$Zm!i Ϡ9,nin?7zN2%bckɼ 'H3%w5,|,rng8_GŚa5\Owo#!u4N= ,]:-I~>KmbxT-s6B}q]mViޗ>/>) 8{[x])aㅥ )Y$0E[:jxj~E]ኟhlb k+G?0=p+%顮c&0y\Z0E}ż8^qz6W.t}JW`[Jz2P|<|Õ;k=+?47{(컃`xώdzViGj+=|̊Q<xܟb𝵫ăOBԟoP־"Ghl<47 ( |#{R7wp%*I=,M;k݈5O˫r|`xV;(˙7aGLWAƘ'<ݾxOE(.(n,޲:0N-e ѣv閿lcp$Uo-/ 'V8 KA<{WϿ u׭mn>Ctp{x׼kq'o至TcHqN[X^,ljF8-uFmBKr00}kwZjZuţ,l)}G_3|t\ Kp8ktw$ gd>>>yE—X+u|!;FCKz\Vl6<"C)c竀8QJR UJW#`Hp8ڵ4mZc$jlN3+ 2hz4nUY8<cil% 夥+xO9 |ӿ{Ƈ%7;PcyIqTu7kHs=?Z9_il%PZ-q)2r3Q%l^9CZ٤ 48+}My6H`U &Gl*yϦG[4 kl ƭ\!wF^Q4aJr*_?7~'&'rU~?|≚+%l|q{~h'?w=v{ib1_|4] 7o*XqA YGv?~<aBHg_8ShGjmNzNGCRll5*rz,UIUR6̱j1#n9ږڎ?t{Vm|M%ɇQVX&^"~!M̿Fv2j* 吤K=ߴt4ٙݜ Jui*G/'*=ś+W775u_.u6_#糺JQ_ЃZi\[3_|hÖp!{$j|x>rCo?zOGQHB7|t]^z#KfmÞprZmW쏮x|M,jl^3z|UMrd+j/ś3L.Um'Gs8{ mxv;{iɄgWsԂ[%p"NGٖV -_9Y@c/Iɤk 8\]v]**Ep9*zo=cmH;=Muӯi5~tjg vGeSG0ҼP }GG񷇤j&", |!Ar:sr,,cI>"|["b@=)t`tPYZF&xn,5<-s˰JU7_0vzzIs# sX$s|lVM"N}I2J*穖Q/=CŸe& :תx;y#/MpI=I8zSn8ѭ);Ξh x@ kz+ɼ;£`9 |5¯F~gC4t]6]"pԚw:eйs۟z*ATZ<4ctk,+p+\M *vgڼ ^ |_2K,sV?Z_QO0<[ahM:{՞UZ' `RFsYZZNV|fp r08%8Wt|mzupu9dx4^7o-3z7c':_~Fgޱ.͌G GH;2gUU&c#|JGUƵFBndy3Ұ %j3UӅ@2j9<j"@0@Ir*2\~+qrRў>orW] ],WXHnSzW/ 5״M,Gk1֏Sn2|׶?d,'Ү(I@n#!p]Eh[d`{WMdeP88z{2̱u&/Nx {/1Xİ"`X78h M/ \%H=74!y?Ps|wtil8qʕtSڼ=a63\ą+qj}.:мiSLRUiw[vөO,:OGҭ@}1U4A'?h.֜]GBw'C#.~c;GYCzVk>7iYj6,ֶ?9' FR>n=+y>^*Ν@AGj1kc`PPo`d5i"֚>v imOs?i]ڿ=#hA*]ā~CƯIgp~}[xKfooMb)V T|=i~#MULkfsǨOslj4NW-p0sک$1^78#jZ"OOYIb:,1KjZ54"#Y>qzM PiKF*7'<ǽf+SFrǯ\NV5\䞤V\mJסXʞll%G֧K+!g*qpvzv]0NwcZ/7H>8,wl jTFݍqvǯ;":OO'$gQ셢4)~If~=iM-ֳ%۟֟N{zt>y ِ-yA>0I>UOyihz⚇BZu)}1PI&GM'k?_jmxN:B'=1QpAbA "[v~Ks aI dzdk7'!#_҇ }*` SH݌r=ګl7]Zk)0GN:.cB3Sv0yNu ~)s>ԛv (HZk t;li<4idqO94pxP\ ^h 4{vOJ #g,}O(_n9*p$M>2րzR WHv+?.ӎ:7U>BTH[@.zU XxRUgu5 ֚E˴z Mu4rGBz9&w<&{[ pqKqXKK-mkOܘV=J st5gRW;_#+o~" j@} 㿋4nJcbTae:rLgi# ldtIm$$U|5C=I0U.zF^.eaWz#8(~xK:zm,.F$a& Fr1r K]mtI$[&- 9b~VNXViкb-!<#ߞr,\j4m&GYL`Wvs**Ny^>"mG훀oe2?J;QpK(5Ds4XjIRXؙM6n躶5—+3/nN+⿈MDN?¼ LH$ W?O]J]+FUuǘs_Mfo1sw>WqXLSz٤}2f|= 汉^c?_B"KyɍgSDҺWGA~Q3ҵ4`@]I?S_T̒ㄯS z*k,FnX0g p:?Ζ3p=x9A,3Sz '+a8 T_,?w޿\ԯ/ Z[VA$8u'o |5xWtOXK# 0͎I'ٗi O"obYrk|o)]VQC5Č˓N+^k&<^%Z|^>\rMhпoΆuu \$qcw5OkFj(O(Z> .~=7j R^_1$[، Zprm4)8"!"1=+ܾKiobymqGswml\*$ǯ+>2xn {ViIGxb7R}kU'kz9MJ=e_4iF%nY,,ȼٓ9br]Zp$)lzW|-P@8i@t`i\Et!,.9aݤ~ ĘWFծ% FKZ#g`Â:uZz9'ڹ|Q*>:0  ݟ(އxi:v@9@ߴ쟥uK/y&=;TY[Ș!;`^PÑlWYsXYAxUYKvbpX*{o6UIiL@,8O0~lp 'v~Ӎtk+}>8W:ٮ^~i/xnՆo-ފE8*q:Rk>Tyq_UC| mh-n-lT ($$’z=+X{reXPl3x6J2W}IxXAvO0M'G۽;砭/:si2Q,~xҬm}6< cNxp]ׂ5ȼ/ )sx@{ 8G[%CC̹֦e4.}?jfQI8.r6'7GPS ǯ$lF tZZkȸˆaOuzzDmSBB#޾3( hxrɰaK'E5-1[?*9(?Ck<){{fi/[\c,03K2,NZk%՜I\1_>&A"oF|=r8tأـA{kh=9rlg7؎X?ulx/>-EǵyD՛ j"-$Wk )yDg{sҽ|>9-'I#u rk.ҟ =AV|1! u¼c=ԥ^=zDWQ)@9à^+skbm^9)DOKm99Y>x _KWԆ㿵mM81GZ}q~ c@\]jzקG"|=;חJQI S% w ls5?>-_:k=rDkdSg]lXZJv> n`OWٺZ :_"a8zS ?a١.BukZbaCzYlw}߲^𽡖 J@wb9f=kO>27FuET9Q-h +9"jqq_{PH&RQ좿J&E]X,_SH^wNj},3Y`kIDnWGZ7E"6$a;gZzZYƫ]M*(~S45 .6Wmt8ڭ9F3o[? 鲼F <>|$x}wU!S_7zogNCH}Y! Vr$y Sŵ$Zhc*tu=_KW@Ojd v9הxb֪Xl}>]V=LЕ]N:Ӄ^x 9GK9ֽaF*>ͦj"8c+)WA"@ ֖srGCGRw{ՕՆ;@8ǥrZfe63ǼŸyq޹NDSeE0<7etr(sU'Ֆ6Or*>H'UT Һ'P޼=kʭeeM.~UKZPh{ML|3*#@=(q?^[rȟzzeӯ=fHN R$cO)[_YzMYcyu'sqF sޙ`u-J^Ғrz*vsփ㊴D%=wd$Hi)ܛM8)9OsH sn({/=;9<+5SJzzpq8=I=isOJp'ޭ;znQq=Jfy1(jDB=m=;8sK\⑓*O#iZ/Ω0Q+󦘷1XxvZ"cK^?w+ׯCXkփ1$OJrzu2c]Y[8#'* yW8ݞ};֍pI$=k zREiA?Z"h=rV 8L lgkl,X'B8ݑk ysj>5#9=n^$g5< 9n{[>b=N5R$@cEXyT 99>;ji,sr)s85/L\Q#ir.%3Gz#.1R$?KaM7r1K#=jddc?5<3 NJI 5@?WTm>\=*\^sּ~'`dL:wxoCט7*LvzKଡ଼h :˸ݜQz|4BL˃gxjC6^{^Aһ L:t5aR>nM-E Es!nOZP,9;@z^@ҿBeZY%3]5[㎕xn99S`;TCɳ[ZB W#)T'Yu88fgqՅJAEMQA5#bqZbUFRWskp?I5 V$%nH*_yC _3>+\T#\R |go6zxE60(׍5D i!+k9k aVN[QՃ?+pcW+r׾!i]+YcOQ@$~nZ嬓i;ȳVYϖ? j&Kđգ"Kd?** g dxɭ7^9 i(_C῅ބ*G.`ϏُagkM6{lF2[@*γYOB%m{VW "Ff`;z+׸! B6Zd[*UU|W~fS?n=[I_Tp,?"^K\/'3 ?ciH$  +,E(bU7."'?'- wJ%ĸ#F{_a6V6L5}WJTd6u m3.H߁»#VWhHVg%I:AdH 7=8ЪV}Te4zuf|>~_x$Qiudv9^?­p mþ}ߊͩZ.vnL_E* ϡN HFÀ12႟riowS0N8Uuxzf;Tզ,DWd|² _=Ȕ 0 GWӯWNr$[\)6;Zb;SUUA(\ڌVWc{4bpZ E j4ŗo.lpvnoz|'k]⸸T[k`/}׽ gXm>j 4}I9$X.V(bn3~ Ks*ݍ5*1t#?c-[dO9:}kxJpDc=JǗ2Gy,O~W!'űi~fV2zzW`p!~?s.*¦5-f5ߋo{hbzzե DzmV4-! օƸ Y@+9bҼ>](E5`廁$) p ΆukXo-bY'tce*I.N+4G|1stn?=OztCI%ך}iiKdWfٮN5_}QY*Nɨ4n{n/VgcXs//iz[Gk˄,Ta8μ)#v0$u@|D>)Pħm7;<灜Y|ϴ<>:i|W99[SV?(m<;OZiz"7s-8g9?rteky#'ܚ k2$HJ0ZHS*|؄Gֿ;"jzYv{/)W7Ŵ: Cx}V_q穯De>Rr=ϭEk2_\.9ljeGjs7|SZ%SЎ%[.[ȌqZѷ[ "۹8Z]1Gs{ökЖyzNuS%{#_uFLsO|^kD0“i5'bLg54]گUkU%8qgKZ&`53RgV|fU6>^,_+w}q_Axa!i@ 3>_f0`uɭ-oW_ 7ڍ^Ggsj sW?~R^Kf:̰XYF~޷%m G|)އ#@][ƱH6=\QxTM6V"Byd$yůEYpb& @\MySaeZ,oּ]%8r1?9'ܐkN&2&~K ,=>V#$U8늿i|5kKkp~ƼZJ> \kEge61Hǩ NuߌsŨhv2b}NrO{?g_غ4]Hыi#?+ 7-t>EU+8_c<3R/WHw>G?)e<˿/oR߁g?x#H;v$3HAvde64RvS[ +H6@(}x!xgrjSky ?CUZtUʸVj_v.kH[k{H^ |-T7z?u_"}+mu n⽋>!_.<99_&qx9rtNFJIFzc8DZ5mu^iU tHG +Bk'MK}@75mwpr>.R+g-_ g*J#s#V">C R#SSLj9nmrOH^UZOߏf}8d.I/<V]v?3!&@:{Wx\<9-idfN x IΙ&#fY!"z~%pS(^[> f Cƚe̋!l!e᠖f8ªG  ХImi >>0 Q82y1jUOUQzC|[eKT56egli7#D61:WXj"N1_UP\xa >Q_-m^:ׯ~(4%̀*Z96n 9ki9ζ|HWSQ"4);|i"v&Z|_ " 2Z&]K 3/ P`5V$[#'n|C634%дpN21\ &d౏9+ݒU?~l,P(֒_1C9 [|\s_$i~83!o>;R'LZ\m,bƙbFEy|akk1ֿE]TZ3xy-xzǵuV8^:^ym3Zz$~kЄycTlvWs9ܳRXTw7J.c̓Ya}GjxwNVl:iZOL$PymYm%\ǹ+?B78߭Y*B߻ E* (5{E'fjh#\jtL\@J`xC9?K܀>v} ھ Y2?xoޝW4qwG?Y^ѣ-cMm6gSb1"C9Ug:W]۵rk,G' ,4X}g~^I sYN@;=*d}O)u.E y0 dr?*@SS>Pܐ@=xS֚<˽Z) v$` ¤a=hV돭X1UM'jYaf~P-Rd.{*޲h1AR+Qhcǽ)Ќʄeê_l$I;\7%t]G'ϥW'.6GpJ*2z!2qjݵZNIV=9UH"66|2s*dqX9V(;z)KB1Zu>S[]YHǭ>;#OO$ V ~jx</ss$TEDň~]ղCG#VR2>6R,GqrEG-'&$JϺ Rc-VL ջ{NMaG7_E]JI 4}ÃךRB3=OZΕ77dm JgI1fVC9'/g1Ft&=>ƾUGcW<u=ͪJ]K;\`v5ÕfKw䏾> !aVS:j"Kku!X/?UO.زlwR%܇@}B&|Ѵ=E~cԴ0 )[}/LR5*2O5$ЗɊ$ `V=rzmkE#s+ƒ/*}fsj\ 9 g}+-(X xǜ_}tr )׵{ mJct>PN# jz|KyiIm5"ۣ0o0t71-T.WϐX:j3-|k!|-! qwoܰ;IQsϵyn4uDR"u 0s,qOpZ'Gr%=kҿf E_M$KȭЅ~Wi׆UT{B:Nj8،It^Ovdx]5%3|_ؘVc-~G־!-q"(Ҧv]>̒Hak~$|~uG,”}Jr"ok\;x& W]z@nd__%x/dżd-<:!u|ks}Qee73㩬_m>7hZԉ 9_ƼN5=xQFmJke~ŨGOAڼbt뇍yI ǿҺ՚q(]OJWBJH!Sk,> \YYAù|j/-~YO?JU,x$qwIyIw+9x3Jҍ&>Εu BF!+g8 rj%GqcRX~\xP֋[huu)U¾^?O~q&sN8P^;jc2p3)"o%f$:Y@*}G&+W&SFnQwJ$ϧ|~"šB%K*0'2_»rhTE˩c3zt)ޱzʟQ]=4`2q h 'a4 Jy YR?v=FƟ{#u2Fo],=exЦ⤮UnžldcUQ{o?^#K~"牯ͮo?M>!lWpI ʫhB?.(ҡ|yS+v.G> /hWv׃P9Փ `yZpPUV"+xP]Jܶqz_zkBлyp uqafݕlǘ\4 DQ q{u>Ivw_`c0UV9ie:4#k*sЁZ㗉Lu}/>\t \ײXPԢ`m+~/ ZfЁM=zbIGID~947|@e~I?ҿoO`@b6;eW9W,<@i=c 5,n!{]ҝ$<=OE uo޽7^nي0;brA9g|'<"O]jelwYYª9cwxNxf};ǠB6R> F&M')?6ٻ⯆/Hxʜ"){kψ]| h ŔrCTAt+j&q' E6^{=7)gqq1ُgVѴwzb>qgKF2+p6 tz׮Ci@ oA9d`=}y!:Eی˜glfuB5Fr0\KS18.3SE!dB=W;ϩȭZ!';O?}&xid+M)a}[YzCEZ|ö_>&mrb@Q޾zԼA}O%ţc"u"{A2 |כ~_Ƶ _Pe$oG+~ڟAr;1<5 {fm7W)8_:|?4ʏ3^kᖲ_dccU{+F":޵2@da<זs苛 Z~?L?R~YRSViDAA2~j7XJqkovNqܚƦeG ٶ19kRk#kj<~&uq#{J+~u%i} 4K;gCj!X-195؏uU{)$סx/ƾg0_)#Sɩz?7}CjM_wx^^Q(e_x-J7qGFu$N u`0xy|~?0E:uesWh8{l>k^-}ZrnjϟWxUA_4*:.i<lzΏ:e9Rz׳|+aʑk ּ[,w+JA庼sڸY//&xlƥ/v,W BT'PO [~21k#$kv5`Wa߿g> Vuݪ3F7ݷp0·nL_in3vaĚ}8%kS1u+^1|1TcZXf󣳂!u-_RDw+g]hq$/': %y\O=TLg;RU[rO@J:Meo}=Э&9#~Ymӂ{ wW*}-ӯW.OH7/mt-W^O=+:Z9g0%ZzE4o%_5.Hbrs]OŏZ|o׎r͟Z׌x&԰W7ky{惸/ ]JʅGָMoZ?ja]4Ū&3֩'$ʨ̤?ZT>ʬx1Փе3jҴ9V2ww^ %߉/S(<1־5n#49̳(27<LKλ]>}{BL+? h^jKp2#_l rQҲi˾5=T xһŴxF_{#|P5o WO$ᗻ+F3 eYzbEA?yu$ }8r+ Zr׍/M{;Z֥6 ߕGqc>Xt?Md8lʱn,_Lxfo. 1^e⏅f1_%CX#q;RQپMմ gOoѳ_=,=X|QgΛ8RG.j #"$=a$"Ig*h`TVLc'#猟SZ.8NINjKA\`[y&;ES߃sKb|&n8j4l~SR9#UHw=sO_jHw,R 6sҫ=:҇$s}+KD!<`9EA ܟ49\g52ЋCr8lsfw9S\z5:SErAQA#oZ4g'bZ&S8Jb'R9PrkLI\1>2hߕRwe))~dsTrϥ7$#L?{Ղ``x>mQ [Zϒ(FN+F¼,t%dg+iT9XbxvuQ xG8\޼lF?jҰW+3\^FzE$$sY:5]Oz#Wgi9+X&qT-J8hq5GSв2Oҹt99w96X[`2m霓^Ffre<9.oR<&1Tf$&SMk"h ?!+ +%%m򏟓֝h+7c&0 * ##'VmǕh\s^MEbбd`ίEIFnW. W k6XZW=z.BzW~5QJ;72en[H>]O8S=͛w/<*9ejdM:cm3Yђ4μnWXKIOAk~4Y;W UCmk9E3QHZzqɯjѥwՍ#qO{ ibrETIpmr-YWg>G+42c 끁cmυO;ț! \ 8+j1xOZ͒i"7e;oG8_[Øu⧰ ; 1Dby&tX!_0:;yHsy1xض{V|=Fb]XyѮxq*xjF4#MY#,0E$:/q65*1UMoHK6ᵱWS6UhbdC,y{}i~adKm3xFܺQ5gd%WPFeGpZʖfdb&ad:]rItm9d 銎 @s'~Q;)bOXrVR-5F۞w~CLyo-rJvW5 o{{>lc 9׌Zt.>rI0]inYחdWZQ9!A^`m#]TIMцV8?zw] Pۄ$=$y7nj ɌvO8쾘qPrj8k sS_~&ujK;>:]BlesJJo9g Zo,5MVGCqYU^_z?45~*XRִic 7y\h0G^j,{1M#&<t=8/^hWPt[gFgh<{ #~iNu%Ɵ)1eHx^aQʊVˡo>Kn&𗊥ՔŬ[_i'_3~%n_eT_ʾS+ӫ|g_(|DwNZ^]0!N?{◉J]bzo1u@mE veS1VVf8LWh?5f {Va"%xvmfByqe'|/,+R> ӄFjERr, yY2a9W\jM*ou!$kZUZM]v}~Mv%ʼn[ oj>^i}G\j5( X+Hm<.摼#$Vnw<ٖ <$~=? |QIB38-EMJ7Z|sQÚoS~ |)gm/rE|0 yWEŸ,:kK>1O7V){{PFzg&Owޫ'կdq~l ƚ?u [B`zz1-3Ŏ*ѐ<םUSUw}/G\ScRw_'oi=5pG_z;tU,9u%G cJk;ܻ7T?gCqK fCU`IWVq[j[[={'⿭S"))vO_Z| Kx6/0qSdmk_f𶲲ʆT El9_x#[KhNUfdc#RWZmJuk8sIt_QeS}m-BԴƼΣ (,st3m2 eJ];@qֿBumBLW~+55hKnAN pmvrb&2pk?Zi>?h5E;qu_wÛOe?-uF|3 _aZjY7L1~ǧr/ݬ,oPŴceܵK&XyƤuddY4eCRK2_bo2vxkNYgUe;oW >KFAGvY/Չկ[ v8T5*nv:A%2UWO]w&GNYW ;()hj*je?]ƍn3#"Z~\lsnMHw386 lT76Mo' ēGTCˍn+Fۨ!_/}jzn&՘|{ >s7^Nf%uCdH`=k|DFlP{Wmha+C6Bk\"v{Ga#YjNϷtO\+'sJ%x9}̒'.rYz`VD7ihQ aO*ǜg v/4?>`KSqN33<kMaZM'&=Ϣsx71«.A vz(uP}M|}ާnR# &$d}:b%,.cb#n[=~q`qjwooKxLq3W|]I@`઒*֓fK+\dxwEʋ_Y;#2"MRb9Ԍ1H.shs"C\܆nA(~Ϻg= +ߊ^|⫛Me4O+OZ8ץ=c(o(ΰ)%ٯIXkYT,r[kV #,ڼH%LHe|5Bdu#5e)s ˌ˖T&MQ0?eK'd\zWwOztw)a2+Fw "L=kZX<-;_Z3>?X٘HCֽ!ydbkΤ{̄_϶B94 ٸ6sTh0% ̄ϥu̝A\K%a8&/M1NG~k ppvp"æG=j柯dzu R ~Qֳ,uR|9',Cφ/o^zDg8¾qkar+ܼtWNK,MJg/7G5v29 mFI6?iK,6 |Oi\W&%d. q-KcW[3Čy$M1qzMp3Z-37+Pu'v|Om4~X'u^w>۟JSOؾ|/(F6: V~F$ yt>pB^+7v.ty9cW֮-tu'4ݯo'dJ>e5,KkC~|Hh1Ү qӚNF+[J(|VIDD %#T8@mgf~eu.J&EiCEvLQT09>ԂUuiF_]Ҩ78<܅Wiaa+[%ge͹WY|~)E'>:HSBENK;y8@ a𘋒}k=VD1ZQoTr TK]#NIչYˢF֙(>~qVopdX\l\JSyr8*`]W]!n"ğ1 qYNQ-TqZeW71[9qȬ|ka9QB')5>t\ q=7I`|6FAzח).W ROX5]Z=%+o_ G!+o̹rzs[Q{<s&lPb;ґ_{ȸ%kcVL}53&NGn9 9AYI6f*!6>93rsҦQ/|>z\O~MS v5"Mkh!3$HIN~*6p;R.[Ulk>hZ`ι&fYIaׁո繨aY s\a>8$ ~ɤ O4pv%"G *T\מE"džozbv6 uޟ09^+6P>Pq>q$g v4&CҞW N3S$`WBD<0㎹$㓚PҀ2#Re܏v k=)ƚ[}kDM|6I\x#9`σi)۳4'Uġ@H# g9Nx5]]?J<ؐ>8 &[;8bbPg۰XdqIqtёȯvS $-3y1<z?&PON+^zJ19:? If?@xzW x*3.E&20;.OcjhCna3ҤL}*8.x98hw7ՉGN{uY^׏؋ _?9Fv1P#nq*t9қ hhٶp.+ReFk'OVܣ<ڶaOWX7%I<8SrAMa\/p1{SỴ_΃H) } PvqJ7i+RGryۏ1{֋B0;bZ ԉ.1+)旅S:zWo.'q~!95h0ݨͪlF\;<3v>sp2x^Y|B־k)a;9M}+Vf Pd%W;OFK4m94賞sAhLV{?|2՜Swq`7z?<]ldso#}/_ e?J"8d.8)s_ FltX"k.O_.9S% wRЏҼ qj&TEKQהeyT|=O]NL`=+3)^E.9f]Q]> W1c;=qYmYzVփ=g?7ڃ?G#2 )[/ƾB~2S].apfj_y^\zI)9aw:62a]Oq]͇#n{=.āk>9dQǞ KbdVB##}fA+)Յkn?/"f㊋Ѩ_Uѧ[G_$dUd(uq^"ڧ~'t닋K!ʦ׽x7?: Zi$ {f5o\w贍-aQ@YR&?;ci=%kvxy! Gs^0N1.'# qϥUw%ǣIq*k<FOY]Cq[q >0Tu”Jｕ?Z# )xTW;5˽Zщ?eרY{`t5_Q0;1*b~W*Q{4,gќTmT+| $QֽiOWc |BHWZ;4D-k{+5U$>CT&DDxo|O?'bnPjω>ZjjV @:t?}&t57e[$ ٛڕ>ȡ\޽ 9V&;5x8{7)hgZ>Nam1G*[JJXpp7s'x^WmPGjKx7'^%˭ž`K5Cp1}YBUjIF.z1xVuRQrmZߩ_{iV8Cc2glu޹O^4ck[׵ dټE}/ |>Wrۨ"_;F+ּ-5ܪ'kIfuq}(NU՗S [w_5 Mgo'._pT\W>4M>/7@~j߆,VAxVpX3?o?EɩFQVȄ¾ap%9QQ]Y+!&[|d|{GRkYZk )cGR+ ozA-зtBWcE{&׹;5hϔs~k3NvM?YfM/ 0A 펵/|y0XzW^ V݈rxW|?i@ oiu H=Ϯ3[o*tߙ˓3%~?ψ?imI{w PWxw_4cW#\L˷qOӭu_| a1^mEȘ<qIsO?`8Ԓv1 M+"mIk͏B9|Um^S+xN,o]/cտ` S۰F0wAT+n~[H[wg++bQUy; ؟^DžVRRuD6QXסZ[10nBq+ʴ]#efתi~٢;s~Ҵ:y\r-%Ty`rNsN~KXPyml%HbCl9nuRNcOxC.Mf˧qX6L֍47h zzV7glc̗d#G供HzkTm%R[u3=)Yi >h;+ |{m$>^jN#F@<}~Uݽ̍G[9 x 0161\om?/ W pݯ7qٳMr%LJ.nEyKm*Pz+|}+#gw2zc2yGm$@YxpMG}kd7EߊWt9Ȍb^[ɪ*>}E[4`:^=BV1qBO{. i^ X#?Wv/.:B'>W4μ.TE;u[s⯉|/Dlqީ<21=M{km#@ԶYE"o^zfwLcFӗFm%rq^ˬ>Mf5:og2Lg\riu?4Y]*ee݃ȯGXm\zC/:kz/ e~+zVN&Ud{? by{mUra^Q9ƑkqWyi%~c:_`F(t> FT wEo@ZEeEITpKdih{i-M{i۰zZϱU`]>ձ ҴT z8nHǹ u+ 깝,*ǥZ-\x@JA%uh*k>aY:r@◳!aykֵPrrj+HdzVMpH~ǣGA߀'UrW3iۇ?Zfk<$VX\!]osۊG~˻?)ͥTݢDz>کj7؀pZOD5܉E-ٻsDG$ku׊턹O.OdwvPʠu燑,TcVHhGZԏ:tE'AFIюs_+qUܨgJ~j>۽|Nq?B? !TQB.+^R3g_ ƱG^sVg$ªi 6=jXUQ'?Y n[9'֞e zU_?^%x<~TrrȔjO73T9jC0HE63K=O,zU''b9zr/rl׏֧LҪ)}z'e5p^==(nGh OCB܆uu>&'<ǵkrG#-:Rm?< &>jBm'9HSFsO+yqN+JW)hFP)a^GRW+cHV2[^0ǥ_5-\|"`k:Q v;#z)㘚[g0gkibZPj[u\"n9?s򳶝[S6I4t4 HG.9fj^+1v|˔9@çιV'ך-SqT]`ppIsz7p8=} 79:ciGLWBJ*Ql5,Fj֣S2ԛv4B8%jAw3.n?Zox=kvSWRiy5B;*J$zW$AIX{S ? SR=@Sc)íZ¤vB ֹ*Nbނ#]o۽r*Ͽֻ=!G?Jέ)K#ZwxTzz/F tOA#f|B-o?-} ϗ \\=A֟ct#ެ\i{W," /tKdĖ0"w#,~]/ڭGCyD2L/zח?jrՖiK_{ot3441| C) M DIl/Ꮽzum{Z"Mer#'Є|Ҽ3) BxAs:O:Mvmr(uQ௄JQ]0nexGӼ7z\+̋csf㝭}pMv:}NiAӿ5_?k?kZt핒]x~|rO=;zZ27"V( Xg&ps&yӋ&g~A(n^[Iye8bG^+?g;^ڣynP{`JEx<%>9rG^j];7Ub ܟj$<k;қOx?OId]MŽ%!c'JuE&uO'ʚ#_WKmpRYВJڞQƱe1LbV$彫Vi֦]QYmn=V9[ᯃ-'?7A<5~4Ē_vzCXW#V<_{}ZiuHOq),3#(M>s-o&FK!a!^I[|gy6IM{'og0YZbUCD[Wk~#Aldw*"Dxj[Tدu_gS񕦒yf˃}a-̊<"⍂r2q-ĉN%.#嶷 }*tv}a划_ǥk}?J$YN3Ը2_~ \i<~`njΫIc4y洯*=A<3/ ~W'͵ERŷnPs_%ɯ-5.>Es\(nxS|3ee-f;!ҲuIVB=5Sn)$kپ|T61`dJj;7 jm~g/ Zv'Nu&|z!ĸfQux:+X̌6Ƹo͗u[%կ<(ǕF˲>,*Na>g_34(_PN/ۓ]9~p-y(NG^k$˦m"vD}Њ[xb~v\m5OO5e'N_Oiv:kkORƚЫU' z pn&Ֆ220QƱMV*kg,x=6֫m[3P'D-$%;=&zs5k&l*9ھw3hZ&g5B[ks~u~ؿU_t-.Hc0ٹf_i/_c^j0d>sO)yi5@$z9rZk坕{Z[ 8>\W⮠ESiv?[$RWEϤu?cf-?2_U\tӏ/Vg421r:\/{pVqw@|}#| dw~.%.#8W #I:oyC^O4*dǩJ֖%߹YliI>Ҿ4 ,~BN҉|hu7?iQ(W9 ?${ei~|[ɍd2&>~z1+VU|.[5}>Bo1Ù'la˱9S_}<;i~$USR0Fkqj5ּ#iҴˢ%`Oe<5~v`Xʕⴵaom#Q6~> y?ZV`CQV:W*ݚwׯxZt^ \?AukyB'I6WoSkۥ9 qZt_i𥶧=̫7ZM.>2Oب{,ڝi䏼|'A:[jpM5YxPO*1*Mß־[V'+ϔ /1<#ft7s7W,x8֊qLW^uGӶ"kyQn1W5.Y$~̱n?c( rO$Y+|=WM\$VE*[=8⾁)N?<ņ>c-zx-- 7#܁Y1x 27'þ@=jֶnSj1O`rp=k];[.g/0Gc).GR&O[ϝ,$?mK2!CW3O `v.V}3v|4sjHfrA~ ֮ ^3Gt6H#q<@qs־%aw/VU6h+B`_Z}L(.u}8bx/+=qڶ prrLK*gxNG4{,+3~i\MÂzTC|ڌnF~jZqZm^EFu'U6AO_٢_:Wm?ݰs9m-bmg#qǵӱ1XVaI_:|, \V_n_,;_^wV n~ef1q5hW|OJt@Rc%vOLVѤ笞OW01_.sxU4P8le_u:lgoy^8(sIjϷrBl3B@>bs]lcֿ[Lӕ#[XG%W UZxnN[=j][P^j&NHVCjgHN9T'*mּ@3g>x Kz-wc;^m_+ydZ5=:k(Li^3|Os֭ic~yGXۻاիg˩EpKXvP#^8A Z|%: ]q:*pJpOoU%5xּ:Pc f-2̄}:WF>6ì=EO??|Y0C~& c'}^>q)UH%*qG4%U\#ֽOV4Wk:qg_fX7J; *3ml7`Iߵ?ڼ(-R\PeӜq@%d7NiQ׮}\Io*ץTi9.Vm\/cJ7'j''gA1co)>V@en\תpvv)\s%\iX6_z϶'_F?rMNpIj*|GJ=+ϪK/=85hY:Iyը 0+-/qyJ6hk.UR=*xu/XNaAp`}j7aE:TɪmkXv+:7Q 0z2yהXYv~56̉k*T K=ü>kŶ~u$ZɶUǷ[~uӜ_ U^qL4Dmzz\֡r 1r(rm׺$=/<=}o9F* OR1W:OL?nw9egG__y^GJ*ZY=;CXJɫ>ϷyDaqyE1隐s\ZqNzַ/e݄I}Lk޺=f4ۘf?:)gRZҒFnVrz^|>b>7WB_wqqjnjAr:~hntn5_c`_`5|No&~͝ms+4_;JR$rE&,F Um{?FY, 4jڪN׏Grl^\Жn=j:4R|G5xᧃ|REY[hp|O?.bG{WJFV%UGՈag=EFuV_OA>X-e_ ?փ9^Mb8L =S_)f5o6D xOr^NͨM$9v^m\ ZW4yyy/ϣOc7jba*0-sҏkr&٘mW>%.EqjH#S99hh1h/x;[k)tuyؗB}x#gֵkU^ZQ v2?]IPJml$2{g6NoY{VuC4[V:k.Y^#1xR 3_HhHlG#$+/+D0ϧ5师n)`qKg|9 {3[W\ڰ~4 #60:%l0''^GO@ P 9,}+ًwK}.[P[n?f 5ͩ $V޾E^{9_c_c8첅jrn.xoT3WvKg  !-buBַh=U ikAE{[Ȉz~ /_:߉?3:l@9]WayzMs&pBּ^kNZ嫍ֹSp['Oi}\'-Z. 'puq4ճ RVzV▴3#n@`Cyupc2>޼ž2`:ZzJKI N5Z-WՋROg5Gth]G'z.TBGL?ZBEY RO/V)p`}?a6>KAZgofV90+{ ԭd`Imf$r AxKܵ;d`F"[vR^jG[/sO+3- $nrZ-݇xHw)Vq_ߴ7>0|ִV4y-^KbɕA*ӥ~Yܰk9!D8TpqN&˩પ]<<05KoI 8lONn5`-Y䟥t? *@.#f . _R>Z:uZ:SMxLDchSEz)V5`;úJ)mG1[vٮ3.5 yt~ K@X߽L*̟ S2xcz\],*P2qV?bO0jxLۤK]L e5l֖)Aڵ\]T|i?Dy53[|: >5]/!QN=~9~ў+h5_Wɱ"1lusW7&v3sGo0|ˈqق?wC̸LEKǶrB=s]u+3ߚ5x'qϳ[J)5G\,JH P]xoWSƅP8at־6GV|]jh'n/)3ZK)4}~Ř*[G +<,5G~B[FJ'l; GZeLoݿO|7⁸gXv7b *ROz}yLA]Oн?WA2:ͼ|9-\Vɼ{4g;m8~_#o9>~=|hyBD^@aay;w|NOtx7VzG@_:_y_% ǟ/=+[4/c!elc"c~Vumr'rqXa|d2(~q3teʝ t)%y ] "[j?K\Ri:uɸυ"qҹ5{iwp=nU1Woyt Hy8xW(E2OrFkѾ|86tlx[6N!p1_}QGO>/+T<2Gc  Nևmߥy~mqY4CCkPL򕌒;3Xk9;z?0\ˏyt: 5c>DiAʃڽO169oH Ґ9Jn<9lTbUxyV>[BXZ+ M}j-9nH<ߕ]8a6.cJ{Bݷp ^s,=*wh۠Wm=j([䏭r͂zҳ9Jo8hJjzg#N5j29n^!皜Lʸ䯠- 0sR`~ dv$U(3Xx\R/_LNBzr)|Go΂7{Tb 'ws?;(ۇ42kVfF\`}MmPOYZaWt^J~xCJ -*o[˷g8YeH'DS־K%vTsc4VD~:f,3RWEҝ0A ]\^e;_4d\u^Q`+XF[k~s0\d}*ׇ0AֽJYnFֳfpIr+yݼJoq vT |e$YW?%Eq[fVK{uk1×vĆtS#(#i=Sd,G_ӽ[U`Iko *D$q1$qM[9/!UhA:rǙʒKCwÕJm(Rsǥzh^N.i۱ʾ+;+ Et Kgt*)+F-;י2pR= {p~_FQXv~ص$I?,E5#xOWw5[xZՅ{ͪzmwg^qEmxcTJHVL{59leGݿt_ce]Ym#]qd[d1A?k=p\JTM>x[c5)叚N>zTk'-{(Rm kޕYUwL՜7|]xkW1 c ,:WKZHKQ"@n+ӼuF`JOm"ѭ'1j%c֫;RC5(0VQ F=~!intݡdF{իiJ{AkZv#")=GyUT<4)fx$kaDUsw:On7L?ZkJ܃kk{erԥ|ezRijś&5\*zI}+Z@l"01TpUN~R_38]EF>Sqҫ9]%^ܮ=9j2[FPsqx,FQŗv;Js9KronzF)deG2 ƶ$aSqaʀzSo&4S U-ug8w|[[<^-51GҺxapCf=٬8).P̰IkKuwe)>a±_mN2OYw8 aAs+ֵLB² L.ڦ_SCbAbX~^k3V \(?Z n-vrsTv`V"K 8(UGkiS5kC_ vfs ^B$Tlp /ph"vWF${ +N #Ms{Q60ڨR]y njiseM_OGy6f&Nֺª^BHd]9]&w6jNǑ7ٻbZPI{=V%9FaObxqWmxNFvlEHuHKf|_@DįҾ@<_|.\g53rnP(xK_"]p;p:`4Տ˨V5g+g 7Iy#*vt? U! Gٷ9+њQ]0@9X}aҩVu{W|=7چ[:6 JGUf~bӵ+ʿ=|gWj|A7КGIڤi*}}O&NJ:vӲXQ[]{\ Qd*(ֿ+}ڳDt]R^1x@$L7 Ƣ}YNdgbNO5]DP<j18/?KN:4|⟇~"OpO~cm}E- ][Nv4n_&~?m|d4"6' 9{HT'vN<tT0cl1Zkߗ*iO X)vATĹ3Vp=LJmu? B5wCsNӀ?} ּ8xI RkLJ."Q-,Y}~R28^ht;rGkMd_<.3ִiVX,suxO\-Ԁ,d0WK^h # %5Y4<$Ad=wdž'>oba`~_N)+rb@J}*&c=yh wjgbq҉O\ SfWa,U;aWٜzز!U>CzOu3#&csI2˺gn8/$keb`ba&RWG^Sc֮kYv!5jU="t.(].\b;d'[r܂kxו5S 6'`2[ !-K!S5τ(]O.h8ȪݗgNx6^8xY[=&I|mc+_? jJuA_!~˞|DPաaba7lW>PHSYKdW?Օ;(/VO ,Rb#jUyrsҾ'x!"GA#p~9R=3Vڡ9=OZ=omZ+eoO_-0쯡TV#2];soo짣|&SğdY XdMo;KWh 1k`*]=/ǿgs ].eqt'!ax="(cTC9gQM[Gm;QVZ/oO&[#7;o'qlz+ ?&RBpA>~5E𼖊 d_B+`[_Fsiu?A|eYxMopLrdkQĜJחko^#kҾ`_ڝ#ň9/W00Nx3(э*|ΫKѤ޹4zs? kv^Asd5㸨> x'Gi$lӮe⹷)T 7E]5}WCoM_C3E CMpʆH[_>A#د?!hugHs;p}r^cއ-uɋLۋ~kNc0iR4iL=kt)C]<5LCVZ_(CkÑy,inFN95=I$v(V.8+|/q,qTҿDaW;pyWcхuygď4.OҼmD߅-We;S ' eh[YP3Ҿ/Bt=o᭎ǥ{<8%E!{u%Qk/<_CxU#p+<.ޱEBȯDkQN}۟R:# ؂q^^&ehce20~5^ymPbw(<1^I$9ͮs,w$8J9鞕IXqOfgxIb;G=^1cBte`j+T ?θmeG.Zp>GnW]j).ڞ&|ܮCȧ[t+LyJ+ml'y9~a_&7mj*wשnos}nݺ;ǘo9=6ҧ.>_QGM(Et"↷d+VՀVڹ{t_LXZn8r=+xMYfϬgi@8?i⯴oz{Wx[^$h%/Iծiīt#r,6޽+д՞5 x\O6g=],Dm$|a*.k r#l |EI c־+W=\l vCk #m|L1\t&Kƽ[ K,x2Ns_%Tû4|'Sֆ^B)~o$D"(W=78[$gJA'֦2r\b!ƭ۞A pkR_'>|!yV ޮZOҸ2jʹjlq5l95)_F&ZoNn< vre^f^:Azc[q=+r0PGNzR'Q2GN9\r$prM 784?ʬEAQ&; D~5(L3E"Cv={be=Қɓ=MA5[7?J1㠨@2z)J&,y"?ҭ;uH`t?hqZdqd|)uCzVH%oG"Ėm"![U# ǎ3'oNI1WԥS:2#NHQÈ-QvD aI@xҴbۚ>)lhY"KU0i-R ߵjCjZgΟBD,UdV])ڤcڋ}Qn}855y_4sNK܅wxC mp;>j[Gxy#ȿdWSJ{NefsmR+!aR5㚫i"xju5brSc" "O5wmb*Ȏws;^&hSroQDxVkO3]FE\ӭtOW/]bmiRz7>Aylj4i4%{Wt/zSw(Ip.XU8L1e淴s^"li:#SON{}d2.ExQ7?ꕜfr7T& s8lqlpGZؖ?yN\q=h.jh|z I%AL~! {W!eyRQA,Ǡ=zYդGVfݰc_[ vTM'›y{'rhW1e{gifyf$g4A4{8lm5H?1_i(b%eW.~?@ v켷>s'ٖ+/zmIfyTwi'UK_m?@GSZ.xr-Uܣz+ε?u(Uӻ$}H’PJ}8NTcmVV;Mk {C.Hy߉l'KA ͜Gc޼QRcc}#ePEy3#a[{j\Ֆ{gvqc$~> an#(6H1?NCăC _uk!ySj4K/@vTTJZsK1 72{r/Y;\n?Zk(\$ľ$IУbiyK{37/cEg.$䁞SV:Xo4uXzϏeԕ"DK(?)Qןxq\:LAؒAnyjRQEy|]k>/o5VqBJDI/a+u>Mk8\.F3ϥ{jj7]ZC<|1kh5Feq¹]GJ<ɕ|0]?k1ʒ8~;kĚt3 (۸=}t$μ.%jwzn'>H9h5']9 &X&M^678<*ҭ>jwHl4Hs(ǚ)BB*[u\eeRExsRg6&luzwT\.7Ƴ.5W;(Rzt`LV ǟ [o'"]~Q܃QS1n\EYގƽ' Xp}+y"ʌNӌ >sj['kyBz-̨gQRF43 uW|Mm [p{{CԟOrr1v*RQOYܓQZx ?N2cǽmoR}COIA'9yO{eg4zӻ @=y{4XhҾ,Iw܊ `9{XZGrN[mZ̝A|=ْ>.H fEDTdXJy%^|}y=<g ]~%qken%f@QJXXe $F8Qc>{[ . @f}VaV۸Wj/T.rJ,K=./ԟlևm\Ǡ .Fvoڽ[/o2C 2E_ُNֿi/[q &ƒk_w40үk 7o?yx_][ M,ǩoh$^_'{M km:A0*V"Ud՞V2p__ě?]` ۜkKxzERU +o|%㹿&E1+tZe[O:`Sseωua5܇΁vZwQKq <~ERE}a2;)GÌW8T{j?yU$2; >?}4^8c5,5[şl)"?7J5}Au J{FJ6c^R|[*%O,j՗nt|Q(iqڳA_\.[MB3#/aaRZ˼?A1t/`s]D>XA45ƟGfh8W5kQ8B[m8#޹1uL#4އi}訷sפo47z}nC| Yc{Ү׈(;c|DX̽9_@Š? ,4LhTu2Yt[V$s*ݶ#xX~" `X~bS{,q/"0z$93VUmOV1p+˕u*GYhNz⼧Us97]Hf9A\Vk|BrTeE@匫t5c;IӻE?]kyF O\dzZz0w>jhȸ㑊0q=[498O~xzKT GvICTXTNֽ?gS%U_j5AvMzokt ?tZMZ}6 %zP1OGZWo9aV|?@Teb־ՁT~9}nH1ҼT[j%sZq'/b䞀u5}Maifi}𾜮s]}Rh+𻁌»!j#a_3O3w)KHR"vSW3JtEzP)<+ gޖy32~kVVY+OJ~k3]*ګl\qnz+pvC1u8 ןJq7j \~9$5X򫊴2U=R>zHr`ҥ6+g:u‘*5>xʔd|Ӄht#ըa{S"LpO?ʭ$Wc;,@<[20;6wz gj#Z T<´`=j ?^#sscvV|'皻l)ȿ[{Ωێ5r8\1b/~[W!\csI 2H8SO$S#H8ǾjdLtnz`Ҕt`E8Gɨn lNso *WN4RßSsDJJFs|1БsګIyG==&f[x=S zЙiJR9JTmM#.O=>0rMp1y<:| _MgJ|dA'qPpVq3oOZ)X[w {c5wP`s>} ^_Jʾec] ,T5h۷zנ۪9Zd*vE~Y{JiO]*&d[_=^=wÏ@Zm[)9p$sҺ;w3a2C2O=2q+i!PNJž(|O2MѼ?9|];~$Wk^ojE `}'I}(.f^`}{in@Lܹ?RI~> czt~N][%xl5#ztt_-K|G! oa+k5͜x:a|[# p1\6üjXyWP pWgߊk^8% n|GːFϴKwqt\9r#>~/&ˆge _.u,+q뛚z96w"}q\>. {/BOSyPM3Ok|;:Mn~);R(<陻5m|ʾ)ziZgkLojd/Pr~5j  =}tq[?L ;0DiFBdZVk< O\}{ '_J+昗[=6|iiZ !HOz?: MHrIt>59vIO˟cZμmIRRMGStczjx! @`c?ιK:i!I#5|>m8\L{W@ԯicCYz|3>c:U*JR~%+=q,/=LE/\z޸[w;uPNSa_G}##6OO,V1U;/ ,3W&fu\"2~h^ůJڲv?_ϬʳX{O^ Ѵw>o 穯37 |2)8 פk#,֒=|Yq#IR>~vGy]IԎr''u1Ll}GZWK4U?PcvdG"lOr˜UZ_ᶞrD<!^d9WDfA'v|Vv7M#=ŴmH=}7J `93+Ƶ /vjbg%*>ZDfW6Ree HS6?r<#.RmѢEr>󬻫KB7&3'_~mq~_<_1Ri-YUh^C_U_x qߊgn]׬`A=VIjV$c߳Ɔ6IԌf(Kcxc7Usm握v۫w< # I^y[+l}7U6Ys{Y(+=낍6,JU<Tލ#^+nC1빱f7F7q2Ţ≭.fVCH@ǭtΫ% t>`~;Esְؚa[*N=kYf$:}߅.>c{_O*^Gy.aZUM\e]x.^I9=+>? Kh܏orȮÑָiЧ=)3oFcV9։Mk`?3NN.dF:T_1nVB\2ުCx.>W#Z[k'Cɽ$GbyҎ`3\j*1O~Ο$-ΧCY _C^4meXmf1޼M~᷄]!@ӕGBt<_dm|ksB7FK! ~|B8P&r~خoiDz;;7<םj']B?նOs_͈D$V,Mםyqn;S ^E<޺_ xdʒL 5t N-uf/>[*'TslY*=ÔC)rk@o s#ŲIpL!%Lv>ZVrbiRGZO(#OZ:nݶYɍH!]Exb_!M5ot+R G,@?(QΫ]#[8e[M -ܜmn7K_I:ǃ^SI?,5;AQ#ҹ/kN 7z5h\WoCK}?BV; s'=G%.ȣ_W:LV=mGr#lpھU?_xqCqC&sozrUU:ME].^rQno+#N|M]2%RZX>!Z˯} ("T'sIRSҷd~ùYuMꢑ_]-\Wu0-˼eݛ5&ۉŦYZU\~8~uxŌnq!v9hֳ:OQ'rj$v/Yl^;(O?A^LcιTMho+BgP+3Ú h 3[/\t>+4=V%4n|CW*܍Ʃx_6W'J|Je+kѩQV>/Ĩ;[]|9Ͻp>,Z0G'p}GJI4+y#r0!^]2 |ytZnj x|0tB2;5Qo5F7Їh8cs,zbvI>{",c׵k~^W;/d,?  ]ю+ՊFHZ Rq__!FܚJ"Y-8u9Mr@*yшǯru+z_2 =z܈[T/m Jb_-^#CqQזg9z/ﲬA*~q־Gs|EJ.!mckPR[0h?Uq8kWwOUJ4[d9=6XXӞNsZvWfV?z|dSQ&YXO3Edss+Zٕھ."NGK[O|7v'ךjQv7KtkYi;3tP+c8Ͻn_,2A*R$ q]^ r**s̝Ws1ֿ *^d~YTCy,I[x1 Q-cE27g*NZ0Q\[!OdpGLh?ýY@瓊vٱ*+>J뎹8#ְ/Y˒zvY6?j=r7)3BAU|3zUOpsVV4Y,NG҈Wǡ ۊͣhgJ~01ьuޔM->Sy$cgr{vgZj-l qZ#Zqy'Mɢ]&M1EXAdioU|rcIHԥmSVҪ0.㏩}=G,Mg]O޺?^ Mb*Z+ey-ƭoj:Ps11(u'JA8xcl8N]V .dlƿ6zՈxul`⭦^\K|[x`p8ic(A5%&6lR \YcQe16*)Eh ^H9<֌N9YFwd TrA!W4?|;ӭG2p?T'ٗqXUxHZ^o%dyTp;Wnjm6rxDES>pzƮΧ{Sىw.sKHV!Rxws9xxv {dpÐ IԪVݑZūȒ27YMzs[@4ȝbS ?ٶw7 h͸}<5ZԴQf>:U<{+xcHkVkT*=wt^;kaOMQ5 Ua/l׬ߊEGlHJgrbrI5cPzt4/"wwkE\blvK7a[e+0,l%{9.CGk߅6{-)n dmտlm\y69-I'":z5γ%tk\A*4J0읿#fK4{u$dNOsJ~-x[HE+s~.% &'Mx+ʾ!2dvu<<%iJr8S7c%Dh9&ZF%EW i?sPX@ Ե\3yPϔʬjq {6*֓OH=lgv2-yp;mSkյ9"pχm[jv^&iM-wu;kscjl6rrAycbW\G h ުIpNUh͸צ6|:޹_ +YCcc8/;' xTH0.Jsz%܆` _5ғL hNn'Ϙ>s+rd"~ji#My$VszWg%;L5_>?gje{4.\N? dw5 5i@YHW7y-ZGNE|#>2ny#bOb=:WntqWGjJ+SwOS+ xSWFut)qc<7SXf b^Y:4e9>v?'z|HKsV-~Gbc+M h:C8A|Qt$zWaZ|47ecquU $n$tIbl2GQ_kc"6CztV&NŭOo>p:럶Ŭ#Nlhϥy^J:ԫ$T/i)Mܜ7۵EK=knfu=o/2n\q`q^?,I +?24' DuY@ۿ1޾fċKMVimkۉqL:d?\YwS׺ui5]B8ve>ny>¶~Po}%8 3er#"3̙'[#1vI%g?ּlzV62WL嘩u3u]$ @$_9=sl=kkOVvR]\< \3_A|5$~wT3ߩ澔bbF]Nm o;QZ%`vQVՌ g֯6l +=zu6<֭#syq[ǵz߉s&.k] +i@⺋tcw83E0J=U|N#=WO3GCϠ03!zUwWwBC>ѶԂ(xK~fռO_ c̊w;MU]V ZeG4ንUdgw #4O~ꟻPHr9JtgKvhxyXkɾ"]IBA5>8G9|t%>i?|We7U`u+ϥ{wּsXU;(?~=TT9RU4Tb!>%"HpۯJnx <(1=jͺ>^1X`XA;!y0'CVJQԵ$cP1銧ҭ@rzȮyčp?#Vl-\gҮۜ'=1\ұjsZvdCX?iesQQ=Ts+wJryjDI4#})8t{dҎ^s|OZzSB~S,jUڢH1&3vTqqPeF::" .1^ӣ(oa~\L7#Z mQ*9}qW^FHޠ<9=k9QXq@SDW%Z&{}* zЦ)D)>MnK`QD] : 'ͅ>,NlƧ==hEPܤ"Ge K& >s'6xf# c^|Ϲg/+95iKzG c~&oEg|7_:oatEaԀ?Z֌yiQ+gwcۊ~1U7#ֳ5W=9;w4oZx;I8JO' `5H!_9U7OB?\.4_=>\c,ZgnyߕORPGabX-\" pN+OhuYgI(W(Pӫ#'x_U?./x|g@|\dK$5ßG|n>⽅ evF =Yr~6Dgf~X a@>FdjMR<1"li瓎I''$ٲ/y~0٤"O}:oWmB-%nx^^8 8Zw 8u~ϗu곶T 5[D`H ƺnٳ77W8]gygF- ս z}+?:@IaA~UE ;m|qXtӺ<\~ 7XѬPzO/ vҺ\\+!9كЊ|CFeUd}qz l~mOpz[."xFmR&+`P]0kăO7 ûP|E؋v>xKKio&' Bn~zLƔ;k[-\ O#5%{xw9ec-ϜIjZ: MG=H=3U`6@mFW]Fy5k?m-ȌڽO{oJY`8;GÃj sv3_Z|"bQE!M-W p5K[ハx94-"xP1Ξ8%`k.aBJuLLV\ n+4(d} T"QV8ۖo¹bc&`+g'޺B)hy&m87apC59i7 ?.XcSc8{׺xU!Eg!穯 -D͜yq@'qJq|S2.rף k:v%$,U">+Z,NTU' zWT~mhiZ,[T˱RQAuJ KOϳ>`qk%TS?9ל XmoI(*ѫTrv+rZG>3bTk W_P", ym9wq_@h͚I%W|GkkM Rȧ`g&qtjn,X:lg5VI9IfJ+?ݫ]N(d^㨮n7>V.؊9SkgHwOkQevv߀s|^W$rKj{g(>jKu,IlxAҽw2FZJEyyNғNh rpHvz7$XgxO*.d؛Pj c?W8% )Z-hin'pFN3𽉵"T=EwZr1bx>J$L\S.A8p1W?mvo'?׶@m-S!syn }[=2+7QhN[9'=s_ XVjosQwҟ Eaׯ{>5 go5ß8Q^eA@ǭ~/_ Q%FM- xd ^Ik1"`N} i8$k$h׮ Rhq=+-sd =%H޻pe JSm?2ʺ 7V]c9NJ[kbz;䌜ۖ圞@++ g'EwfϾ+!b˕Q+:p7%}>4@nv 03V~:IJ zUHđ~t8hoFc 2I?kTWϵMYݞ,<촚:i22.0x[c8"c1;WC/FdCk-Y 𝯅{G`JTu=VM\NЂ ;qNv.IX4['S?1n¼:~_9^^;#7UeٴZZsq%;!Vǎ5h5Kt1z(ɯN颽Sz0ҽ✬YF?v=k4[#> F ,zx:ad\ēPsV|!d3Zjr29OSڠxURxCtzj^i`:W Ks-A SX&i̟7s_F9U=JY쐲&z:UZn Ӿ<7zsY%=$emᝈO~Kr23F.>rk貪鲌Zr𞛘ޕ9SڣDLX,9N(:N<[rk/.ck5m+D\WHwU*Ic^L 7;i$jy#h\QBDz}+˾$m^¸x`^}Mr W>- .AzXnjڽ/dt7 EyބZBXW|AΜos(#KȮwzWE-і\Fj@FxCMGq>eiP3n*Ri[RxRĜqV2 kkԩ{h:Yɨ%[V#x?exl~]_2zW*uUrppkKɘ=+"Fz[ZO#XQ'92}> u#{3 *dpk5W95xxVcIlu;յv )GZk1ze[/T^cx)XU\ҒoJc\ƥ#8z5qd8-Yg9>ޔGޘp֜xf7DJs5('8N [CLp>aHUc=}*IoО7;Ћjx =*呬UDx#49J|p=M8|>)j2~;cA$!itbYOϭdUu\s߸8#[ګюjb3j9繨dZ@$z%C k(X]OwzōӭKxI)=j5M*{7u믄~ ׼-g,RdK{ዧUg$Oj0-Dž_O#?7i ZdMѧd,}-جc[Cyj.+3vq޸*Zǖ,<+Ybq;R=88[ZlI!lOqVbtӊ1Vm2ÍOx$l$ s?b|3 >Z$EHwnXeX טAD'<^ȵ9:K=^H.yy#;KY.y#p88jLۆ9 U$o.f%!]3Ҵh k $1y+iA[q&*ی^sjާtrS 05_?fƿ*k}JxZuoeR:< dnc\{⹚k3[^pT7]̖w3/1WKsR`t,ԴC.ˉd<=돷Qrrj嫴y; Ÿ+Mwzzw;9 34^MlUx9YYQJZߞ+Rd瓜}jPfۃ_i 0oǯ,t7(c9PC@VDPrR@{?/2ѣ%Mfib$eI$v{U ͰH;}*y'f޼F7;VYY9Շi5to$*{)۱HrZuU.;zv8?7h'2hW8ACipMbREV~5en[.2hw}c3v=VQA;׽Ů$lq~γa3sfE\L9}]yLÆ䊚 #7uW!msctRqr+qISs_#*$쥩Fk<-T\W^f[`/su_?ʾ{r9quoo:t<)X2|n+hͮZCIUN;_M\R#X&a W%7*ԽZ՗߹sdD7I_ M<ȿ,b>?1[vostC5nOp@V0}zYɽ2wx[f$sX~W<۩_;M iHo|4驻3RjRG/EFɹ[{x^EݢW9)]<֫p2`?J|-]V+ Q ɒw'MA>GGgkM&?=hkli[Vdrvr.;Voe"RUMxԥ3Q~Vߠ/tsdœH;c54zZcjc1dž4ԯƤw4RJ1Z Y"E2N |)I3>w߇#2[`!?|cR=+(3^!<@;/pB,ܟ{eN)e'qkֶZ8.5' @4,Wji%,b} 9FeRTӷxpZNܳNKCC`VS9-j[YOmSib]:\}ڽG@dѤ28*gNlζ]%c̫g +6}*[ys'q:{qKW<:?Z ei[wv9%,&G6q|^k0Qtpz>G2>+ἇWQgn2kՙCԊuWiCMlK;u@53N1޺EfRqⰩIcr1]erdNCrAbH"z*EQuotV[=9DJ0:~U*{t. Z]MX^:M! e8;޼{U_bj# JWfjznb_^9qLP*:_1F.Ϊ5N$㚥sOAXMS ywDskP=1\; >ykM]xVbuQZ1q.9#ŗ1l= \P(4aټs\nj%|uҲڛ-SlZŮ2[^1cE7w d{VW<ڥ1|5ZKU5a`WN/%n_p( ?ߛۦm* ZKA+dZxNipqҹ)SVQr RI1V e\Uo<ִ4أjv-G_]i ;|Oy|P:WQ|?jsXikfɯ+tڢz`ҷ=fN =1]ց1`."u`޴=8h2)>ua7.U 'Cۚ,ٖU+O_j5k;N?,3P*vZ|1H`OkW +-XMPs!P+Ui%m{*Sg~^&+ⷛ@K+p9m|6q3H]aR@=#w>'&+`+rۻx8u4t>[]#Ҵ,1VJ?%\`/RX&3zsGH`K<׏+.?J̭.}n砧Ce?v/?m :jHF K+p3QxPb3]l&\5s V-*YcdkW-ΈQR5_lX~S~py$>-:Xh\ϥ{GZ;׍OD{ŽÌ^F Mztr+>{*Ԭ:;Jaq&>iZA8? -#01^ekRN>G'ZMzCpǕ]$TسS| odϭ{\*ҼGk2Z((GRx=šgUD+O0 Dj}tgtEZkiG>bk,Y+GL!`9/1|= Jo%'=+,x Y%cx}[{d[=zכªw<,tX?k[h}+=Cg>áHQ5!ť8kz1*HϏcҚW5?ziuyr<.nZyIk^qsɮ[KNm\#08z>n6lۍ[5&kEc_aê׫%hozcڤ߃KO6N:dkȼA R%F<8JSԮkU[km0N\}5[M~.'UŒ#ԮiI}Xq衋"aEjgWS1[uoP>Ҫ;b7⼼ԣggsϯ;_fH@!qJk=ejKӲ@{f.{w515p/6wg1KJϫDb[w$W)oi`^+Ȕ(ۜds̄Hd{WkR9VƊM4ѻ&enпA5LjIu9V3mH ֲ2β=YgB#4{W!Mq 3һ k)8UJY=54_ > 65sZ cgcy1ޅKH1qҲ|ҲGuIOv/I} q+L}ާY9<Qv^OA5:]8<Ԯ] ?lOyc ׈BUY^lhENgncÓjeS瞕bƈ8'z+H|17漩\M")lE|={Utez el sռ~Ng<ׁNJ|;g͠0G^qV-A'T8k$ ֖O2TA\+֞ީ9'CQ[fwQi|&q1k-4 qӊoܺ{|'BhK)u=_9niҫom>GHU /ުMF)¸{47.yylJ-/%s{ڍc Rѱ6(eI㜟k1TVT-OwΗuq;+\+@>ξpŲV#+ǟnV>x X|EA>?uf (#~)_oҾ1;%-Rg[M'DU J=C,BW~g犴&ү䌡_(?ֲ E}g+ŭͬFbG,W=6Xis_!ZP>pt"[FO{?WWlx\w~]x4nH{=>*+Gk&H/s&mQz^i%۴I߂K2l\?J?:^ d]횓Ñ}ww4˽FۃS|uY*e! 8{PN~[q p)F~{kIhn^Ep'VB5jgs^{ym4ʊZk eY pCU٭:Z3h [c@J*5u{O O9*94海2#1/V6)C=Fs=ڜxsFy!wHFÃ*oQ 4۩yN0@ZYy9oc2֡ҭ%`ۦ;Wtk[SSmQA+Ԣ6HzWx4wEI r+Zvs_ϕ0ѓٴLGJT+ʜMJ Y-Wa\gNk!k{ ;\x+b#c,MhY>& ! ';Z|&k5;^mȚXY1EonMv~ T%Ĩ!UeY,R۪)Qҹ*i䃞8JP$=l5UtϨ.u|>Դaфs'SJ yuP/Xh9> !>oFsN.xsKFt܈9YP7#qJg DًwgWcⷴtmvsӊ/~|&q޺ ' ]fiI-#P,Ot}J<=+O zt;}ʹ^(55m u49xK. hjClW>X潘mKhiA#YdGNy5;9.:b)$t%.Ğ( Uiw8ϮsZ$o YLJejӀsөcs:̒ǵs&Ҳ;!EI9cYiRTQ˷^|[^[%qJriOusR{ݑ3/y~54I'ݲJFqM[w'QTw.ifKR`mpY09T>=j49wnCKlP)u{K#l&ח7CHmdb^_ j>!]D7c&g7mQ@{w2 ],qOe7ֈ.ZVts*s35kN>Zq(m=_Wh#<;#56=*/n0Wj`''WxFj (#};VI\W#t^O60־;ʛ55NJy#ռ/qا}Úai.߇^8-N%_jtpS'<]?8)Žjy+u]Niv/Z5+f-]j(; q HzHl{<Ɲ}k4ks:XtYYewKB=+/1l#=k-ZLX@l5mij[dڈC>jg5>`QldWMwxa~&f4~\gNt ~nON^$XI\A9K`] q{W*M))o`8>[Z/Oǚ߈B`ztk; ob0F;5{#=Ҽ;?h8⊼1z]1+Hٟ9gMD-pvOo_Yc9HYze#w`nVCWo du:}+.D;zιK;~Oz<:#Tq_AWS<=r꾽֬6]χx*"`@+t!<>nb,k/XQ|f okϊ+ ;ϔԊl5BVcJY\/S9aw9>k< R2^yV]DŽ\>h=Lf|0N@k< ">'9^l}Q>MpLK^ګWh 0)Ka\W5N̷F{ΥPF 1IN1iE5>xMDc$zkTgbpAbWbgB8js)!EwtҴHKQsj[y5kxYG9Yn6 x:sg^yfR=_JyѳޮzF #$HwN[6E8exU}Uj9hwm 5Cwgl"ǔ^G~!SEF'EbII4]Ymm >׉ Ɩ⛦q$>>¿?25]\`ۻ! j)=Gm]FYyӢO߳nw IS`'#.zVG򒾘hҾe%Pܹf9ckْJ|*\ӓo';x7>9cU$qoAY>\ `BFA}~7QөGG St=?PЂ&ڊ9}:7rwoSf|7NdY)C7޾?.M#n_3C]%@xlbl*_ݿ&>I}k(D9+|dmkz'Z)ay"e#Rl?UN8涼= PNx5qv]5s oX !{6"I;>b|pA?jW$U^CnfU+[sOL!+6xb}+ɛFSѭh\5Znֱ_\ 3Һ]zNFG՘~Y3ϊW9=`ɽqjDŽ<7wR<޻ܚD?t--/CͣN>ʖ4t>lnxmB`bl.Ma&k$$ZN Z }nFՏjxl8>}y#C ˩pn%Ot: UpsU6y >"ghܨiu;]&e͹S%ֱ1s~7957.k֦1m>t k!v\ɏ lN~RuKB'_delDet- Mx+$gu?-GIH#pm,ߓ;2Yn"5Gq$mHif?jU !x^לaw?k {U4 ,l'Mݏo_ºZȄi TbdozDag+ p) yZ_wSj8Ir:ǽ~xqu-$ޜ`\ S-Xzg -JW>. ޗcϼ+Fž3pU3.яR@׽z'>R~U^@]6J"f`NH8vMc/ܖ TRZf51vrV5VaG~1~dS (-zUǥ 5 BA! 0kFm[ˎI _!ŐqOcN1nzaIB\7tYuG3{W|Rd&f>qzOm>(^yL"\/ԝ7Ļ7IDu*i^Ko57MCCaWV12AwҾyw j^}2s-|0 w;M+s𯨪}ZI('W{X O˖jCti!g@xZհì0<.N,zt:)>iO 1pljK~p(9Ւ^]_i.-ZmyDœTpߴ&o|g5Ci82+|KwhUh^!_ j-{f{ӝowoAaVzY|eb A3m5k+v0'<zpKuz+݌Xyόk5IHsb(?uo+59V*݌b)f_Ŷ峟\WYɂZ=(L.N:W&RtBZXhr^P&Йsq ĞO!L\)DXr3{l48C-&sʻ9mP0:u"ʤ_AK5DhdQ*χ&1SxkII>:Wvk r, D?B=^gpzWGޓ33Z-cbV]پ#gjL0LYHT`zeSkGV%A#?g's'ֽwW!㷥Y$废IkMq ŗ 8$b4)$ssZZ3C>j3I)TF\x]3ϭ*jꭜ[)ΠC\)RGxFVm5~U=|nX]Υ&F!<潳Tk WQ568"v-lig5j=" ?:z.2x̭LUC n}5OM$/]iN'li_ZaZ{VQOg4$W$rˎcJCZFA5Oykڥ#&ܧu U)dʼn}^Ў1޾Qӻ80Ys3ӯ#ֺ T_ q8Lc<ջmOf9OݟyEBǫgžMl^o)|c@Wq'޽"-{'#8:6pR-Z+72p=kS_Xm>[Xi.Qs׊ Oơs px,LjUB<J)r9rK`ҕ~_@;~{RQiZG*h;F^`&$zRFܨoZPIqX6Z6km&$ִmn08ķW>lrN&vfr AjķRs*W U5R&FzgOY03{r]REs5/I~jv}+5n0~RjO݀5sE"ٗ8t9Z=1XJaӳt8K`OJWBuD۸nI>|h3rH 3gby򑎙$l7L"99 ɭb'+;6oyWY[!OUE*羸i0C۠s¿FSZk-iEzF}|xLJSAݤ_·Ê4knHŒ UƸ Nsg ĉ+.3XѩN1quDo(W+kXwvW1:Gw5Z;H8+S3K惖L$toݾְGJďx&F:T88ǡ'LwOs^AD|3&@Kx Aezj׮i$|JՊMތ[eLJu!qMѼA4(r5>#Bdm_e M)-J[wBn:?I"]ۀ3KY$Wqn&s>|.(=#S*͑߰tc ]D'#,&#W j/R;}6g?h$}IּL rgž\"JVdM@<{W3PP۵U8n.?IOt5}[/'6ѳ'j+ MYlqS\.Bܐ8^^]ea\ۈdg|ǁ3\׆t9{rùBVB/j]K)kC88&}Rv5ġ溫ȷw6lVhFB<[WH!N0+.])xRsoF߃Lq#|PI;qVbb$J٤'?S9rI۫:^y4eNG\֪+'a'X 5e8aU8\*teuOt~T3S5{olp)tSԓU4\kitqr8ܟZ#wd- zOYf7(8GЭMuOabonҴX6ߕ}+>K Yq':J'lQ lwd7lƓr/ٶe$s`zW;W̸\Ic"a!E$ycv:u.Ǖ~"~^"uKVX2;p&&3%̣Zg\EU(E/Mft.CFhB}EO+_v@aɯ5n^5C-7/qb}k?g?8qM]{9A i,l0ASc?:sRmϻOC? Fݽjd<(mv&׮ ++ЌH*Č9F"u6ذkVys\͕1q4B:?P9GJЙ1}{W5gslYϹFN+­Ki؋WP08 1` zvq^oH O^U)X2O^6OA."{[s^mփp~^Νآ\V3COzJ&;k!>Lbm͎Y9UHIֽ3N|Q謖Sn\]M?z@E,OƖC?Jɐ:z ,%i9+ՠY=kҡIӚlۨ%dZ83^_h܍WAȗzԎ`N:nˇt?oW$y׋uF߀5e( _"ռկ-W3NgjsnN&U}v ĺJ#"Sxg1r9գnru^קfUTra~v1ݱpұh$u?ǾZ4CQF59P,9RqzVu3+<{M6ys?cG[r ٘=]Zu8OS} P$p;|W& jhzVirɕQRZ2x{Tڲ'I<)מ|Va+4qdAv7{2zƶ}.3a#X#_ΰ!J/} q-3Y=,쒞"N}p=i*Qo9KN7b0[Q3cBҖ29J|+@$##S*mD㭉y!%[h+b;w7^= mqtJ`*Ė柍|p0cxoaz+|/qowe#< |8? #94U8R՘0ؒsukh?1fib`0>ayex#5Cl}9yxWVh3Zm#5v1⽬5ofGxSYV+{ֻ iܤc#cdIտt+p؅5cͫ54YC+w6?]zWJq漌{<tG8rMkCbv9Ȯ3QoNsֿ"ͨ3G|?c֗Ut _78)4~0~ %IXs#NYv⪉G89i@N~֣.+4lv)ۀzz9CMeێ9W-NMfG&g9&Ep3IʢZ.:>[ +{u#=Fj7 u&&\Mn@  jŶli`X bkE)wE.x=ja'+<(O1詛ӊp(DŽ>:s#! SJ܋}Ӎ>݌].zWsɂX,fڕgoI=>mX?4v!.$}a?«kEE~:|f&Л;RQ>zҴ[9+ռ% 3]t a̗;P("쮥\}kĥjOYt__sǾ2XvnWr|}k],zYj>LcLW*ZɊٵF`p+=\woi*@c]JHօp롭'Lz֥n}aA' Σsۊ-ӭ2Vh-SOΰiJ}qZ7{!zFb7Dr:Ψ^CVLgh'h~b22LW~9I“kR5CirK;MqiycԎ_0^,Cw%#F~θO |6k sx\7E/w:rKo LӴ;u~5_j8v3J4~WL;!&Iޑ?_ )>ggb\׻>7xuH7Jp7gshĜg8\]VV~F:u&¶A]wq$ltOKypp &>ڝ1b9oGChut>a?» & ?yX8߳m\hAϥse0|? "ǥw׺Y' nrc n{6m<P07jHoXzujFs+eD)oso?.b,I q\/S荫]*szWƋ]^#TU'e!򜎼W77A Og`3$sZjӳ9fW\H8TpDf.Z kSOWssZճ^v+FVbXG޶!IȘ:u.w`1zONbb:cҼĤuyv_cN /@ kԴ G&I5!p$#8z8+SOX1+3d֝މX<=#q_?RLu: >p0w5[a5{f'kJ5n66C A^]X7WTD+xYwYZHFc~\G$ ~( aHuȍS?/<',~G K3ҏ+nT((IumR("yws[>K<ֽ3 ->^$&CG5EΦx~'|);.@u bѱLf"^ gj;rtM,Ԇϋ2rbaRw|ء*c;p]N*]6+E)klz_^yjg Rߟlz|0fXzĭ8SYlwCSA*9MGSw늠Oݞݚ,$nvꋁ /.W m8˭^Ev##to}W+Y0TsvzkQ>SFX 4pجnݏ>Kd}7t$xB1m^+z4iy3֣i`Nq_arXƽ7vqZVgI+j]7N@i\ךve7Wm?FEJ'-vJ=:Ux(PXqҼwMHIZZ xϥ汅=F]N0Cb3Dnn?J|U+ӧE#N:3-Z.sTVy(Oqo[Uz՟D:W̮U{m4"+{HӚ=EnGR}gڴ-e#+xISw=(fKVM]FҹX젒*G׌k8#5K앙ˉB׹aԌz|M uy kGCYes3|6fgu1)srg֝SxK&p@k<~'vu~& oҠ6 Zw3^uа`)wAӏΫ,܂z֏;OtQ&>s}xJ@(`dRۆA=0+׽JrzT&^Yx=jX>Ae9R$ݻH#N6AvXc9JƎ w\mOVRCR7H#oW20N;SRGl$_5|ƥIB7/˓隙fr%sTnI>H{|«5Q9!Z@qLiw8LyN*2<835Ig48';pFk~Bw6;ץx'[bךki'h$h ;%S=7=bq x|4>G(/`e)*iJ zz{I1Cp-K Ҷ}1+M+.Pp^|7%PT*EQnjEw `F3Wk_ wZIc\=Ok*3͸\W/2xåK,6{⥇U# VK ~GjLf2͓U*KiѢMi %\>⑪2C 䄍H`+X(b/8͉NU$|=1v4Iv'&!(F*_` η&34j\9SOmpj`Ҁ{l;Vݝ>3=NDq4p~$8g0kίuݬZv;`V/+GzMyj,+sZUAfuJjMAcQ:w.Zel:^ŗD㰺bFӓyٮIRkFt4>l!BQߵa4zn9{o(gӨ$Ҿ9EHM09 ,ag|^'NqTM%or,z{Y,W/]3j;9?gj+pGaFm-I_>n[6v!qX#>[RF$z/^Wh?4SKsw$ +5DrխXǖg+'J1w7>4鍶< fgsilZEL974Iݾ f%9:5ϴVh{r$\܎kT8X##V, 1jro5/O h̝~PdNA9XH!lmϟp7Ҭ$WEѷQup S#cojlK~U#7W! '>NcYP{gYv9>:PNV:[[Oj9ɱ&jq*Ždrʞ%c[Qnְ|@Jb#ޝ${qps49_1:W=/ߘnQ x++V >C [[i>#z1*6'>c"b=Q~W]2ԶG[}Z+S\378r7dp8qr?J4$ҿ6?-.\Oab-&8*nu^Mdx.`eV$tF [z՟he0ַjF5%tU ^ٵ.ed8m縯>AF*ӣhk75g\ ڻ$*aljT톞07,,&{V,<Y.Tz`s^;h Q+f1XA;s\uт N1x%|]1+GO!q՞ZD ZMt}##WPxީsWxw])DCchFR^9FJQ:Ohz_4q,9%F>~,>Q& b}D]/,NG>|j?%Z~5f|^gcA7)NQLW-3GikK]eÚ ;*ٹ9Tqɹ۲G#wo$+'}ldD/Wy))aFfz)S*2lz5i!X:Ve.QHS+_|;wP\R+~jɋRpWm\UtzNza2 qP{TWi?Lz1NFy+QsZOĵf 3sZc~^\kVԑ޼Һ]' օn7z7`s+,<\VrYGvKDd kvzW`*2 LjD]ϙc$ֽ#k[H8\ոX3+L>Fi4)I y|݇kfnW yp]t*ԏ\ s+%L9,#z72k&>Xn*폈,OJѺzjf?B9q=r88?`_MZoݠVl}3Z]Kq澊DITRJn4}WqU4s kE''&6Ե8I8$n+A~Y(2A&-:d* v>]pkV][7g3uAg zV|ty%bUI{c5m ۢѧqՉtc$T$grX=*ЪnۙZ֤6}Oz|O3 ; mzIMyuo2(ʤ;iJ醥gb~l󞢴4 HΫ\P=Ի$WS.r==MtTFZޝ85%ՖT;z4'U۔qW$+;֡-']1vXӽvn3]4dQwRԪSV5>s| x[7ׯJ}_h.^ o|m}:h%ӜWT{dyO/δf?75Ɩ0Jֲ`p>,p8[æ?:r}byҨEE-v*}ӌ]BAVJ==hu]6-쑌+޴$@0TU`RX2q[# I5ӂaO"J*Ws{-ffC Zۊ:t+M(q3ҽ:4= c-"mN܏P+VQ:ce^t155piPJvOή[xǭ[QSӚe$~zm4XY*HT:t;K+9t&x8w miCA=vZ?[ldiҾV8++no޶-'oҝۖU2JA$yu*8O dU GM z5匸1Qn+s\D;ku%ֵ|Uնzטx?m=ٞF'5庹k^'?z}lɜ1$Zkw`}k?29/kqmEYY˷R5Qe}?Zpikb{gSߗ$p#ޏ UpKx,cު'9ɧv+8RKn 3:qҞfw,+nv=y8J$ǽM Y @4 P=oیm\oMKzՈ%XU#㊚7rF1K⹥H8ַzgk"c{ո%ZQ4L܂8QVa4w85f+wr&7\u*\nz"qx]z SKFOzx_֨7˟zbG"tW4zr1*p JQq9Q |1#Iuo~" >8m2s" - xϮ+)arEK~V>g55oi+h16r1W)u|{ ʫ,rWy\"ўs=bsO_GU8[!W%,j+[;O#ymi$ ~'xTm>+[ =Td\fJ5B̳utuFr;mt8ȧ.=1\g5{CcS}o<*%$PN95ug7Ԯdםj%Q3 wvkmfx89 ,fuqU;rzWS֩-6MncJ%INT9Ş!b2d=#^^{tk PwS^z g/NPj+<.[_Fr40 {N+! )0&+X[r6qglx k҃{t>F8)"!c8L3d?ل/N1?Zx-P{>9$f{QT{9a`c:zMˇ+ٻH)+I둵s0e9ɯej)ռqTua3B<Os!S0Nkt_MCǩ^q鍥KGj7;1v5zx]- *=oD*~7btʒr+ƴOw٫<9H"QM|;-t_2Djt2U&\Ǒ5V[S`WC&қ-Zw76 p*ݬsdgϙ%4O+ܭ{}11ڲ`pK2iɲcXuzyPd'9^*VVa΃AՉtIĸ ۠I"0H9*4nRj 4z.|gFHjAy^=럽QWVoi[p犩lAb5~79v}kZxsRtO\g6r9MnxN_3G+ ҵ(>bmfA7QJi]O"SԃJ|)}n3^uFjqrWnMsúto{?z^6ڏ,tg+`?&u/D쁖/澍ݥCI%4Z[Cs:sYĒ_Dp;5*rzޤ֌Y|zWţ1!5omϔFqҼ_mS2~Ҕїc5ޠ䟗v@p1\,c<^6j4jWY5hc`E#+׃d Ђh|Gi 3sTkKA=4rHH⽤>YXOa%φ-#l N{IK:t]x8#רEn26Ǐz]iF4)JrM77Qڻrb-ҹMu֋oE#*=zV4V"OOA8s@n£k0]OG,r+[Ufom:Tuu}{$at+gԙ5=טybzGSMq=kbk&.:ҵZq4@g9\%nTWRI*anrRּ7Kh:'s jɓau5 ;?Z),Cv9Ӿ_Wm)= wɭ-*Ⱬ;+ I%xJНj IKj9ܙzfh#p9zx*QLrHkqcO (k4HG_K{~BAgSNVGt8_Gb9YwvIjlđWO]\,̤^{W9 Jv>tMEOzgc$Hl^wabř c zsZk v=)Tg}͈eN"k~(I 8 Wk:CrV1qAq&?zzz"@:qޢ`ֺbdЊa7't^85)|܃O=סqڱ# xiS1vWY(ܓǵb?j\J>zg]UӬAqZtKE.=iڏM {U'MvWb9=JrS4m'c1[Dl,-dqΣN0{T? j&g=?Zܗ]E(My>ys3m4R ܃ N_ͷ+ECmk1]܎:oxPD<;ןsLq$xDonT 8ȣ K%F!{8mx_Bflb=W[úYX##5j g q"xq! #u5tqMF׸ZLjT% Ӡ#L!ןM$ 4xuF<:èVzzsְMqC9\獶:X:|'5\&tU̬M}!9&?[ \/ʱ^rCvsޜ'SVp\uas@{^U6`+H@Oke>QLjdny2spz['j_C`\u|#=+q|}oADn}kD@qt* v}`Nkch;;Xׁ< |ԉU;>ZP;m4zkldؒMOK*8DT/f&aGT N Vi˜Ԣb+kIԦr8kJQCQ2aOMmQ1z qVlG] rfNzܤ?ÜTd#5W*R|=y0ID\7Cڛl9wP;sa~~sz獼l>}NzWbwf^ww+)o5zs k?Sk<l||C+>du_vOjpl7G9CNsdw0>:۸s[>&%֑In>Y1giCWb$Bu@~ xi_`\QSbyV9/jW‚[Ԛ4xo-FA#kG2 I29xwZIU zV4]8Y#~4r ׇYNyD;ܐF+7FW˼oZ!j*M^ɤiKTt ':`pȮWEpYD\3\XͼA85OX}0C0Â=*ǑҰ6"hHT/1^K۞\Ljg몤e{ 5{Pp 9cr['=x^6fmZ*ED}*lWUnD9!7 j륇U:FtRu ޺R:ܪ 0+ k76עç5 |oArp ^1r[ajݓ}IF['*5w^ @yC(8dž퍗a+3W/hvڶ"\ƭ9r 5rNf %=Gaf~^Eɓұu:S$vw02y+Z70wZGE$gi_#!s-VIIs 5/hsj/DS02$v^AdFPA[_3KGSS^Sn&5b|pG [3|tiQaGA{~ sLH?έka4gmV^3czICSɒԻGW-*URb9b|O⹽CRl~=jMoR,J=[;_ WFIz3'=9Uq%V-^*)-->գ`/0jc j-?J&j>۽w}7-ץ7K:y ;׉Jz6:+CAhXM|S I{{0[έ:>FLk7 1cڶ0S9zͅH[ZyEWRvc|7nfϕ?ٵmX_}Mo-T,- nIՔtM扤|3I9tGJĻ̏q}snI3ڼCQxة=2wBle|6p;VmUzStH '?%Gޕ'iw4v,q]:wl q/J֤usjJŏ'pҮx5'ѧ  ;:gj \$F= uZ:DAls\oLzbIBR٘s;jhzr)jcRdcۊP=k|]qJR3֌,ܿ?ʋv9S|qz1ݱq^ nB7LeA5ҟ.ȞA&$du;eykvVMА{W;vCf6dH'$qܻy'?JuZׁ|Ou7Rzt &l֞?3q^{(ּO2)^8˧lpWgYӤw3w:4ےFおd;an3\gNIӜ~Uԗٛ97{uyl庎 㘭 .z].nFZ4Q擷fI*䊪|btfhc")ݘdc5Ԡkš7ĥOG#ֱϊRLFwgOFOP")6R]o[S|O\59'=j8jv?Jd]L1RZ`' Z\5SDXt2÷w9ڧ'+S*yWO'8Zl6e+JVC> K7 g?ZQwХ+6ES+ZPvXKB:+?R7e?w^A.*K[]N*+_.xV}CPy%9bIMƎ[W\JO]X:H.yگ.qFOTP WCGkrskCgT$negj6֖ŭ^W9.aMo95&,]gMdޞ}]]tw~܉e**5x^6ʐ`ǸY ASW#-Y<Ig^ =rΝڑ]63^ѬvY7OyC ճ翷FWmHQVu|8*mJ#H5js©S;'l!W48e\2JҗO9%pnn$i5`vnzW3i-\IcǗaUd\ݘ t2FŔcq=3WqkƹbySOU6!s:Uh=3DgO㕺*VX#WfmHWJW+ }s\uF;W ҧɎ#K $I⼧ެ 1鞵vHS(RIIZvq PyKY׫fXCv;\LvAlVjJmmҧCioV2F6;ֶmA`:V}֐U3a,bbg8C jiJ{Z˯ׯ8إQ} d=Mt:?ϯgvWek`Hzu6{>)Qٖ@k$p|*sS #_$gj{@NVKSEV[ ^*8־ fmWV漊+|"Lr:cQ;߮=k>{4R`~8E<ҹdOjs8UG4` r($W"FI~"EǽG n9ߕ;B)8ު?6HU}$:}*y$G1)~P0}i +}i>57䞂ʥyZuF}і~g<<Úb޴,q5h[sԧQX}N{U;WyW1m]~OS],W,ҹQېJ49dx#=jt vxfN:pzWee$wht '|c׵6.F*S]r>^V,"UF@Z][[c%os#@zu=U8 W Q6>Hjq#}|Uj>V0kɼkoPkaF@8?Ǻe`3ҋgfתORVmg'ֲu.9*JӖ~}WV Ue?sJ[ߎ{҃ict$n77 pnIQGv3MWU;IoJNwb< ʆaFnq,_ʯ\VNW1u\ق'ڵ?O褞 =MlP1=M9nmoQ{ɟ6rJEOdnYW+Dsϭ7 _ nĨ.-fG!!ʌ?Q_cac~!e-V)ydleԶz־_CI{C}B띁 =1ֿAoXyٔ*6R(Y%mΛ'ˠD&_ [lWD@8TiDž/Lq{\9Xq<wu#-:4O]H5$2`Yp\O1+]4p:֮!8YpvAY,iy'{Ҵ$||;u\>#,v$@@ָHB3C[93p85Nlb|Vk$֖GK0"SѤcŽ m');%KnKs+߆o=5 O-nO~ זx+Me!ӠUmn>MiSkI7~d#t.}9*WDVMݗIe <t2.Z֭UkB)NO'z&Y' P4^-|B?-4*rqo9>W_⏍.1H<?Ub=o;Œ7N dcFh4XoUw?g kNf J~0.]ORm&{mPiq+#I,ٔ,K5_u6 |V% ڹ(GddU .Eыہ!BIw\r+NP{9D v"A]}߇5}G4NxN@5iZi #(BMiCB7si%g^ާ! LTcҰt6 ^Tͷ4b3@dVnI2uwSþYFTj8tw,G#fkaNsTSL8+>fkZƖEKi$:m[Vhe;MLkkb4E 5֕B?ahlJоtWe&>`A]Uu׽`B v+trk8{ȕ3mW84+"y{^2z.Xgz38ع).>:럿lt\ֶ##Si:]$w]*|V8Wk1jdd5kʓJѵqtgUYFT|IbK*dq\&)Ǔ+ϊ9qxߊCt*I5C73u\\|{v &#'cmtaVCP4KZܬcDIKj\Ǹ>x۔OB `M s+L67rxi/T,֥wb3Dk RsZ]V;:x(.ߑK漟_f+ԜקJlW }Zpy %g6 ~|q_Jx?]`eq_>|=#{Z0E``feJ4n"^,=!yn0=k-|* 5p)h4k0uYws;AF\] (V&QN&ׅ1u?ƽ\*Q1^Y2Y8Sֽ\ER1yu.ݎ{^Jjk!cc{nr+MO'''X|4BSC]Lwi}kS ku4g [lz3٤њwg!O]Rxm5-<#4ˍ1]ޓkU958J2Z'8OI])rҩWu`$^u }bЧҼnڔu Tݙ. Su,z\0_`\lpע/f͕ч5S9@}C_Ͼ7ofg5Ҥs%Ork8tn*6>>4Ot <ܵd+@, l5+:e۽x+|[9~$nq kDu]py嫦t2nG#>î*{2TKU_jvk@5o?u*J6 _M9HLa滟xI3b@(c? <+cWwcL.8ܹ W\[ں JXXMٮ/vrCN79cj v?nk[b=?JƝ83\̒:sW4;g}jEq=yY!ms;7fer?ַ5u8` [WvS\&\l, xnJuzӦ㎵X38.:ך4yJʨ"ܙI9=u3Zc13nӚ-q -wjmrF|_pǥr:û^qvh0G=_2 (HJ8hBl'+F~l^>x3>n zPseQZ1ڥn3Q#֬T=*Uw҇nBǸ~^}sR3c)ҡ"a2:jKSҧ_V1U^[j5Q-~#KK'1|GMg\zPw޸?ho}"ݱk' v>y;FHYs*q֯Gs&e?.G՞2iv9߫UWnF t< ꎸ\:>A=Xxik$c%R ̟jzc ȷU_tW/ϊu.mCFAW ֨կ"9m <{QylqMfm }Z0o;tx՛q^_o傮y+Ǿ_.v]'?kWfJ4G/qucXyk"ƙm>p|e>-y.>rW~Ğ_ύZVϿzג-G|JJozgӥW~I<d?+}k؎`^'Ӻ'9]6+y_)ieeҺI\ƝC@>>&8a\į%yז !s./Ďz,ܦ r_Hjlc I5κtjf7S隨˒1q۽z$Emt!ː'Ҋy=k:HVmx\⮢ORfVk+'Mi­8Fa {+=uk]3a?: V;ܜ$S(C3qc rй (rξq_ h,lo6]ʌOzg||=CJ竉\Oma|aT,2yx9ju/GE?8=*狓ܨښۊ[cr腜uZlͽ=1ޠ!8SR$CCtwL2VC혳 ~j5S ڲO̟βMo? y ׇn0UDd+ kcn}itKsA55M(M]wrvv>*V''X2fc*kEy!vy=0@q Rr;Ԕ'Cup@B/Z⏍CGn{ Vޣy4\ r}+|gI|I19Y>\H"дM9Wx[ %`/4y ޥGQlGe9kDou;Hk7(]vĈ'T{+V7O0 RNOsg>_y#:%OQ^ZijTTtg}m'SFX׿1_:LjdGOٳ׆ڂDm{5{۞kK5~s!Ϲ@_V41="숏ҼԔ=ztQ8wJIRI Q +(?cͨkndU$c/yicqUxw/.y'^ͪb%+ӄ >s= ɾϿxvzƸ{MIS>ȧ#)'M` ֝ҙY]&ENX;X<9dpFkJ=ojb9e1|YO9+eS]KD2kG E|1dy{ u _1 >q^sQ_"aM5}#Ʉ W+uin9PA 7LwX :~j]&c}'jE1"tR}UHbP*I5:NQٍē&7:҇<9<(ⳛ$mǽj5WR\B[niT.i$ۭM x ftךTlFxyۛRN};lva|5W,df%ޤz19?XI8'qPpGO-QHnCNP'A5;"uk m8JXs=j3ӵ=x]짒1J̷%\=ꮁ>`9=_1V$BYF^Vy6VFE%؂1JWXªFZ~+Fi'ڋ*jS9'pxh'u5{a+'dry={VDt޺Y.B蜃s^䕑#+tSYZh،T~V{}cJ)Zf7$:׷ ӭtY56BauertaW_~x[Syl7'9o)ǡTgo/k_]+^znK$$xN+W dѕcBsxMsѹdHo>hlKQZO(8k6Nhi鷖EggES Ai$({qV珞2B3Vx_ψ$b!ƾU*Ɯ'sWQE)=zOc2|=^P533 s xI>JcpORM}USW:߂-th7 gַ 36!obke~xPH0O23W27ѿ+>=KHkմitnp5$:{WOaxǭ}d90` >Ks7-vgh]APʹozP8gҾNu³TsĺQ]o=->Jfo5ߵ'-=Qi`xS>jS/{16tۖ4g=.=f2F}?Z7W ʣ\m>}Ξ%pkеUɠݦȵUċx*xI8R_2⎞v,wy@{V6ZRG`F=kHlR 0H_iG{nWصsR-UOz Ìާ&׭6W^\UcgUMOƏ3N;W;'I ʌ:҃fMXYg.pOt ]@;`EFJǚ<bN*9sjV4ݙbe9?X֘ouևm$+GZa&8<ח[Eȩ-OKܩik/p2ls[ڶkBqNdr i76RJ13Z2`u*U=*p}ZFk܄х\\3+_Ap˱3Y'{jΆ#ӥz5R;fvVI+zd.ln"U+8VfɶeJ=FOҡd 7bhݾnA?7ַm ֬ị*S (sW'̬4X f>IFma5=H'X7gftBJH4I~ѧԀyjqҬ[褂Gsڸ8=YK7gv 5}`dV]Ցe5BiњVׄl1{;h%d)8=i^ SM7Q^?v:~ gkSo XGyhU|/C_Oqݪڀ<\LjRN{jܷ*D9Q +\ܿ}k/f5GT.'ֳI,F2x-Fu;ƻ.RAOUJI\um[m48xi :(;3.^x >eL]>9,mIWҽl.bIjuS63Yk/9|ARPmpOL.*TTyVʍocV#NJ"tc)9¾(mVE 7>X$I%9[)\5Ӽs1kCš<*)#5 M<^I8e3dV_F5J9(+g{n>r;v9nq z]6ݖUk|Cw]P:W# &"2z-팣Z*KT_,rH+ьfVݡ$ qr9D2y,9A& \ 4=Q/pAOJK:OZ0OT\7sZV"=:Ͱ9֌d$`뎶oBr[:&>g5ILږF*xMTVhZ㋫ _~!370]l)E͸6;#Pp}6EczWV͔frOzM/LX[|>mn%Z&k&q왿K̫swN3]ߜGJt<AfM26q8ƂIR*.HK? IjO#(i:Wlqs9$bAk%n@Kx{QO 裶OZhU\ן{hs+suY5p 'ֺ޽!3s>Ն]Nu9-O;{s>^_Nd9'ڲm>(e Zֲ𗓂؃_Ev=SsXids*SfߕRddO˜G=>JunLe֕2OZqsj2y>֠bCʍ``qf󞝺]|$z'5֙;Ru$ɠ.?.=4rcTmڋ pޏ0;I7mcҝlpG<^8w<7Jy9)TJE1N=9` 9_3ƐwPElIe{ x {TҔ6a#})*=Gқߟ~n]̞{Y~nx>]8'YxH= ;t#E<6:u&,@ z˓J\>f2I85X>:gҜNE.R\\c0I9"z\M`Ԡ>n?\pID@r=7\nwFWa6 q;C%9eAȑGB=–Kx'1e#(R_B-4xVQfmzcuvO{v5kkt2.־o-$׫iun+dzz]z|?(]]H%;G#kS甪foEͬ )-? x$v7V^&+c8JKQ-N7UbXlvj-f-e P}3\^Ȑ:kJ.pz ץkan׽y}bO~κi%4xȽa3:>Z?j`33Drdm=Nk׼çϥ\jJ.g]Ѓ:WVl֬ Q8׷hJ-H AEq_! *q|Z1i(GL V|q}KZa>foQV>:Zʾ)FP@#jwmFt C"kMFw} R%%q$:+5"BiAg+S5>(kS[9W'̑ ^kɂIIxMVbկ맑#ѼE߼x[[2XXyuenr3׭~ /~!Đ9pWW;iZkc;@$Lnrv7ch~œ@}%Ib88n4[GQV5 )7k{;{:~/lV[߀!h&R*p@5u%w#Hr$ki,֐F~QW,FiUc]ގXERlVFmڍ;R~!栳jB$[0BŹ6F}_YJqz8z΅qoI!H1c[+ӗ>l|^C/\xgSYٕ2;^aūXGwjAIYTW2V2V^_u߿S$a.ץFm3p1[+wEɍucЃL\ gӊcN*k֌` ݚշґ@/ۧO B5㷡/iXR ' g&*13cÖZ~࿰xX\4l9 X%]Qx us8^颍9,k𽠰Ӕd?j#,8^>3;Bp1s#IZT+%؁jqVtK[Ђ3GqHZpԗ/m))u%v;bcf6b=j=!=F2=k6p^%i^O1sWkm-A@?p~˿3]*EƏ#./M#ɜVPPw%O'kQ#bڹ@H#UsFj|mnZ']DXKe +ۜV[cXj"dCzV2f.+9L7kpy5ԉOlur19fP\tu%9kHJu]#מkZln5D#BHZ'qRjs'UaW54vUi[Eۿ>1W.Ec' ]̧vz T9yOέ/ɮi: WXz㧥\Ƽd (D⹋gpGu5 ɀz[O!f'O(ק} 0נxi2>#ErTZ&S'qVmZ:֦u^ta<\Z|3|bX"`kX9$溏^"mSTqT À$`hPW>~a;W>X96|׍v=UEw^#-ybm8} _;EX溟ѝ##qLFYׯJ$U#Z1E`>1Qb{QhN}nۼlUzխ>΋ y |\b@UH]\5={N2GL l:u|W#zj`IqV| ?^n F:uXMrTxKt28PA.ÑS7ʀ=k kv Q=O?TwQ%8ֶ^{{$ָkV哌rw3,tO*lmiP3<_n\\5̧ >cY&ܬah;kT@٧ 5$ 5U#WNke|=+P#)c;#7"iӧNK!{VEmK&!k )4 )@#мmu>[Tr9d[w~w&9zVc\%+M~_BS1קh1$)9݌WhM|H]_R36K tafIK.A=?U4CT,Hi2 gȝٻc6( ]##Kq)akZeN_zBrmvɮDύdn,9J清zޣEP)ZC Rrdg*mQxv $=#MpI.?I<Gsɯc GOX=:$cy,~&t :3X7^E\a%RVLŽͧΡVB5@K4,a :Xק*v"吐[*nN* ǚ}xG3c%c:-qAF299u 9xۤ3w=WJ(Bpץu/bGx]OB 9|ԣ>}mh{ lMJH;O8.0ZHHgp;Oz~!8d#dҹmgŲmߊ⤣q{T"ޮdVX㎕[?yZ9cƠ?q'~9m>ӆ$s~Ea9 izu:bԧKNE+,oAlM8N5pHzT{Uk~mYPx}*+h4x9Wp)c~y=ǜʟ`0򫎸7֫0Н\t:qS,4LuEȂH~^D9 s gTf(̸?7JE;^ˆj7q$,)"2zb;U䏸Z GR98܅cSyg>C#?^LW/UHXZwd Q)sb@J9M۸Ҍ*1ϭH$uM'<JB[ %Pp:y'R#<٫Bصc9<~UɏWZ>KaiĶ 49o/^RC(s:Ss'JrX)=^a&1f}IN1j}i 8/s(s7?74=ǐ:q#nCv,nA'^Ҫ3׎rG9D[GR 1zv`ejpp}yQ%UN޴7w g=xfGnf_Zx@L*>0Æ#"=4yZVp2qzWW(..n hA]垙(ӣRTI[(9k&IE HI3`UF )mrUM*7 RܚMEs=ȴ/IM,~;zO^eर\|UO `}N1p\-;{}/zȼe^}wl/Ú4݋\5 4k$ք&ƛlmgXhGF Ms/rLHAl'U7h|Ok -aYFL(c3Je&~ :_ī435 ; P}хZ5їFyX 椏UR;vwalǽ}-ÿ4S@<ŬK:!C60?^<1Y&Y0$#NtImɤ|s{cXTO|^֗1]M$XI52K^$5 .UL`H2F~ι nQ%; v ħ)tD%UYC9',jrGB{W>ng~hsL-в``U ^v$I?^3^|CӨVy,2f裃sW_Vͬ_la$"m|It>5dmaܞ/nY\L  3JWwJ5~+a*aϳ+k1~dI[2skS ?AMK"pqX:~LvoB⼖UmJ奕s9srԪ'm %incҢpsߦ*8e5oM7wJ}P^Hw<{[Ѕ JR2"U;*jfς i68?ʯjĔAW-je#wj4L,*H'j,%h]#_EU?*Cm *R0c /l 򚲥`pR.<9iXDeҺ7◀!ƑzzY]ۖPk59n!ro׭}  r=_4Z7Ex6Y${ _Qh3XpH?t_]I3d/ |I*]`5ÍZe));2Se{o$W50פk8+* B+ϼQdND#REq`j~튤~ vۄBg5_\-+|5o xN 2ҜVI휗[3#Sޠּ57Կgjd^q{{M?H\7ڙrYa?}_/Msyck Oy˅ -[×rc==kҵr7=1W `ܫwFOrwg) > * һMbc\˲@tfYI\|=Ԍ~`z5MЮTfsxn$V==kK`g9A6\^L摣*7?J+uczd#ޭ1ڢT2l&yCLo;D/2b\^iP8ҼN/C }(۶gkY񭅀zUkTu9יYnG)m͎8?fՀOhAqҵ9<5,X9Jh`x$#n JrFA4nO 5cJLvNiAyϭ0ߵ5G>Lsɦw1F98DO9ByC,,=E1$)CHlrzTe~;T?7r9ǸA`0z)C`L8tZA! ֞TM#JU>`5i&"o7ǗLi89HbGҟ.zS1SUrG(n3UKe3/>3d8rqsˊtRsy~X@Sԕ~zR䶂-,8{ r#jTREuyg'L,s헚O2G˷x4d]ªcJѥcNnXOZ5̄Ҳu{u ʖk$DZxWšsPSU\+ÌW#QsH(n5ۤ7Fk!R\Nj1c¶}^j' .᷸66E'ּWRW'ξu:|ΫX2fgiQ5W]Yż.đ?jm].u rEUGީe䭞7ZJJq>/EGF A(r (]|K Im+S<需k^+̀23^N7AzrVOF; n&ѴZ܂b~^9${WCß aдviXA߆wpODKrt.1'ufTKDEWx5Aa(F _[]|xڣ]WUO -0(KHvt-ܟzK+4ͩʱrOJ~#z 5N .&M|+F>v#ui  c3w/{EvDJj#O~>Gr-~}3^E?z] -ۯ^U?ʟGZ IN]Ytgm|\ߍ5,c+]H*y+(l ܒdclMq4=._j~Gbᮟ2P‹3 r? %(+)՝Ks6Y߈~xUғYӮ>3mss\k`͂k|yz+d0Q=%理 B/te͹0'heB󚥧SZEk)zxiבO;K+* |Atf,f@3QO4uR __| Qh=+'WMy`䵌Bsor\-MpL-R<Ȳ9֗|Cg53W>Zcr+mN[Anָs)F'u2-̚[UMJl KZj?=#\]QF.2vהUv7mEn0c=0Ea$^xVO i裰OxzCn,u%+4 as+CK{wSeiuba޽V9zG 1igۅsާ<8j 7zҼEEtxKiOo>t\繯T*s:RmXЬ+c:WcZH`<,^+La>Ѝ >}Ւrip4ˋf V&WxV#? p;{UoIu, 7r}*Ghg$||R4l/h\ 6zfmsQwY_ 5fw9DIZxJB~̡n6Zn+^rv\}GU=jm_d!I?{YYqpĤn>9)y2u@HzywlʳW\du*w¾yeԽ$A;k Y@S%|*0ȧ^ =Y=kx8ţX3A/+_:oYI:ՑH^R\e;dsZvpàڲ[?[JJ<.ܱ}.Up:?}Or<56p&rrN̖AI]Ires#njTU9[~-%Zs;Z\y1\΅,Lɷ*YUs)!$Н"wP?cpԌ$l+MlV?9)3𭷊tW2z=v.NZ~9:(8=k1ظV1^c1ȭsIQ^:ӵf^F [tgmϽ*ʬ6G$^*KedžϭYT* nqVB>F(! az`VR[\,'ZX}F3W#g桖0d\dblxaǃ$qY URm8*ƷǺ-sVly T-֍ZEeb< \)oJ˶2>ZTt+Nk)Z4K76pьl94|uJNg3@dv:kg#gF[ÎSve?#GJަU~&#eX'қWeLf idZ Rz t$Dn+S_[+8 UY5,a n9x #{#~rZҺK~h(֟Rp>T& 6צZK`^Z=+^qii6]UOq0 ϥM⛦2 n&.3y-^b cگiPYHcgb2HDW5utcn0.ѻԌY5}1|Uy.?/SP_-J:"f(+g4,pZ]CP'< ~ZٶL]ֺ0ْVtCt~xgc̥Yk2`U}Սq\_JY܁iS3^oaRoC|'Z{ul)IJ,{cбOkg=Y=ɑA1B>®(Mk8z5y*l2Q4Hi5XSIfsԎ( }Bw);8ȡA:sGOM1l"ˑ=*H騼"H PJx~9Hbsb w>Ok U\t.bvw}+_A9> TPz0Ov+CyUPѼ+.r Flu?Xc鴝ztW~3S\"ze,! Υ,rݘRn-^> jK]TYf;gm<3.X+l|}j;J~츲XxFlq]tMʜ Ip) g:½K_v[1ROJײףGUNal*ǂ=kinТTz mK( 7]OO2c)dו^$ݞj:[|0fwb( * uǏn/Җj y+񿈟vg8ʞàϽdxjTh`B<`^z+W12oN}RR|33`)rx)P|$qob], FVRO?C^Mf+]iΞdOp>9cV۹88CWIx1I[X*31^> t_j_;g'aUA=ݑj:Ax1F:9Kpe埝WYG͐!z=fRvfn@}+ꐓvo6߼H4|HyxS] s.%ĹnxM8Zp/N3Njߵ$a*̥ׯN7";z/cd8fxx.$PV }lLIv5`~^gHJє#\¿nH,z5O>0֭X,Tg Ծk؜*vƽa%gw'oԺ Օ_kщ@mzs^!Vz]"mF>Tס|C~}AȼcxD5VqpsW}Tݞ߰o: _P$4fmRI?&_ [ޢ<^;ע|z$PHcr2y^][xY6i';IWĪIHۨCtb zqT4K ͮ%"1[:_̪9l] +k 4la 'Orλp=~+k9W92g/ijxc\1~qkZyeZF+r3zW9Ј|xkIm^J bs5#+M-Ugiڈ[۟r쎇9=zgld(|wM=I־rdSh?54o{`?(+wbdhz'K{E_Z)k\\7ۤ}}]|5ѧVCRFw1'u؛'Wگ\JĹG`y>(|G&XjLrm=AڈFG4/i+hٴ]тNJ8ǥgi+EXF 9D> 'G5G0*'sSl_I݄ވAt<.=ʪǥ^VߕJXj,"ٟmQz'33\ekOE aP9׏ҷm[l<59o &C^n=/ c+5[!f y5I'ִ1} 6zT k~m"ǽm p s/QRH=+4⒰Q9Y˵d_į1=(MXG5#ڲu(2Xvז'p~<ⳅHץ|ܰN2Y7`xnZvM0O^]6Pbw_s 'Ջxm֯im;nvb)OPՒ &7ڒ,ueKoKgSs&Y; kֺrd=;W-1>SRE-"2sSx~XFHjpb?Ʀ VFr#s2>^jvUHN͵B_I7WdgVySid)ҳ&*1XbqwBj[ۧ$Ƅ8ןMH2`>,EXn౞C~bq%F{}3Z/z⽨-;lQxVZT'ɫ2H9>Ա_p9+#T*gz%J|枫c]J՘~ ?CV ?R=*/9'&SqԫΟ8A ;ȇz}Ojc$zG3KF(zZ߸$:++^Hmp3nmHMu+ 6]vBq^i-6:ҼS '֪0"\ psT02H==켸shCOVs\SBr[Ξ1ꨈncUb7Aސ<]?.ikn;r1j}s9qךD8<ɤ~^>)%yJGjTQ{cjx\ir2)qd A 'w>752s?vcoq8Ojy\>H:qRpr1N xTĈ>vړ3׃?JS V"aOTL"稧y'ONadq߭J7 O u杇}nq~sZ h՞95gZ<+fڤ訤s;WapݙJ +a"FP;s\yNhŠO@쬊>-w,:$o"/\wެwC~SU>oQ0a5)Z9.iӭmy*Kr##:fKyj#I⿴MJQ:A &6Uk'4HߨK½HEң- :If.~a&5u6| 3t>2xī,DD$`}q_Tx; *y)՝ŽI| ]Hy5QYQ_4<dA=Of$ #Q]/DvVU?/Oz>wvmۡh\2{W5٤$H۽mSQ1#X7*Ć#֥S _bp6ۈƽ#%47+9v0,۾ٝHir[fqpJݴ5vOG䁌b5{FH_}+ϼC,A̱mbiό#8Ln?OJ|5fIp1_C,4Ge1eʂyaV#02t\tF.-z rzr^N2-G,̹mq䃷jIe $sHX?ZGRZ4އ'g_K==qPjֹGO+`чNoZɗ\|ҹJdՉ`xJmZNi-lvANbo}FQp}k4=_[uMLbx ^mJiJz I/ZkGMXWc>," Zu&O\oH5Qyu0Ts^EFr徾_ՈlxY2[N9I7nִW^&G[q#tT(a[:UkNkJPxV:Oq{eZCڽ'M!gW#'&%p3]U%-ZpV>xѼ=q/&P2?:t ZiuYk⎏t߄EhkOWj*OR}q7 }9Jj:Xd(03O[Z^>\$_ Yw:yfoRk˕(Z,HVlӵˣV*pyKT/p3웋VhYk;~PNq\܈G'Ys\It.y)SͮȟQחqoeyI {:ִz+U]hgh19u$A$n=jUv1ǴWsMT\m<5"c>֧d*=pӦXj>HU| rHI&&" o I5U9ԚG"UZ7 RTf4ʒ=/[p0;_"%s .y$2#^Ū=R2#%{9sze&H\ԚڦHOZuw֖"nݟjO77Sênc{S4vZr |׍>:r+eeʽl*X*M?SX@̨Îkas;[91sWb %1Y/CW&Ӽ̓*ҼM?ZC˴&`γ6c'h;&3tC|Ck"9{yg%3j'R(Cg 9#%+-y<=3ތRW['0zZ?^mƨʅ-V5f7q1,Nx>Y;P969Hs)WߧO4?۔qߊ8O:MQ~aڝ z~,g-[KodҀqjz[ QbW;?ʓvrkFM%@tNz[q' )+Z@@wl`׊cewni6+K[Sf D@,1']ח*4Zzsn0ck}g{WZtPwgzĚfZ&m+ob4B{|G_cO$Vly_7"C] Cp ՗Qo[W#:#tZ$j9* {GN2;g}kz1XYLWx%+ۘ'1X۳E<vv{GUvʣ)KWypnI@qU?Ս^H;2yf22HD2{fw) ÃldbY-/uf'"/i<Ӎ Iϩ^Y#lQRz-_j!s׭f\nN~R҉XoZ~^)k St!f+cI08ڢ5 v+.<]&jJ4kSs/$oX3MY}&u,H$w|-ŤN ]/zf299.,uW+Oc2wħZG>nlޕGIp Oo }oz~xbTj-!s\x(JǘFN4![Ҳtm&Vcj,aGtz.c1<ag^U9%Z׌e~^{-'OҽT඘? b5<kg)S0a?Q[|T%(-N7R7} w-;^i?{~*޵'8H6OZ.Lķ˻kSUm-*ܼtz#W}vҔlj֝)TZ=%x@At5p; q,-]V^>HPArI<ᴏ UHS#ӣNΤӰ5_Z}њ=^姹f'=C|dWܒ^s_5cW%l# v܌*'pw>("ݷjWh9% FIING֔rX@`xo;QHpy㠬m [l]x|2ugF.]ׁH-#}q\$Uƶ[ OQQ6BW.)CǦk?lz3Zf7P򎹪t NV mcZr2[ R'꼰4Ex3l~I̘:ڲ)I?pWXYpHCҬh҂}vSEM[Yх=uu ;{.#$R9kl.3^B[IϭG㡍 un>j]Ŭ%8ϭuGwy#3)#4|vz p0;׋G׶]4ve:Wm#sIpW>/!Y23]s&ggqҸ4ɦr`ծm8ҷrfp ܴ!<] q07+fd8ZEx<~ {UK5#־0}kIԒOԑ׵vNR T9dQWۨ\}K(E;ғNe%L%ºcqֲ5w#},w5klXwqmkoZuY5= f*4{F݌{}9KR_w6ֿ-OՔ1#.9<XF9; Vj-E+rQXmJۧK^nힵR݈|=uPzױ36=BK\߉5<"cO{cc]2)*FzyMkCyVV@%qަR%\dUHn֯AOUmNer! R}mg֬\OLSٶEb ho\Tr[}~ \0Xe >#KY (zV(T4髶#L2ذ}s,Ҭð^/Gc.s98WPy4CtM]hy>ͼ{[S?AN[o¾RFh~4A#sێןTܭ#|S<[?Ozj EbٹQJwsO [㏮jTcf'- WsN B+xBѶrQ֗GXٕEGP䍞rt%5EI&//";[c׽q??vV3ߌ/Bk(K SG/鞎W8PQϭKu.@Ozg߭V,rOHC t,gg\` ;U(_q=Mox~͛>pz3ֶˀO=JK2Rv^F>NG^*>!T5 T4T"R&rGP-Ҷ} d]Y᫼4 x+m|lr>1x?R*==ڒw ʓQOSy@ǫ~''dN?x~GKӞ)gׯ2cMz;ϭLv1rj!Nvmm,=kۿeυj7zӌ}Myhun ++{:h4&34+B}k᰾\ކU"ݞU7f[Q6㰬KŊX-Qʻfڶګ.;6ViΦ"+p֖*L]!47OWTojy8tBKEHlw?'2gEO6yXa3j] tW￢:iF.-ɜkgI6%+ ٟ@ >[O؄=ʴ S;giN%r:^6Dtu4[I OeP(%wİ3gw?AX5ْ5f\ |ԍw9|K4~1|x6A/1=|mYe- !U.$U/+8ȮY^w4lit5~8>X$q^wx'>I|Qinxs^m*1):+[gon454cbok%񕉎q^a94VuPrʥҋMɣ1E4ŁSڥC9 :CІQd}jA<Za:Uy޷ fR!3jkHb9g_P-/aYŷ?q˟\Sn,OrI#*e·!MWRWyb95w¿^x~Ev}k{%|P9=1xcJH"Qv^<Id 8ҵZղ"fqbYy_OcִEjmrlgKG[ KkNf2,#^.@Wh\fY>f>v5 %%M./g 5|!|cQ  .%ZNl\S^'gK]Ӧ|zGſ}3V˅w@:c\_|J iw1}CC5¶ԣky\׌S/XxFPjßavQ\vPW>:WO%3VgG!]MZ$ UNeEg4֌_sKvnk +:nX^+tWyd:Ν,GeK.>k|tJ ?gl.Ob \)O|k{yߊk~=O΂,![2\"]?ZךXl˽y_f7 ˆx1 Һ爍x5N6XOEWTr:S-|>OwZX,5PZhQ-; \﹋}G̼oXcgvΣDrT^{iE SxU1z.n6IEA%A U&.O&&~9eʮ /8qpshx^NyGQ<_XYEDl2s_#}֎5Iczrt6O8M jѴOzqWꚠ[íy$J`k9AxK_2[(N9-GSe\75 3]]#'ZrladG$i?j 0-k>[ɸOBo(1ec뚐h޷I3['>+,4ŖE TDZkѵdB~#_mZ_l~[8[.>;{KjӵiTvg(r:+MMe%{.xj^>SִFBxnwy#K6"$ >x?]Bqy4guZJm9>5' V)P9̱Pe1FNRŔMr}*,s] 5hyAg9U[q3 A{3ݞw#{J;c8xk.pcymPDcӟJK(䞚S8 ZԑCaH: rμd's[j7w.*gU24WV峓ް/|=3r(6$mqɤ|'ڠG x4\܈9쵑e0'Zf%DҨZMvUT<׭hM(FyO/7)쎜5ndžM2π޹o+7֧5PWźzTtrhZ'tڸ?UԗNAL!ݑSeW)+-쬎LޠgkǃgGgok~L9S? n\>\ch3]’GhCxfOx1}+ۯ=d 9⵵ oPe?k *ϩp2Ufn{|sܪ?j<:7;VO8zW>(Xx~x_ s{ln"c$V8W̺B z$v\5M }5ோSj_>A1gg`?Qkd(x5MxT3zn0FW]^矈ʄeXڨ)o׶jҧ<`償ڿ[{~Ƕq+AmGPĂ;wlY5-BcҶ=FsڡkP’cR+[3M>ysUmϦ)b:qU+oJ.TPuLD/gOo%|oxP *2+­Cw7m;rE}'ho-4Khnk<'&kc\taNz(vy/~"hZhWv|<&\bw /TceԥDULdZ-C_QAa $=^{ RpMw7ӔػNJ9ҽ\M;F)*t'9s58:t`b2zIwH>G S6JI$ zT'#%RaQ9Jv]ǓޢZ"g~m'נ6Bc޸?8ا z Մk*Fi+V5 sUaxfWGjsy3<6ɂxkӼC6h|*}Gs_|a3it.$aڰ;lķBT Wt#5V}MXs 2\c8'֛oGN]UXXf[O:`iR:R$mX6 ?oS|#XYfֽac8h2Z˧˧hnaa_akУxɥ}ZSvGotĄ zVg|sT[!}Ğ/};e~|j+ Ms|1>xw^_u9p#{WD;XHNz*uOl5`1쵍$^է C+cƖQ!t"r[@?@rkغXr6v%.u GQ@+#E>˦aLsX-ʿ{7=7K,u:K[UAqqr哦\}R5=Bڸx[x漊x*?d缻y#Ogjh|R|R./Ӟ1Tn|qW3tJƵk;w'O\^J$xTֶ5aY{2Mg=֠]:fۋɮg>枰mu,kPi'%o: o_EL$ g$`{ S*evbbAy5SP.w5|M{>"r5䳎WINN)-CyQɍT|wP&`b>t+kkO)sg@ZxfxY|Pc=kSTνշH[|I]urʎ@3zl# jR59xu4jޥ[Iy#!ZMjݴ#5xgi %&/b,+:5->uB1%AG\4dy!NjnO̵cJ'$}#Ġ : ݲnBAx@p}?[ JjIZ1ZsLo[|Gl+b 0wixMQUqR^fFj2fyzWWmhMZdfCTpBsV|?j7hJFIPp*_ݵK{KP'mR: j5[_\HH[=~3<bho~W~Vq栒{.I'$4,A>RŠRFw,[6؋1ZT--G,n)>p ʽj1.*LN1֮ץs{rݔ{8ǷZHd=xV}q֞:Zu~@xM𿅼Ė.TgPgՈeρؾX¶dCz嫕< i/;&5h!a(1ؐwv|mhR+ \sw< Thuo_TQ-s^8׌˻'?5_>7wRK<6x|V4x֖U;q:WqloV>1WSYXenaXzJhcMFIVfyĄax"o[28=+ |.<.fUa9٫Emټr°ƤST;~zRkd!%~:W+Yx#o111gyoeKm7\3ZvF{WF_Xʚzyh{ğGKᦡ7gWjh\\?WP%u]kі=k2厮T՛61bq湖MFbej{i \Npwڛkz o_ĘNkʯ;?Ib#Wxzk}binՍM"غp=Z?YaALfիM^$Zjg] WJ"\]j-l:۲ ̾F8,ojoCʝ W I ~5*iSfIcbL~9"[]Q?Ld"ǭTPi%T3zfo1^f>Izԥ29j ]ˁ _*1N:i q]nsV]7H t\ߋ/>)֍fնd0I>.` mc*3k<bS^k,Mhԭ͜#6cHMr~',Y'٘gGZٮ0[ugldRïҳ=?35PSw7>M[\49&a7APHԳ1uIHET޼QҴ]X9Bd '5QU{D6c#kw:#F<(I,j[nln5-$Ek2w^F>'?y䦯ռ^KaYZڴnnC>4%q~Xz|}Iq^x%;M3'F2}>X9M% w)0q; W^xzҋt pZZ>scPҼ2|ҿ<)IODmJ`<隚 \FP9ޯjN-3qvHϿiuvT;s]GNdPZ~$W06r{aIĎ:5{9|)m'^J[:0xHܺZunW{e.1z>Dya+؅` ::ER~(ִL31=O[XB#oj}zmq&nqǽqƣ:pϽc^EwQʷQϥbތ R4bBx9rd޴/2yEk<ZS}zTUDFbG q|gұ kBk!zʍFF=+0$cW[UucGۏ^I*m+jtP!=`xXTS/Gy\52O[u>V\p{339ݑz[^5dT/>X9;u|{Lr43JysLyRDs7iZAFFy2*|=*xP>ǴXpomaDpr?2ՄPAsFSiu~rpLBB3~Q[tJ0tGwqZI}=7p5FۦCylznW/v2(,_ڧ}ܶþ8{iU> l0AM 32"qX8+\jy躵&uR -(Sl_ObxXK!7e3ŝ1aty8K:"P7C\8dRmzչ0qQrQT|Kc1ȏ*#,bqQj'B35}+_lum]_g>&m[g.GVc/~0 j 0 ̧YVz㦣. 9?*S]xR}&mܷzQ+vV-u;R\d=?pF$A$_{.5Ky$f,yc޾6\d$)9=+9$]8a|GoֻpTDGBg9L7pV`H% 22$qULp(2dbP:($үhlA|ku|zE @ /Gÿ5OWewGj{?˹&k[4l,Q ve:1ŠJԐ$c-CG5s|&X$^Үcr? oQ53dЊs˩s)^]M}yyC'SHV 6#e|rĞ+óQ1^wN=ШP1Ҿ~<,Oךt_ K>">!K\c<֧Lj N+kGN G8"bkTYcp[@;38(ǹ(*{2? |if=~c`@jM;_%_x6[Y_N[UqSxĩcʅ>uN_=úP拖-%l=8 B$]5rxTQZRP?e/g*#W >@y\O*$W?{ëkYsm<zkz6&^kZKus!G,XףhMi#ݤXdyr "oZŸ ~@! 8EĎe2vZuaZ)Ɵք{]gi= D"("(^ 5)7_R߿5 ިYXG=^Cӯ `gN^/~(<:|Y;QN7 C#nI9Q^6H-zO;Rl +vI0zWiைig Rx0_H8ʑޱW/{ Ϣ<9wjr&ɯ>$]jQ-qTIQđ _R8''WQJ'n?ۇtzwnI*ƣs35[<5X[hs;5+ܼڏH\($=LjzF@'sc*5cYk4O~ dj$Ve0&Le80x}.dtt;yGO {3]ity q;/>{ۤčr4i+|OzWTjj6kFm[S=BRM W ٸ$vׂ4~vTh&5{ւ|FeLltGOOZU}oKp1 Q/^{EӨM?rdlsv:^)k,Y!+%֣u?p?[yd\ +|&&nRR⣸68yYELϧ x'P"zWi6Q2 $?a%Zna,0sRjR Qԗ*In%DdΛp" umc&NB{gU&A&l tIXu,qT0Hc䟻Zf%pNIⰧFIl*[S?^Ol-ϡM/^z6o[vҺJٔG>/-Bgiҿ6iߌ7wzWVR^k_GTK/݄.~Lo\.>y؍=e8xӗ# Jjg|5gepzWZCޜ52kCLJڗ'򮟫9'& 핲xxyFr<{W'V4[m!#Cnt+g!\ٰja.GZ3e܏ʼ pD3LGZGemfPvh'KK򽑖,mSzA]熼=%gU}`޽\68lܬrPX 4L}jrڒ89?ʲS#K_A#faV@q+V$d+[Fp!bY(c)s;-؜N~ |?uh3cT|!IJڮgd}=+FԼ DռE/#E T6Z4Җp_֊گz} usb/mҳ &[tD0-+k v-K$99_)>&mF2qϥa ~󎿅rg)Rax-{rG^Ti]Y$ؐ5F+>M=z %Nŋ'~ WueX XV:UedxВ;jsκ NKjѿ 2 #8ϥji$aS'FEMzmMp^)͎Oz5n %Og\}6G~+8VV1oSԵZYAE\pC혶Nkè%:!g~SvR HtY>0' :+j($dʨN ԋzUz9j>2=ׄ!#sT)xr k22MJ5xǟڳ+t~Vri]p 3!P0TnD<ҷ,mŃҾWN ;S6*KgZ9jE@#t<'|؅C2dqWmp-,s`FN^-r}:(GC;[Y&U#UѥQvsTnMXa秭=1>)7S8^2\Ykz|Zn'8kV8e<-KÏ ǝf9 T:φb왊TpqT'Ko 1QvQ4}o.Oz&N.xHiʞ n34"s^u5qeZ:Wq{YY[٩ɷlqo}Oi =`x'[>.[A#8~wZNO2:$CO򀌶zIG.8:bde< I8'ʊe{<~%kNhh8RP95(r++TY#4/nkhcw8_% Nq~(%dJLSw{Gx:J+ >it3y*MNJH'֮\L6ps]͙8RdG#;WaG`cp+t$_SO!q<\K+]vj1ⶄinsE\:{V-$ skӴb*lüsz̙y}+vh$z5֤1HS5xz"W5u} 䯱h+= +3N@_iǧ\rJ"q5̗sַ.HYc+JPҹ/88=އ'cr?JnICS*pڥwZEt=@*Tz5"c̘sEϿZI9|Rfd0pZ\m6(I|OdOHkt=ok y+9vhcRM3[_O[xgҹ;n@2+ `(RS`.:.-s)$}V+渜ϠʫufԸ#Ф7Z0'm6dQ[%XGbSU55痁EkDw> Df!zfr+겊QP'N-'nO#Ezj&:/ MC+I!9'ҽE/R arH('Gq+7EG=KO>h-Hb_,Mx~.:7-%K=.̗4QXcdu(S"jɧyKvk~ 1auB#W<֊+xc'ľdzt$8_:xwz4pE\-4U|IȻDw#qI.1&;qֺ x0UrUBO>Q\Q4  Zok9)<+VR^4Tr*Ռ= W5tD5xͭ6qA'²7 ""os_lx?ῆ*InsNT`P("_va7ʕ?_w=„zzS=ʻmmcMzzz(ZםKƟ|9'K{mʓR#%ݳ_?|Aѩ@wf#qvI(^֦c5E/_ 0< lח'8%.*= B7c? yZ%q" ѣuq4QXckΜ"s9>yc|7Su(^4)ԧ5G4݌-Ur4{o-ީ v(V+MN T]GG]zgw\oYiJ4 >EɔqsYq9^c%i$jII4Q_OdrM%vY֭"ǐ1(*cn1&1D(['}n+ХsɲLKXV?V4F VliTx>+<&50{+͟k[Fxn@IU EWZ*/CJj1!byAvҷ'OM%djji֤pd8<~Uɦy܂- QEnn6t_i#Hw8P }~k_gEוdzQJrlq_zw*cYR _(x[)WF:IԫJߋ uiK~OH_ꖍ]?x2Zwql:EdSZ~-kv2 ݫ=S[T~֡լI1b](ly?- ZSJ*ܶp=a:F䍧J(<ʴ4Ӳv4H+h ?7V( Y0H)IP80)Y[׾|'+ƑeU}t³ WfxʑRԒn8?ZڲգqQEpaq$L4zb[EjZl6oaU :׌[iM!n4d4Q^ҍ9KBVj;}SA}°yQ[qEsc4tMM+H7Kojh!wb={QEucI-^IMۍ/[nt=ֳk7u섟 %Q0 wK*u?jul*6۔*h@{@i*Y%69qWo[Lh"2Eřs.ېC":4 \MY7V}Y vonW*nx6YxdWe^@_W7<>w^빾N'7Uu_Bƌa_+鄸be;_GhƵQ'n44.I]ȎnI{w?zЊe1ў>ΆNv\+S>WCtLJk!I Gp@ ᓵMw9%_?VvMb{/g?(-mewTR|IVP=&o-}+[w;.F/m։\՛vdtK nU|(x=\WSI+?d.KKC-:V,##>Nb"4 Pc#)LQĪXFEvd5w@٪O{Cۯ5]ʜ+?nwLXqG= Z&z+ *5bMj[aG8>F4we{i]73.~:6x=UgPJ/ےkŵwb0Ml}%M]h\l h8uGhTS5hvhg|{c^w[Y$6t%a#ª;P[hM7Z&*-euTC1rW=]8`Mw"ߎu?jc /׿ XwmiK4weU|Gnezks]v.,c[u)Q[a# MD.p 0Pc&)[=cҶҫgҕo_ KN䜟?3YtaB_ɮy{;n4wni/>:Yq}脚)ϻ&|qdRk-u=s^묳vm lv)UqmMwAgL9;~ۀƣ6%١zޡnv4kWuC;: Xu@D@`5%("T[mtNV5u߯%Gλ0}bpk%΍֜.;fΧyStBXvM^ #|ܓ~zd%XjU:R2Rł""eq'0qTRr(6y}o ~~qY`_} _ڝfJۨ A#Px>cF @(: :ڃ[j%F|N;5HocE5wpz{$_:XqM;7R?Nmm.:=Q~mhᵶԃkVRTL8^2o6^7%2Uٞt]WunaaUʾgCU'ƞ3mQgkhӷű͕tcmaU:QP @Y @CuJeyNS>W7pzl+h}Wb'C_<`TȚ M;wz9T3o%RY!|4:uO"N埂)6wwI7z(\{MCýGM敳#}L4t ڦ)28 ɵFk!eMTVG(3@, 3PlFbwyDY1O=z"wH+Ț;d~-? χ_yuOhЂ]/Yh˽ T7fWYGyF,8_ ŠE Hh A @+BH[z{߉=z]>NOM7/ -M006uQGee#1e-6YY ɮ>jYI.>%)~9nQ&>sSHj(2Y 2A]BlW9ݙ'KnK*N-ldqGه?^} EyʤP;-YZo$pBb \1tx i Y3LE$5A%vE$$%4g\g{>b~U݋gYuXlaqSu f;iXH#lD &jbh@D0J.:3Ci)f}gx>52.5+ 慧&YHz6X5ZwDzHև+Fu`:Qv2 2&SpTOT@C aml]| B<F: -V` %1pY,| ږJfhlRb8M$WWkPH@4aJӰv+.{/t:k_[N ʦ%~qN_aIDH؅2uRsAsA:Sf l RyHUQI`!fb[ e$@Ø:14 )\ jЍA@2怦-afD= ^WCxf,Vih F˲D/0~AN]_u%2O;T$Ys,3e>5֠g+L*L 6$W1 cHuP|!kQgTMoDg̔:XZ p> G`98t}<@?ЌkbaHwi!m@m+c [Z9MWyATUM1[V`lQ\>703ؠ eTT8_Fgi* TSCh*3u-3:ۄcFӶgykEs3M*Js[rvX Jed*[<ރ-ridN9DR jqք$oN;MI /US`k`oeMt5S(<! &6h#+i@$ H*n$u@ 2(>KŚ14 Դa9 Xƴ8&埶+;$Łc@8`َ(X{W6{}zӖM3k=U*@pP\w5oO@C?ݱ234'6`Af9ؙmN'1\7GMm1FJzdj РJPt@Xl!;X`ɷ:G,1fzνq`Gѕ6ϙgda`gaFu:|X4skw^~<.UaW B[R^IlO7_2715tn7#̇$ & mnbn1Dyz rXЦ,xf3L@a 6᢬ )>0#}8}a`CNCnJhj *fWlPM`FtֈI۰;c~M wOw=:mE"EŇhRT3bt0~f9 nܐKeyMܡM~y1)!~_Zx #țbN7R0ÄYc-0&H#CBⱐtKTAT@g ecL1Չ0Y4{_ *y\-v`ʶ?R7<9"4"%̜a@pr9x`G&SA;Xܸ$(;$CR*jT6jyg RbRM؁~okjnB06S26ŘM&(#RCsPZ IC30AXWqt1d7^0"{_Ư[!b㨚 *\>*.sK# ^`$0E Ca?ip#RCOT(3EKzBa- bf3p{@'Q GU |V|:e;C,m~wI%"hZ(NOJ'E#Ѷ\_Tפjppt&;qִ^/sY?9>(ďMpQqq#:ؐ)&CKefgB`1zl$W dl P[@࿀UJcHZ p|mOS(+tj/!Rngpa,]eAKi$Ob- FjNH[yn|wn縗]2vabdZ>& QxO2=66=8%1{wcqLLC( Б_<3/oe:%X b@*H2axjtT363- G{ߺQSҕt$MMgb=gl䃵sC;;x8\Tmm 63Ú p|-`!L*F.:ef}ATETA2yFcU&Ht Qv3'ە`&`ذ~tBuGYH $gS2;HC!.OO'Fe#m阮 w:zf`LSƪq1 !O=n]hXe{ott;\ZL qƺX6ڀ8 c k5x'$BhdJu8@tc k gmn󁦬/!HB!P\JH&B Ru3$UHwmownn9;94gbK6G88b]T\ D R0(}\:40L-KɪP#j3rEUCPQdM$裘X gjLq"ǀb\qU*?/S^X!Z&hu{n'2mG:6N l>"_]5^F~f%@Gd'k;bؚJz8c! ЖJ6S;0HxBj$XxjT@M 14-܍7;*"5edž3;|}!/J=Rh/Tb Z6LtL~.j?ifKFw~9hlp|(W4^?9iZoY46`hcPG?{{Ë*2=Cl?c*YX,0fV8R]Iб:4z4]Dg[J4X]өԑtm)DJbbJ>JHN*?B5b5* ECK*HZ̝(?=Mk, . Bӹ|BhHvh5m^ɞg.0cfxMKP7ᩈoAF0(52 rYL@_p@[ \TNXZC҈ P)3#1]A Zhm'e5IӊRU ;sBHXArlRhB^) qbZ9j⥫k笩d8_>=W!, s%өRI\X,ٝ?pɊOm,7?=1>Pa7$A].l+ Ai!$R@&k`в Sl 0(A&#tMT4gLxvhx7FFڞχf NX IW+de E>$K""W PBQ-R %YDTb*O<-RӹRQTB:O<5W.^uֵ Y]cvT=߁m2{c vHxZMLxuA6`4A m獰2 Sr yhM* duMG-ؾ nUHWI&4ry (E |@e+y \,Oˤ0U\e*y"xt"_23˅8d|"K>5O!]F0#}z>־X`{(#wVrrYZMS_9xPHdL=x%Zh|c=(leص7CrYTQ/ryL/̃sR:#e9<_!Iq2yD$Gdx) 6!HƓSr9bTxlhb؝3Wmki޾[7xz2QJ6psko5`6/K%AKGtA\Ѿ\_M^8HrL;4mezCBcpUx,4Z( \er\8|.< Y-ˆRqxG>'s"%#Q8X2'NO͝;5X<5bRxͧ[[/m.lp*`"ho{+@ J$3hTY` 8#<#a ԨBf\v\ O<56]+ȠҡxbyE.yzUA. ɪ!i\ZA4$SE2lT*MB޲~{a|K;xw|,M&A ddjtxzjjixG{>u1i1+n?l{c" 4E MUyj1EZay 8?`rP O&1$K1f03K֋}xWx/s˜dzV.ϸUdBZ,ϕMϓҧ2ld.$["ERyB,;{,]֒n7q7H12K<+&+F)PAw;x__mYQH&zUhQle y 2k6j4Oϧ.Jb,ODU0TjUs+W8/w)u//sMٵ7*d5t1$/Ph$K$biT6_&*& )iX+FOɇ"l':_nplY80K477g;u_XZz~y|JH'qQ(bRX>\; `sQeZUe-sճjk95K\kˌ|N>$dx4P1]$S6MɄ#%nZcoSЧGX|4X> åֲVvsl0fKES} Ÿqo?qo=Ic?~xw_pkR2m"Zh3Q6iHKUJ K#hiJ*ڋ7.e`mR~hZlfJv2&Qe\Sz%*eebΗLI0d2 .!'=EP| GHG]%G_r?hm OL1Sk;u.ldjO߁/^!l!5 \@.yf}gJp!`B1zFbƂf;nfWܬlEaC.~ IaϩbVҔMۇ|dj|L.*O0S2*̗͒ 'bb$-~v[cS{+ߑ{6Yya|ʢ,Ӯ7o:?9pu{dGj~ltȤUIKM2_9LMI|Bl@9η\%t)CWdn0^KoISn5G]7 +Uˉ!J( $<5 qB8_!,MfJ'R#Y&x ..; LK ĻuDD۵:˸|z ,ɳw,DҊ {7"ޏRVm.F,xNsL40O@j_%.0ZsΡu{NX5r8hA7Z5PX[ZC/TΫ!}4L-+NCR\X'#!_XD0> 'X+NYN:(Z DG""LG:*xQ`ere2o/?bᮠU6E}QZ S^Dخ]EQnNkV\bpIJoR@2^9V+бu 7Ro < ߈.G4&5ҁ ^@ڽck;OK<ݿ;_u>tw-v;<֨ǯ#emIYT#Qp/Q$8y#5c+cJ|R&ZRuN-էXHF{-R.U D&+o972jlxB@;sCķhqa_1(ѧˎsnW&oL > v7h^NQ#ö-62-z60+1>Jri\zl``|Nv~Fo5րj$,QYB6PS6ӛ)g-çь_9g)9b%,BԪ5U#" 5' +dO}):Gk@-_J{bD?~އL]p_'!* :>b-9">!$9'$b9x޸7u߆\Z8dz?wu?q< c=7aUȬͬ-M : 7k%voP?gj|&RJlr93gV\#a-䚋˕B!D\1P\F$M+#Bm17AƾL &L= 2M^:/>;ui|JZI%@~l+—ґpWԢwmîEPKn<3+VŮP9o7?g;'~ !~-.jfV#!R('5mVIklOZϜ@I_]et+Dxan@Z cHI$ \8=z͓3ώ{nyҴUWA'*GDG\jL|M||NkVzL@:W>8Dq[}Kّew+zG2m̯?d_l*~dZ3#k+F3i-%kZ&zqk)QՔ% SVrp7.O׊a9))_ɽ9xNBӒid@$:}GOw[oW`_oHCD:ӛ&6қa{os a[MpWQ'Qs=H0l!%ig }Oooy<4F+D5f)6n:Qb`NӪY+&X{e-;㱾RY?@oX=>zxujOs6/nkf|boϺ[֡\ C ED> V~}t0Ec>k q?x/:ķd'}0 lJXZ,\kϭu~=7~keyK ri89˧۱G|D;!}5lw:tI(:9ǽ޼[qŵ[ uҵ/_[?L}U $7OZÝmAxKoC+'k{Wfoqu0/iG 6M3&:rXerirP$AxpmW_LzywySsN z}1Fqnv aEN|qC}.9۪ay>73\J9(͔-Gv;x9U}$S'{ ]3@ T&/{g F޲D:xbڡ[wu xlxQjޢ%ۯxλn4_ 8DBC%_tB>W!Pf6{`&j8 a}(l8KL5 u y:qBld7x6G8[6(3UHA=eLIjbemsɱ']}o[}+nqk͗K ^.#GD}n9Cw[&8cub w^Cu(LJGO]Sw!̵&*ԮoxtcVL+ $G>0q~ne j*p-@u'}H`@@ *뱈*eFJ*'S͙&/XW}A%'J Ҷl,oDΫ֧_/ezg vscI?wN1߻B5t/oQ{KVYrޫu&y2Nؔsl^7c%bѯ.K*V̕˳P> xUuU^]»wv>vj#lF@jYI@+X4o1Kl+GJNZ4\~cw`Th۞[w_3U6uAF&E5U V(oa.<ī8i]yʱM.Uٍm9;*؜yWrNJ#.ʃER(Kȓ* Df?[9p z= ߍ9]̑IX|'BHVUr5 (3Q"h$.Yf65/iMGM|^lC+CNOofuQZ J0 KMevjם4=[rƨҋN'OZ,;X{Ƚtݢl0:bߢ&7*ċgJ~H>A/&{>#:h]_λMvlq=f!>2}$KZmb5TpA$ RRG䣻 y{+Ugtw7PoE@[o/^_؛hN$gc,ڢF5i-!Q5}x/~97]6]kD+h4x$~8n˧_~%95auէN?vStuۛoo3H/^zۇwFk}{H2,ABX-92Y((F~ wO|}/?~U݅^) |>lB8$|N@h4uK'{ 8MCqH  H(N {e2!DS4xF<}]?{%ׯ#M{F{> |/:5):ۏϽ:鉙8±cΉ/o>ݖ?<IENDB`PK !/44word/media/image1.pngPNG  IHDRYv 4IDATxw]e% $@!tPz" GQ:rEATTD>A LLz!!mR&ۤ'>^fz/{o=$@L2k_OLvz׺۞K%.@0 ` @0  `@@)(PI+s,W,eԮiohZUm} \a.ا6)}ӂ4%%?n -r?-l}68Nk|PU1MClPNmv_56vuBm|5×AO62x:_~wk ZN, `j֫R*>b FijO5[~k"Y V ΧJ TBղ C㼲ghY&[Ei6Qׯ(!M~E+iBU ` KˮH_ sm3J3tm|}5KNiKЏ.%S_o+w俬<s>fo>^RO7AQ`0@@멳e99UۖR䤵]ly6sl1 `ǖZ o7>-f7k~voofkxRëmzoϬRBu6Mzٶ gnTE>b@tlNhtq ^:_aUg(ɢp& `=ʏfyiV1'?jX B4-OT#6Oƻr:^1?Ѻ*:Cp)g6vlͺ*BPӥvtHmݲ_۵xN*mJUE}b@Psvj]w+!^3GxFzc窮!] 4W-564]C0[Y}5yq CV'Wjh<$$'@Ѹ8+1inӂmuoFBB94ZYŇ ^oEvMո_ fy WinhƟ@.=l $Ѩjdv.v)zS[x[Q-Lvˀ:_I B@W$+rYg3L]GZoPm5/3@tgQ:+x12B8]b-ް0 Ȧƶ)̈́tx5[G$5:Rvh^Bܸu82MzYY;GĀsmշ+{iJӥNy\S՚7;( }=ڤ)U| ^L }\>i N._J WeFp說~剖h|27gpo(}&0>Mz`}Omɏƫ]qc x]sA9[ #`r,9dQ'1':žKٛ-*it D]nj.8V;eoRӜ5tSX"@ d̲5Ukl~-8]ɯ]a|Vveotd‹>m]'mfQ?>hXH#Zzξ@q[&a;R[EEg_N \aOAsfI{i.RȬKuRX该v}Km59K=s #`R:Ux.^qʘC#E+(gucna_.<mg:_.r2A{R=>FM󬼆ӆbi&_Q `Pe)nArn̔ˀI׭y@]cTSA@QN~;#6EF>ս@ |jk"Za:휢nנg#Yp4QA(k#O aZo'c#L>)eY ^gTXϲ[F1u?yŝÓMm}sYFmGl/i#zem>X0\q.~jZ" SgFȧ&vqiG*u2Fl`Rhk)}w+㻼΍dp5JAS_QU>wĊ?-vw^=NFkƛ4ߐg_dS(km xϡB+xw MJn'paHӡVYd%4:v)4\ߞFg3d.F},W)0v98GiO5L#}Fa#Pg#ds6:j ;]ƒ%]8m.GȐG( Jr 4"*U 8B*N6|+jP*  4D%mS<}R6;B G5mIUJ8nX_"]s-O"v5o˭c&ŝ.d,{h6& |}O'v'|oi)J_2Σ8uUv-Z?q}zܠ}0}zX_A;J-9'w3F`z߆59vϱ:MK$̀WmUcO&xBMzU(Иx)?je7T9 ]Vs;|jƛ_XCO|N\3SA.c gc"u5Vlq$)<dgA?s*G&C0S5gVU};MV0HgH>-i\pmRAg> `h%:mS W.R,@5bT혤-1E6~<pݦ^bP2'KJ4 W&L{CG, }uU#`@or* 1/9U0%Jy._V&; ` KNFg2;˭dFFR_RF#`@>ᩳ|-KD~MaR_vfۦ0}VsJY+Tо#`@>b"To3Z6 ` Wj+9pǑrZvRGupgix̊H̪n,DΟyvN%T]Wڠ }6$+?{cO:V{]3׶qjB: O_ӹ[%5E ϴx"htAq7nf`ͶM4׫6c5.ӡUZϪq}Ϭk+6 ~Phvߣb6>5ե uG:,PPQV)-ܯvC~:xk~;KGܣBh36g[B_`S()VaOM7+"n61Mz~vef?~YV~ot`} `(>ĩe0О6=| 46I\9NۘpdK4ueoni6ũ^dwT\hiʫ 6wMv~6䈦Gve?7y,U*ѓ{>G[hcYu7=vHu.:j! ^Byޘ}I˜v͵WtM{8;mO| P.KP%QvچA7gE?-1ԣڲx,n\NuxmɋMWۂhcķne~2 5=*q&P.zcPեg^\!t8OS"s0|7AWSSaf v欿nF.͋lHEG3׫CKJc83-eCĔ]7b,z4|ZJ7۷J};F *ɌI#NHc~ r3yfpNhI3No*;H#29U )NVZ}7pM&V$VuY!zF؍G!)7sEQЊWdi>VW'?e4&^Pn BKה֊L~OIhLJ )R_#|қm@ŝ[+ұmAFu7*mu99["|73Gr[_ gD54*^Ph;i*mi~$\e^81s7gXOzѿcJ%.lmPƟY]uh_'oϝǼk+5ȵQILYw;i+mr ~s|n;j䇵}Z`0xFst~v!;X[G٢ި*sx/}ĖwoFAMҬvUo+wp'kҔ?dƶgsC}_; qy|ڻ߿Nٚvn#AJA -O ϮP#bZ+6iYr9~W#rCi~?i [Ug[[i)1,R6y'f13 n>ݼ@{>{ m_c?a;]I׆kO[\NMz{#Dgp㩭nJU%ŇZT_x9ץ֒ 8mD'N\OuFs>nsK~|H ~6b-zr?ەtd˨l|Jvu7w yy-V&RF{4Ipɴ^׮p w3oGx ~U9?l[zͶ:\[ H gqSLpp<>LV?f !囇FUǤsW #`r6 g`܄0F8~m8YpF#QW¯ u &0F@CG dk #`p@)>D0F8u#41!`0(Sy[SW0Fmc+09++09ώ||< #`p@w@Rc%0FfP,09b0 `ps#`CgQ,09CC0F8 E0F!gؓ(F0 `pE0F!g+(FF0F8P F%q($]iH#`MjOy0F!g4#`CN&40F>[D dEgĄ0F8d(L} 1!`0(ο9i#`CK]&bHۉ0F؆7!`0(׆<7!`0(EY( 6nB#`P~ #pNu 6}6W!`Ԫ({CRu2槪DޥmX ǯ yK )7_v7#`ǖ6&#`=WZFW}\΄j!?~]߲䀏#`.:_ǯ : I -k}5)`S kG'f`CNӟ;ڨ,i?i#C:vk'#( tI~m9@sQ~FFk4^4!OC8\Q=k1VK]Yr;$@ѴkpR_B~ +6Q 5(e[\A; #`%6MxʵК@ $ ȁ[F!`v(Rȵʝx괼6E}-C.6& `Mv{,U|JbŠiMvFQ&=l 6GUee @:]߿ai FQ&B ~66k)wViB;]EcFnmQk=v!`(>d+ǧ꾱 yN}MA8k6;\[bVU%YKUR-|u^6|F*`ke} *7S] v nyh:GRcR{h[3lFҬTW4+M}@>w`Sh뀀+-ŞXlXSV `.ӔߡR3Q/הԯOR@dm\AMzReٴ{@Kj4wQi/L?®~ ppTQ|تQ?Ǣ0-UŇ 袾^Y*<_)Zݓ|S9;2;UsbUǞ Ɋ?{<#V\y*>Ĺ1,cM6BulپQqʘey;Zc$zb _nч\Ũ(V$3 `#s߀A[1Ta>v;dMr\@N;0MK3vUYʺ]\`t }\]Vv~R{P&:`O{}wq6=F`GG4+:3\@Þ.Zs*IՈۢX6&{싀VlT>[F񜄚s<{ky"6qNqۊwnn,G֩X3x>f%!dٮlNG87u; sa\7"Iap5.lEZjxzTeԠh:4}x:sZC0g}3!b(I/6>*r}6:#^?[D?8(I^e<<"mfakk!rX? |;X ei&o$[yk\T53"< fNM^դN _Kߵ$} .h'qgke+M=n`:j.CJZv,/ty. ?ηd+Ҷ)nS߻lyp\; ^]k j[}RU173dioN{|KSH8hc4LԌ(&D3ߴӓ RM~u'ٗq8 y3 zS2pJ=ӫ3|z0]>m:fspH\O|>ݳR\ z *ϖ:W|M/mj E%'"őgWSΓ✿G?O#~8 U%ʘ=Ǿ28 ;璳 CQ?F͍pes6ʶ7fe??@U>ɯ J(-qS8 {Š>>m*ig G]v@O~vG;`}VKG-UZN-P`d : .' ˉd8jB EJ6Urm_,@wP6d&J~DGvF."gF=u MOCV1I QF!k ӥ2-druȷ^W@H3~M͟UT!Bu뭭z.W1 ,@n~~|'qD۬Y.KPЄ)˵)G$'niJag}6šb%j=n XVf-bmaH4?pRSAiiK5uǷFP9[YocZ/;EK=o9+AֺR EKN\kz|W* AoQ3@ҦgI)q4ݚк֜%`g(/zfki{uE_ZkmR?kvМJ3d̴f6׳v﯊B[!`=`_t7kkCVE#o,'mWL$ԋ2J}BfnHJMh1#M1aJ044Jl\Ro׭gw%{ܝ^mw{x$<]֊6ECc)c?HJSˊ${3:h[:Y#NF!`2mLVϛL>y-xF/`3 hq![(TЮ9/}~Y#Պ:&˸VlSծ$;}K ~P ?T @!6=*:4 w gҝOTyˀ>7F]o{+7 ֔iV؏1g sk5m [Q pnq*Vo8r9sU0d#n4lQU1]@~2fjIF=_A6 Q~]w-@7qmt4]S4m+O;x(fB|_'*RV B;oނ:Zk_mM찦MK@YCмwmV"s  ` 6Ʋqgr\p򘦼ee.P&Qm%c3ʇRsM*/ATs rۦ6z. {B/K:*3k$A})UЦ=^SU~vF ~Hzbż:^hxTs%޷Y}Pc4Wg-]ӕE,Ru]0 & +U|DG3ŶH[l} 5o6*tG>!j9o҉]lǒtOJE&?Kcn^,/i6|@bEgӅ٪=*Re\0 q t%KT_;(aNB,Ӟ'uVX؟:eVÄ0 ` @0  `@@n ۜRIENDB`PK!0C)word/theme/theme1.xmlYKoGWwŎ -Pqwf UpT*z(Ro=Tm@~T- zcTߏ/^3tDA}۞22J >5( 6CNd tY9?C K-j>^eb bj mg>9]NNkl^-Sn ~},t)cZ{ʳʆ;faKvi (6NP6l.t-e|zPh2Z@x) Cή8ߘ& U)eWFe;\`Md}up<kxN˅%- I_TS 1x㋧ɽ''~9+8 TϿWn,~ Te೯ѳo>2Oc"urx 9x=~ib' %Nq*'ѱpmb{^߱>XQj[=Y MWI.eG.ٝv)4-mhD,5$! =>"AvR˯{\B)jctIl]1eRmfjsbKl$Tf.Yn NqkXE.%'·.D:$n@tKݫz3{lHȅ9/#w8uLH E1ʩ+D!8Y[X~umߤ,AXJp'la^1M^ָΝI8 ٷݝl;r|^o.w]F:G[*Ѕ҈=# BPZ%/ZWr4[SPpbQ4DBS d_vY-ye>S+9 Guk=MI=ϝ1u',m^x0ѯ*Kөڬc-7W~զpMA 7>oD eK1 @l1Yec,9g ]rqo|dGWWKRȘ?Y|pdh̔4p)L>DCPK !ܥ word/media/image12.pngPNG  IHDR?1 IDATxWw'31lB0D4&09{QgV3x\^k߇Rw}j]_v?~رcG=3y>''NLLLMŋsvT]Ў2=k1hq7=ro䅚9HGNTl:uk5ٕ"䜟~i̙Ϙ1#+dZL,)U#s涣VaU{MݛRezjʙQK'gS6m]#ϤL1MڃLϞ>ίFo}Z"lGwלiwԎQzVLo(~qϞ=uZȾ}33knG-Ԏ[>dbs<44;_cں>~СCG9ގcǎ>|xttt޽YpYP Ud^uڿZsUǦ~ѣOxիW/_|'OR&eT?~d`<d}O>EkHɮ@s\iGWsNxYY>Ǐ?#kBN@Pfy=um[g]蹾S_>~ ݻwۑKϴn{\۬hRnϳTZmRg?rR&tk+hnNRW&d垣*WwQźoj}d 'YT3gLMMrxu2=źORܚ5)BwߜMLLt]s0>>^N>}ڽeX>BԨSkC-QPsUZ4=.oOFXZhqoN~MQ])f i5"ޓ >~<_>|ϗ<_>|Oϗ?=_>|Oϗ?=_>|Oϗ?=_>|Oϗ|||>_>/ϗ|||>_>/ϗ|||>_>/ϗ|||>_>//@x|?/@x|П/@z|П/@z|П/@z||||>_>/ϗ|||>_>/ϗ|||>_>/ϗ|||>_>/ϗ?/@x|?/@x|П/@z|П/@z|П/@z||||>_>/ϗ|||>_>/ϗ|||>_>/ϗ|||>_>/ϗϗ<_>|ϗ<_>|Oϗ?=_>|Oϗ?=_>|Oϗ?=_>|||>_>/ϗ|||>_>/ϗ|||>_>/ϗ|||>_>/ϗ||ϗ<_>|ϗ?=_>|Oϗ?=_>|Oϗ?=_>|oq?*7IENDB`PK !Yword/media/image4.jpegJFIFHHnExifII* (1*2;i0CanonCanon EOS 5D Mark IIIHHAdobe Photoshop Lightroom 4.3 (Macintosh)2013:05:17 00:17:40Christophe Ricciowww.g-truc.nett|"'20220230    00001 245 $ 2013:05:16 21:55:082013:05:16 21:55:08X@Bf@B2W:02203100055622EF50mm f/1.4 USM0000000000~(HHJFIFC   %# , #&')*)-0-(0%()(C   (((((((((((((((((((((((((((((((((((((((((((((((((((" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?͊:tGZ+lqՄua$iNԈ2%"XET(V:p RVӄud%8%XGKՠ(<չ,uNX-3n2*\<7 i[˜TN64LPڜW\5TTHRT\BST<% =)\,WFʴ#ˢb<ڍ\,T)HRpP4\)L)E2%\d),Sd*%DEPUZҝP:UJҋt%hȕZD3J*VUeJLq:fK݇5w̎2ko&zR jJ+^+Ӯm'kьycj:jRe2-LMdޕŵ oM UCSE6R)\v@FH$担AZj w N]ddTl\,Sd* qXPUNIҠt*\eJ"VUZw"YdZ"Qqts ds\M|[LFM,ks]^ѣ*/P uIv=kS~L5`?9};Yzm#ӊqZc|n9s\յ sZ0\ޯOɵ8iV/9$s> c5v-BOS,u)7jji|YZ|w'(2Vo= Ͻ_g^I*{ws!mJ%ziF+;C=izf[VV{Uގq205UHg|*U85)s_2} jvkxT*X氭sQ;zֹ"Ɵbh,1ly#=kFsZBI3l V98#Q^n5NJzڂLیo[OuW8Ax859NPA1os2k_’A0ĜlT@ʧo]N"/A+s\Mңݞyj080 "{LW10^fWԬhp{\.!euo_.?nޛWRA'U8Ϩ5({+;3K{\䷻IM5.Tnur_:Yu;!>I᪌ՄfÝ|ژUdTpJMU?[/Ǡqԁ*wU8(Ovj#֪ɩUǾ}jڛg'ã]LAZ6YVxsDU銍}Z HO`ߩ0Q_,{7|gƭ F#Au\ϸ7=t𰌷ҕY4g_k<օ娩VVؓWSP:I15LrJ=Z\pӼ;]M$AOqܝ8P SǙNi j&m,Cx$v橫ڥF0eh` [P2+-ثCҭZύ֢HW,[[e8fKb%jJBB*ݛ*Zt(F:Iy1+¥FTy<Ծn"-S`4ᐫ޴' W?wsVn*Hnx {z$ҝ B 1g9feWQIMcVivJds> ؏g}X% ]4n >HbX ޺;/MEޫ&4>M7F#xx±NuiiVg_+${\GD6k&YAqkq#36p~Wq]sufң~koq{s<,* Ņ B>32¾UE5~aUHIAGZ0j U)^⥂My `OөBBO֝?rh.b:VcU-G#^O=V|⠚:zDȫR¼yDWuZ\}VP~\Y0~zN$@ɕu;PHqSíKDNDߊޜ 2=[$H@C:dMXeo1KʚG~Jc#*xnK#GXl \ :$cRZGJZۓ?](AtRPewqJ+аF8?^+nM#t >$ 9 =¹hc&\>;`vg:˕P#8E2=~ME:Q#/ ?y*΃ Kt \!ʃ;UTYpA<{W\3{Yv:!=Go ^->hY=^Ayd"2x;WOKq/&yUƵ{S1α#'̼uqqYcR~߈ 审R."+^AjI-a*d'V Tsjs+SpjlwUxT9fT2Rq8,a`#_Mi+$&GPr+Tܾ (m@kZ&J{ V͉ 9r?i1d| YsߏN*ԤP܀\'N Rf;~TTwHTqZq5IӚBďʠc_ڜsUJ k`. *2qYՈ."5NA 0eG'5)~LpA9SJH'r_S_4LMO&7z҉0:<Ϳ1QU$ި4jxeԸkCO^jޕ\FqjIo'cY_q5dv=RD#K ka%* #=jKK IcH 3TjfFV 5d}kaHr@)U=",u٨:m׵GOjfP$$sOTCΦ#Bzlڬ.3M>ϹW$֫[wJlXu,:_.UpFӂA[V\`՗$08UItLzҙx{ _jI &ィ_AMD qpv aJ2zWa9T%y*Vɥ+p$SS#U`iXE~jUTSN VICHrMTWsN/KE1lY@. iRF֧GC=*xUw( XuzhnH횄>j85M8ʂ*]ENFI#T[{cjng5ml jǗ'ښcmfpi"e<y~BJ>Wdq[QsP}@1z^`D\A.)T*2Tޚ$ Ӱ@)El!Ԡhi٨ԄH .ꎖ$5F)E 'GXI*R8h _zf#gjPN*ZX+.2sW!'k6hqG U'hf9Q`&/ynUCNxRjH4R-51pR._gW?zC2i[A'ziJluEJj1ӚFPiԔ "UV^j iQOd&Photoshop 3.08BIM8BIMhZ%G720130516<215508>20130516?215508PChristophe Ricciotwww.g-truc.net8BIM ^BAdobed            s!1AQa"q2B#R3b$r%C4Scs5D'6Tdt& EFVU(eufv7GWgw8HXhx)9IYiy*:JZjzm!1AQa"q2#BRbr3$4CS%cs5DT &6E'dtU7()󄔤euFVfvGWgw8HXhx9IYiy*:JZjz ?-,x Ŋ +X]c *X*GbXwbWzXޖ*ыZb*ŊhqJC4XCT*CIe!%I5D`B(yTqB&8B!# *⪫(TXUE^#W*.K~*OwVF[3q2ce: oq(&ߏY)/$p#hFqQE"6pZ)lmic66JciJBW ZVK֕|6T{kMm׫817ckHy%҃0)AғJ0қH1 $I6QfE)8m_󺜥za S;QdaY\o-pO})Wڏ_ m#|r88gYgm~䄘0^M0Lf7Z)3Fhci`QsqĝLTbG? M2"xQz%eW7F:df('W-iY- j0Ur֒JR \+mM-pȱfh} $eZ4F$^kũE$v#1g@kͅ^ZYJaz΃۪)D~Nw_ xT?H{ƞiRS@d1%d1~}i?*O⯄Ԥ՗ &x𖮮Hebq Q|r6 oW(U\RiJNqZDrǍ) oFl S@oG#T4Do86o1(u]" mP3DHXnoʇzS9n3 'o҃,)! ";W?@f1m MiX<]ir^+u֍>c/m]9-X`z䣑$k?́GQl{i]mо(NؒJAJȒBr6R-#mu211d= =2yZ'q+l1pImv I4?pTtFө j|iqz)n[G!IRsSn Iʌ iSEZkhiPY0Sk- *Ԁ9|mAP ׎*(&l*XWܨTa"b԰UQ]AQhVݸ6𔂋( 4Zm O‹E2%6夬>BF'Q0USքa3 Vb"9k0Lc։'~.AN09S joMwGoM3 0G'c=4n_wPjZt.ذP@4`\.( AFD[pc~"Ih5rF 3O2[BnrQ;9~MN:=vC'j1jHeesȐgod2Z +C^+[Cp(h~ڬk!: h[f>Y8 Cq0-Bh)C\d[ćþa* SQsU\4U8J feZKQ+VOጂVH[WֳȧV=pj5&24oVv5Ho6`w@[F̣vmȓC(5ki^vSM.ǐpS+Dׅ޵Rb= )٨j.p 6Gǂ4R(ǯjg7łd6Z} ZiV$z3g8DtG[5r]Z] !-6o]F ɭ.Gar=ntՁ쇫 eP>&ERhҿM0o?6u(8X,g}^XPZ~흺}+%PBдrIIBwM2$ZmNmIF $(CZ7B6Y*~ ]4-Va7ӱUf;%Z99Ƽc"c3/ʇlBYwlAUcT RS\n:/VW'#^Mi io/GJBЛX[%!|5g!MMJ#(:/p)O٩Ʀ2sre fV6d廓`~C5zymAD2*_] ) zk٣qdHw+y]OwuE&ӑ3ikcM5˝Az_P"j,}oL\?b?[ZApǻ~3yv*^v ŀC^Y؃֙`n)nUvXڮT-2{uJ_p|2i`pJ;崄)?~F*!6d~?Ki\ܩ*R1@#݄A3|/YGH\!W M  UxuR\qu JQ0r4YetU* #*~=497$**+wG eR'f>Jufc[G}߿l|}:CPU|$;&vd%ŴlfP~0;P~-DdEcO֣rӔU&(I-iQOdba-DR5CXM)C&!#lj< AOUg+-IWC&(}.!8}' UusimrK2 o8B18S2q,SkrU&+9"cӌ{[y^%fFHe4ӛry_]HdVҭhTS2SIJQP&2; {)|L@) *NJA(+,;v"Sy$凒6$,rj8ʤIQ rAPQýz*U$G݆Av%I mĸ)eڙF=ȘZ+B = K2`Zh=FBc4 %HTHc"w5~Sĉ]A)_6QG&]zAYA]0FXELRY`gnu| &/8AKT]gqz !-8COZfr~ -;HUcq~ +:IXgw'7HYj{+=Oat 2FZn  % : O d y  ' = T j " 9 Q i  * C \ u & @ Z t .Id %A^z &Ca~1Om&Ed#Cc'Ij4Vx&IlAe@e Ek*Qw;c*R{Gp@j>i  A l !!H!u!!!"'"U"""# #8#f###$$M$|$$% %8%h%%%&'&W&&&''I'z''( (?(q(())8)k))**5*h**++6+i++,,9,n,,- -A-v--..L.../$/Z///050l0011J1112*2c223 3F3334+4e4455M555676r667$7`7788P8899B999:6:t::;-;k;;<' >`>>?!?a??@#@d@@A)AjAAB0BrBBC:C}CDDGDDEEUEEF"FgFFG5G{GHHKHHIIcIIJ7J}JK KSKKL*LrLMMJMMN%NnNOOIOOP'PqPQQPQQR1R|RSS_SSTBTTU(UuUVV\VVWDWWX/X}XYYiYZZVZZ[E[[\5\\]']x]^^l^__a_``W``aOaabIbbcCccd@dde=eef=ffg=ggh?hhiCiijHjjkOkklWlmm`mnnknooxop+ppq:qqrKrss]sttptu(uuv>vvwVwxxnxy*yyzFz{{c{|!||}A}~~b~#G k͂0WGrׇ;iΉ3dʋ0cʍ1fΏ6n֑?zM _ɖ4 uL$h՛BdҞ@iءG&vVǥ8nRĩ7u\ЭD-u`ֲK³8%yhYѹJº;.! zpg_XQKFAǿ=ȼ:ɹ8ʷ6˶5̵5͵6ζ7ϸ9к<Ѿ?DINU\dlvۀ܊ݖޢ)߯6DScs 2F[p(@Xr4Pm8Ww)KmC   %# , #&')*)-0-(0%()(C   ((((((((((((((((((((((((((((((((((((((((((((((((((( " }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?S>|H< S xRJ(N)SS@(SL P)@RJ(@)RJ  pR@.)R@.)qJ N.)R(.(;7b n(;SKn(;SKn(;bb1@ P!R⁌.)أn(;bSF(Qn(;bbPqI~(3b1@ P1F)(?bLT3b1@SF(ILP1F)31I31F( SF(a)R@iB(2)i)TEFE4y)a*B)PfEHE4iH4iddSH@M""E!ꈓޞW1^W=GL5LTtzhR*54ɱiML&MHju5Y Lذ"*jU4%QxD))p hP)@S \P8 @)qJ-Z(RqE Q@ \R)ERZ1@&)qK1@ \RR▗Q@ 1N.)qK7.(R1NqKv(7b1@ bPqF)ԔR@ E-RъJ1KE0Q@ bPqF)أQv(?RbI~)1LCqI~)1@bSF(RbLPi1O&(bIm&)أRbE&(SqRbE3aSȤ"B)R@ "~)P!RbE!)1O"B)R@B)SHM"E!aO"e4y"i0iB(SH@HEE!m6qC)1OSHC@ "Ӎ!iRm4y!ihӍ4Ӎ!HiƐM441q4M"E4"i 0HM4 aO4#4*B)P 4y(2)TSH4iFE4ԄSi ,҃QSժoTQ q=\&'I[FFm^V42UdQ6!zD2Uؤ#DՉoYIVz3&jT5hEj#TIqZV2Q,bpjjxjbpiAR@Xvj,҆V%4ӸX3Q&isQ4 4j iӁ% D 8@J <x4(4@-0ZvisM( QM@ )š)ElQ_,} QMP=MF)2)D5X5NV,ҎJ ոR!b*RV4RUȥ#)DيJj9ke#'^9*=eE%ZI+U#'A^TVJ=_16.ԊI^N7҇wӸX (X))p=<=RSRzpzEbzxjWqXqXV\V-TJNd5<5V O Ebjxj NX @N R@OS@VSR-J)˜)RPh4JiM&Hh 1aLcNj!cQJƣc@lhXRi\vjMԮ;nuC5 SSX585@CT Ӂp& B 8K3Q J EvhL.h(4 L 3Fj=ԛLfF.5]&isQf\DG\duGuLњ4fL!jvi S a婥piKSKQpiKSKQpiXijajijw nQ-EĄnRnԛ2ԛI{Eę3u&.+f5Lp&i Ri EÉM-M-EÉM-L-EaI-EFj=na4њwfsIwfsI.iBiG͹ W˟F:MNQ@TԊji:R+S$VcժtziƜrU䬸ެ%hCFRը1ZFn&RոhQ[FFn&Rԫ%hgh JIT.RKU/3ޏ6ar|_2yy^)JiDs)%ԋ/5!8 %HY%JU) ľR+%z^2-U҇qXR+%z^buV(2;l=<5UONh5<5UWZ O UV,R)"."ʚMWSS)p'SR@S@-blh:IY%XGL*QWU%HTTjw%JTѪtjhShb3Nj RdMVCSaMH @S@NJ(ih6ڥj zޠz=WsSUޥ,jG5 S[u#j*hS 2ԋUYVtc x޳4 lf@k+u9[_QZ8'گtpQ::1cXDƾĄ\v1hE;k@ EuoUVRGRr zaz\'/H^>Rr%@^^`'/L/P*3%,Ji`-oe!`,)Jd2Q.RיIU_2̣9Kw1%(`.o}UI0roG0rwK}RzizM2RRrd>RzMXM2Q>RzC%U2R(RϙGU|O2!r~e8IU.R7_22dص[}'}VF8SE8W{Bu )i)hQ@ p Q@ 28`NR+Upj."ʵ=^b=LTEz./+ԡꊽHV-z]ŝ7Qpc}(z5 EzVb=LVz=NT-JdzdR%Y*HU)h"TJHT%Rd4i+ԪTi}F(:5Rd4^FѪ5X%mVcjUZfmՄ5R6j CUPiSUԪi:x5 x44f\ &i qTj64T/S5B ޠz+IU2Ui*Yh U2h ZsڬþUsFQVZ8Kv+ԚxSwРHX8!ANlSp0s\Sv&-x+CN;Sڼ٬՞0gmp0=VFf=*YJGZVyLM{aRz#g@Z$8$*p(sJV*QZ"aS&bjL0܊N9jᔑ3ۼNAֽ#R`KErZ@99˕O2QWF&isDyפ-sIwfM!4\,Rzizd*\Y2S XM2R)dM2US%4K|%4Uƒ0K&J_z>RIQ*KQ\2LHL2Re&_ziގp/}Zfs)|GYw(p4'giDhygg-/ygR((RIUO2d'4U '.a̔%U2SLZ2SLTLi}s)lM23-4K|7ޏ6o50q/iJZ2\KJ_2 i|ڵ"9Ke/T%Z.%22yy\@)š)¼cKIKHaKIEQE-8SE8PZAK@4h QN& O PN& R+TӁ2½HUApd5;uW N Eōԡi,M5C\p8jzWpj.+Tz OMEzR+) z+Ti}^G**R-:=giѠV#zG1Z H:5gFj7LͣB61gj6LYmVcj36ѵYCTcjLhju5Q N%5*SN,)P) 3Kfh?4M48Ri1Ƣc@Wz@hJa4) E&ۗpXqL*\ kHD{4ͽSxNo~E_s޶mcJh-p<#UJYKY3،R؊[tǵ0J*[GSUm$``64}q *c%)qy9)P"OTUY1`xq=Nw#v8jRޣiޣiisD{m/Si&ާRKQLLihRᖘfF_zcMG8Koziިoz9ÔfC}SCNiӼӄh iZӄs)C}󋔽jHe9KZaiZ\.iZd)s)m̵U49ejKL27ޓ&ZO6 %%jq4%g }ER!ľ$U%8IZ)^=<ʧRyyإ+;ERQER(E:R!ShE8S8P1Ӆ0SRKQUJ\r/U2S s&ZcKUIG0Y2 X4;^gOz+JbJ$BJQ%b%!J9bK%/O,]2SLṢ̣V-yJ}ñhL2Us%0bijzv,4%W/L/Jg̥*7ИX$ *PjD_Y*Eĕ"Z)|INjU[h2?2d)ˊpr)E@&)إ AN'zQKJ.(bF(.)PE8RNQ@ZpS4 x@R Z( QMHb))E 8RM .",hpr-E'ųD5K 4l~nO^L MI*P:1w@ >Ր,%3V8 㠨nmTW\Z|%;\sORB¨$q[y\*Y~eq*K&~&@m㱢9C)|9 ,n;Jj znhZ$e5 LzL-G5ZMͷ6: Z'$9K0P:zjـp5IWZg6')I~N|LFQ1\Ә.j[v9$jHFjjڡQ;T, +PBY1Ufi*eZTfJȤ&Za)eO1V-)JR)sŃ%1JazW 4=D^^bRzF@e20FZZ SwTe7S]nwQQFun w}n];UQPnL,L^^-M-@X1-L-@ SwS Ih@uEMЙ`=8=VJ2Z- )|ʪibђd p@ v)@fPbR&)ii@I(R(¥5DH)N)RS pRJ.) n(4@b P)ؤ1(  \RK@61NAOSRQE8r`-U5"B)iRj@ib>*OT?5JDjz'Yp\xHՅMY0^hHӉmY5ZhɣA#UڬFղfmejS+U܆!jxjdJN@uE\&j&j.; \4O5\ν]Sk>Z-ZQc,ĨW=먳P`cZGZִ1}kV5,Z?h]ޤ7pk;NRFq9I>KS!fVY,xMЬk˰3'~]eR4/_8_,S;Pz-vrngZϤ-/Z" uSbcHG Hʲ5_3xT:T~uBn>7,6/M+?O(қF*䶧3ThpS( 7&qYI{Hq3n''|{,庱 p+*7k>G\ȋU tjʼ'p<A*wE}J8t{ltEmGq=u(-G9 o;Ooxwsܓֺ?U!^Z]nLGG\0s+؊]tmVY`^PXw'opNExH:wMQ,hݏCҽ ~ ]wћ93LcsR6{jq\5$fPN 4IvTRnE#9iR$8q Zc]1BsЋ>{ZƣcJƣc]1sOsP9lhkR96Z#vj-"7jڝ#T՛ezWjdh&zkBYRCJazZKoRn2R"ԛ!jBjij<0400L-M-M& ZZM4`8i4L&i3Ib4f3@f4њfh?4fu34fnuG3@nQ444nhM&4vi3M!4њfh&L3Fi~7S3I`Ii3Nؓu!j4p)ؠ xKpb8 P)@pB))@杊拀b)إ 5Ki)iآ8 P))\bO p1R❊F:pSbKpqxR⋈(M (+S "!8 p(ZpQpi٤"E4lSZD՛ qW"j234z ^B I5Z:'QohFf6ެVEjZ#Tբfm᪲<5Uɱ`5(ju.wQF.+jjƐW#[` qYMǥqu7ѭʰ哸s&Ck.C,Nq]6D'8BާM-eVnrMaKGe>j#Hܼ^ޏ.nҎztFb| *^ΨȎ9=hA#l͆ G°;|7c= z^24&-z2)UmNi&[8Smcǭ}2;=-[򙐲ԞC Ysʟj cT`IA zV3Geݛ8i&^e=PLmQ"-8Onpl#$ ,{mܶA;/-L 9 ӌ[|ɂGL+0ڣ\;~)xV約;@&)v:26q @l}$vSPqc J9$2XDه>X{Wyqڼds޲٪K7Hj5}:j'|ll3TNխ5L Ci sU ) B)@4\d&lC=zO]_5q8w>nE,3ʚAq4< Y3la#{G9P=ϚJE/Z/ڋy`S[Rc^%q2(*xr) ",J/ X$on{W'm쏘!`b0hBr[3ê5xنr2+~F/*dx skB?)B z RX]LM'C S<(V_ՕdQ"1B(F \7J30 gHUKr*eGҮ&3T[hk5mAjm@eA 澃P\U*-3j6z̤/^1bM;qQw,+BMv-Kc٩XT.BِRr_p7k-+5 qN"aH&a3\C)IaqKNi*VR+ aC""jFLC 'zv(EbRSMIie.)qF(N[qTb<G%nOlE4b@*ZtdiHLzugޣ)1I+bFp =\LUplWcm¡*pj j%jsV,GXCSCՅn*Zl⧍Wu>7R˹ 0n)rT`ьZ'j9@4FnP{8w`b_ҭ i߁TF*#DmN,jd"h[@qQۤ>* sYZF# \y=+42}f'Q@R٧.Zjmq[? RLTƩed g8$-0)^w Z5*Fiܙt"K?mj˃~6,`ⶩU`-#=+KJVjKX5vѽRyغ9R^~HaOJ}Fa5Z Z Jvޢ塰#ⵡuHw&9VĬ{ Q}E$b_`(Vc"h)C$d֍>%R]Η- lJ L 5}3ezTLHng+GS1nLY{Rbi"HO<(qF3!,ۏJ(m:Vƌ1o|[PϚ̓f^g暌$ W/ .sz^L5jvu+(MU|2G#B̎0í@s]tCk1%q%y8ӷTdbuU4M!1[&l2}g`U}՜ܻ.vAd3}̽)DeI{|59nyv׭<)3Mfb8"hdl{jS`Z#UnhrUpy 隷m.x=j x}- iCvLr*r=j䟾 IY=Ҹ6 I! rM@VQƹ}iҾAY$dV.Z1i9FA& zjzC[S})H7֠K;fCR FEXVR$§V8j&-v9)5")sQAcCHb6HZ!X+2֥/Y ڞ}j9Bh{T2s}t>+}kB3G>Ս*h[)xaI+6NZBk5[ջvߵ{$+AFOĿn 31¼+|6ɔ$ 9'.+p^ /2*!fmDӰWN1'> x47@u=RKBH'ZR4? aHwWh e6mSEz+}< W6⎌Ֆ+ԁx!(J\VS\+";m $, )Ks(=*y֗ O]~Vl[,P.MJ98=' +J&a r+-&rr2A'' f6@ikrA^"&7R :sQM roW!u`5yZ7eTb1HgOjF3q֒:H=+vq)*H˚p]2'Rj9;fFK>ݪD3ޡt9Yb})=$i'#cQW<.# L9J<Sɡ?4ai8ަ4SH)˜LEF„fiL5@53NcMjQғ4)=j6h51>b m&x5ir3͠# jjHeWa@Rܸ5l pJV0ix7 EBVvODji"*Bi4 SN(c♻Ppjsm!] w !ȫ ʼn5NS&(y؈!jmBi;4uUSsS9c.3r)a<ґ5EC0Ԫ~B)3HhzXZk:;V`UEZJqZ,GJǸSD5͹cT lbֱqZ<+y6C rJGmBj|߅K~AW8V6ޜvV|ވenw5ɫwXÜv |8fKp:IYßnS^=>ʼn `Vwnm6W@F*>Q_:-죩|CQhQ@yqD4cNM0(9o}Y!NA^q^q.a^zJ[n s Ðج9Oq[Ku `g8#k˄m{*ޖ"I!!8+ZwZ6djQ~E8E)$=9c~z{W;V4\$XvsZ7꧓X:eִ:卑>Qɮݔ9m=@\mS5s;o&{$,7u6h5 g"]wrs7mEc94-JQ5̓G0mZ! sQV=j2yVk{V0AJ{ k }`f>r>9V'q\<#ߑTf YN&ٯ[s;5z 76p(̨=9ǰ|FM95q$+Ds4)SAud`)pE9JCDWvL.~<?:ߗ@z7jڌT,>F:⹪n/ rH5FBTV"(w5;+TSzjjҍv*j DJ&ηZ3ڪ(vg,0EgY 8o'ρSDJˌűi#VLjZ@GD#ɧU芌\OMA]AǐG'#P%J{{X\*QRdž5ŘrHZ_ImSF%K{vw +ys.^~ NQn/i" HT=% TnƷu %oI:{U/0څ'珜WFRP\#MV~cOKb!@:⻯kO5mPGA]!7fkED{Vx`\Է9玕X :W cn&Tؒ]h+nSҹeRz9tur tJc%}Gj;4Vq],_LZl5:b`ʬ0zTra zԦRwJhCzWYR1Ӛ'U,=+/!~º0nGtrڒϵyI%^)ŒZݓ!sֽaRmԩ]{(ǠjZd1OY]Ek^ 5-3.5:1<7 G %zϛ-;"ckks!ǩc.8O+?oɣ7Sl*b9o]y7WCK\fWs^,Xd{׽Mij'V+AEw4Mok5՝]f]=ynN5b3V-ez9 6+(5WD'B9kV`CƭsRMMglށ,qX(l FjNNށi4O5@8PԀFhA9P1i!4C 9jBy KTRjWsM19H5H4sEHDNGSTjTjq/b(FPL 2Z0QUq^֮\ >kqY|MbaR;0 dTw#. : Ti lW)W5 !lD*ͳ jsɩPS TU6@˟d#*bRk+Y ѓDbUl@åeF7"nTV0<f oc[>SnȇTU\ Y#lM5V@NcOEۚȫ )QQ$G,7rIBG!qB%9rjdQPyZV0@[k'd3CNX)+a<ɶ5Nb']>e\,v5ҿ'ڲ%2mVdMV+Y73##b~GQ-Eϗ(j)n𜑕Z;jRrc'̵)4UFODYʤdb9W[B0Nk̴ŵ s](QR%ѝI{Y~* |v;7`0"Ud1rU7HYU5[|68r9,ovIMP*$;XZ|M})e+"E |ǽzh@+.F\mvH5vk}hm@nK|9vZ4 <\S(xܑ݁Y1Lq\^c5E7rїU_*{= &zcM41 VګK iK^Gz!92dx1(1X7lNf*l'*ޚN:՗PA"?&@ri$օrGޚ0[ AV})\Rweܭw(U Vs\u]˒Fzc%qҘ ,-M'jhZʞJ0Ʀ|9ܻdNSMF[ FRiL >hFWB疬Uc)yoHÚNE@G5)4Vҳo6ԡ굙r]X˟qNcfсސȦV5yޡaR&ifvix3R/JvU94yR 7)56)1o4$1INX*ů KZД? ~vwjJG7ݪ"*]m|=LJT~\R"b֡QRH3ǥ*Go-uyIjX{RL垔3)-9Y犸[Cq"K )Tn#nDKfe.)`oTRcMKk.3ҷ{3uhJ|0ψ֢g*OUnjA!Ɖdp@|ru+RsTI[SN[[-ª܃ZM NdsҰ̾+qUs穌*TkrsVTOqȉZoR .]rrweXexJ,W,4/jg̞jt .F*;e FGz9H?QȆ6B1YI6s:-Q |x uZŚ/.rZ7JT۔9'V6&cYW?%V}Ы7VU'͎+Ş\Tn4Ĝ{E:CSi=A87c]ZC/P;֪ZK Seu6p.K+U!x,=WN=Mk6 q[Rx ~+ILmװ &^xiE9FFvhm$)j#ʁr a\)Lu睈-6+:j<j̟,b9+{4C$Wj`(* W OZRw`Har|e,NFqh_L^AE39N;Ӡr_.&vǕk:3&(Gд[f]`b*5a]OsYS\F|˂+. 7;\@l$˖ }ie*+e9*affQ2mUY"NH52b\xǯ5jCS"G)ҩR6xx Ap5y i%PKb9T.Cdҩ5"0_ʻQ 'm(\:@++6cV )k2NmeuE+Vz)~jku@&q+Eȸ ߽gcV, nF x *6)hS$w 4VvZLFjBǭDMN*Mh4uQ(@QMd<&婽jdȪҜQ$=i5p/qU/)QUQ܊yHF'֪@ Wf?(QU'vAu0R9P0je `}dAJlӇcw;#(XjiҀ1X~zfJjomM&r.9hFўՓjw\{3~X4RRLmJEjϚdR" 5Q\n{;aEjq(#CP[Dxxt M(慤)(@=*)$A5#iSȬPH殴[tRN%T[As$1r{")X@Siй?xX^i5GT$I槓FkN?Upy#./:ppX[8?AZ 7μšQQ)TcHJvvSѷn(YjcZ͂y.pMgN-L5*EiT'OzTuGN:2*TVxԞ)w9ҫN* і G'VEhےFGZe[v@jȨ8RE:CPGNF±wؼ#γ&]ÊVmO')?;EkkhGpjA o)+8i2] VsR2>*LvMzҽNrcUUb#:T\VRܖɥWj:v,Bz{=jkxJ[~Tͳj+h##L[ԛ55l["ڂ.dw,*uQ =)Z, ))jxV,  ҘIcҥF9n HrڢS1&Tsҫ`&HUT:q j׳UGP1fj*.ucQSk"8vXwv ' W,̄¹J4ۑ׈h5f7ڔ(&n^<ǒV,,X\w56ic}{QjwV4Sl>p+,@_oNF0T!)SvV5]Mu-[A&QloE,jN휤sr3L#NJq;B$ "`~ `QIJn1jn9=ثK2yc*jԁʁVH`&RC 3\.Oi K ٭GnY TJ@XϟR~lUpeC( ^k[ *Ԩ1T|ͬqV2>(}Vb 1Udc|sT..B+HeqY0LX?L`rjIE-CHϙ؊c[XeJTm-Z#ɩKW} [ n5rcCl u'#j-r=:5TQV!o1 «T{(A4i1OH˞)qLc]),-yД?yi?95 Pϭ=1B""dDW,gZĊnfR֭[xFXH!q眙1[I{l%ԦBsT$9ՉsUڶBƛN`M" 3&"j.bH5]@WTDI$6iwS)1$# 3HbbʜUfsWLdLESH*GP: jL1ޓvjq)(SM\ӁR$4isHC4isH fis@)D <% B H $8K)X )ˊx4-<*x7RDhاoV(nidEU`yU4"@Ҥ5Kw4= ?vEM^]n*TniX8WH &84Kb)KgBR`&-R+Us=[Me^ vE;w][]1$?579'"b z!jHԾMBjk K 5XNj֦CK9ZZH"SJ {r5 =+ MXՅn(hf38p8tl\60rr)۱h< )jBGz$mLCPmJm(DV *Hn qQ2})P8"F#)\11=jO4OjhJ[5YOj37˃Kj Oj4r).^\Sך,'bxjyc''#Z:=KV50G 6YV|Z[9XVn:\M)zǚ_Ɩ eE ?ǜ\OEa'omY-un8ܪԉ&H5NMYG㚉f'' wҳ}z)oc)3NEP|H5zhGlJfw}2cmLP2sWdՆP\X!yyHI rqȖ gIANWfՉ=*%j1CM*îW$g*KXT1mFjV35vRdL*og2Aqa}R\H`zU楉CIxcFۯJҒW0QvGm.LqU`$pic2 VQo[); i#t=jѻ8CZļ2GnЂy.7ՏbYe2Xe#4qQ1HC`R Iyr۵RPxRrҨd6@Zǚ7̀F49)sRd*W*g*Q)gA4TnH2L֣FZvqJ+jg9MiT{V Êi] (HMHEԀMnL 3MjLHniƣ=jvi !4vi C@84I,ӳQf,2Mz4`%b !Q,=h-M4xL4dzT`aQEnHQERQ@ EPE%-P(K@4&i3E-8S)s@45.i 4y) 484iX  ) !&4f0Z@)4@L4~iAKVejvjԬX Mjhj @Ӂ)ӳIviY !1Ҟyh<ԫңxJzR qwZ`,~F+y#&`Ձ)o'&Z椐/zj)iԪX '4@56#2*b P9Zzi4Ґ44fNJiS'5zu5R )3GzdxZ`0ɧM a^i8S@@5(H09@搎h5!!n)INL =MBJ[&iIaz 74ӥ.yJN{5I,14M\sRPRCCO4QH*)ǥ1iǚB#P RcfM%KT*Qj!֤5 @nV4SP9J Ziъ/5:^j^ci<@EDG;tOzhEvSqV%W~//}=7~7Ї___G)OyJ/?9y3L?q2çrʧ>ַկ~ы^%qcG>Xy(uw]~rǟ_׼5{^ɟ+_7x//{wqwa~,Gx^mx3g{O~>Oxɬ_~#o|ӛ???׾k~=z׻Ox FZ3 /}KW[./UO|"<X>nw8e/C27G,ףhC7:>IOzW].yC:~W/;˿Ї>~}y-o?e`chnsO oDCO%/1k{r 0nvvr7M؟= &n#sǽ>>qwww@ bBh@q|,ٟ}#>Mox^Wx*ymc=8=~Ar;N8c9ؼo 0`C"7QO{zi;^rGOxA7 싹3Ma:OZ._ ogя~oo'> <;ηEp017 i2 >c܉~OǝA{/`t@b CG4mDedrc// _c$'/Fٷ-__B __ HvI'w'Z.x_}7b#AZw?{n&- >?_~ń`"1[%.x`u|fe[}[݊cS0Fl >)fwƻ&o bFCQ@2mrŻ rZ1k,r3 !#9q9.ȃ-$lï(O~ &q3X5O;|+7կ~_; E !'H2pצz»\.Ci"1Ә>{G|< cޜ ]`_z IDc5|3 ! {VsscA>%p\tِ1ߚE6ܠ^51% )Hێ:x[[`,K|1y׳cZSn?7AaYԍ}zhmp l -^K)sg}^p_1l !)r- X$uzrWS|cwLT7x${ D=B/G4E_Y rA; ɀOd腸83җtgf-HX3M֠>ӟ/o,#C/ ۀ ^e&KZ+`fO Bdr8sa (D#.$!@)9䐃>̀p{۴tE4Ƀ>QRlO{hdvn@H2?S?u衇p yӚY/tšo\pE Cd»!LfS?7HN~||饗^~X N.vD&HSbH; @*S\0, =~ " ,z6-4W7NmK(yڊ!7!IͿh^\(*̝c~?? !?묳853&/C !~G>K l؎uˁ ۦ^B3o1D"@lF'Vclp@V{ %~B</ݏ`4I7 f7['fz }9S9ަL{6^~ĚPs\@+ahTOo*ٖaz#\p;|CY%?!߹sW_?ϣf@mݕ9,":A0p^xi=yY&Y?DyYoNC>ѲiZ)c½]bBT* 2\y!'CA|["_7J) o7=\I$rTj Bǥ5H5Қm4v^(` ݶmve RX+@^V@77 10ieV( 3$DYCZbC@Y !:$l;NcKS'ddF?f==pJCd`fF )}k/bc"a =o87CFԤkDlMV 1jc@l$ Tl '][0OxB'>kba) |2d!2)\Y>kon") E7s9]t  H` 2{hjA]+(+(~*m#p?A8yW\{k.61W`Yvcx3Vr1ǰIh#b$Eh願 $Sf,^Ghe401bVV '@T^tNv*J4E COɘQKc/G+gW6. *@3`jޜV&?].K_uU۷od/l ʶ %wַXt%VG˅3 8s#)1;b`Kɝ)BQ[9s#" SDJZH$ڵkǎPgdV(DJ/^%K߷CN QdkG2øfh V8)jҼ> zx<\Mš6UgnԏOd_@$-? K\`k O r|p?ҩOF 1ʐ%HNP@rhUD dÆQl,7n&›Yc:@y,r3 83΀="!phtJ: @8icE1px<ȡ^KS@cj4]!|6bA2cV7K˅R+X.udDΑ:h' w֣թO ˆ2o|#RTv, &CBMY;r_rtF-&]./Vb܆@o/L^@t?:U 0% =NW($ 7燦-&OpFb OS{6궛,D_pgNQf ;C |ni 3~LN q?5ܑKfӀǫH8 @ח {AEHg1+[dQVA"ZROWX8HV))@nI J~;L*b6pHNpϢH6g;VW#AۆFdZi'k2UE) [|BƜI1h\44eyZ1_P>ony:˃ &A ԧuR"ڭ[t wL/d}ǐZ.o`YI#a;gGcAVF7F(Ks80//z- Aà= -X./2vFjt܃GQZ=E~^/UCc➜9e꿳6m\JZO)"*h2V>G3l ws՟ JC5w5d'^nX9+ypުBy96(  x/s&(I@|^Hpd,e8áuB9r̸bR؊;:2o />"`lǺx/cy{ǚ:!QN9o坝n挟r$[s=7,P̎ƬєAl ͉[.T=1h} jD@H l [gybqrln|_8}'EQswRkF=IE9 lN)Br˶kj/z <й;,˕ cb()X e&,nli̐KDɶbtXAF !͠tIz kڶ7dLK/%Y/\R23 I@\>@bq,HQ$9#z'^Gx򂹍t1캘@6`&@^>(&Hg(;hb,r->ju]0Afb `ڂ^2uD_h~6q#quZq7Чh Ёǟm4.=cu5n)`btZN ]XN61_,/XD"p7"pHY/6kL ZN*@nDC 8f4W ư̌ ñ%2ǟigXS*q?Yܗ* <ݗ| 0φ'Ʉm Ex<'|0S(nN]ke غ8)'޲ RTA6rX0V`D(?@_\&ŋmSETZ:KN2#` \/'z0D}rB dH7vg |/ aKxVFY{W;C!mk 3i.E)6j-2vR @($*iӠ]Jw˖k:P \à[B'lWD #%Qbsy?v|iI.[܋q5@bK?2cskNx|r>&3 [.S`,/9L=FG'g Ӳ_h>|}ӟÓ|وX`bJ㗫@8P:459X(X(7`{ؚ 4?}Z^1r¤:434HfqVr؀TX'~+@FHgY쩐"H$}A<.yCWy ೖ"`Xsgu^wJ(saܟAQ%srBNXμmѯ0cep 1qxENWz!%^{ˁn)i=hqs u%6X^ 1HQ%Ȗ{ޫ\9Y䓉A hg[$5aB 1[43(6qA)~pJ-zԌe)8Vd-q vbV={ۋ0e2'>ʥRX= ||0r'-/6Dw'r1s mO CH ̿Iy˕.,]< 7gC?ᔟC3I'/W΍x9`XȹcrF$(  ho (g^t- /֚^@('o9ּ9p-" !I Xgw"&Ul[)a}f(/ )ㅋk1FR rYjml2iHF2)䤠v{,פnrv@׹yO5-%h d4Y+ڰg2o #Ey!Fu Y)CɥXb(QЍ BMvyUtH TrPԖhF[d6$Yft>ވ4/s7,h2.u^DAJ40!ɑ.3rvB3s]D4u.vm/U3sghzg+_! Nn_t!_N-"9~Q._@h⎈ gchH*f3N$NJtUYlqξI Esy6uYddLLLX8[XbY5\?ޢQK0aB;0 ʫ$ E*ƽݭ_-O&'KB_3u]>x!$-JhRy@TJw,M[͘0EDܿ!CV|?B6` 0wH9S Q i3q,fFpd}ŏ7.i|ن|H@ag njɕQYZOb/+ضm9s:9a9u]&"~q?V \vSbPH|@VrLAnzB &~,a 6g[audrB 2ЉRrR'ˤT'dbXsI sr*…%9O;2c MtQCC&ѣv`@i0s̈k* /;}_zC8[ڐR = >?3DkvMܐl:]cQ|d9r't&ɥ;:ͬ>hT++H'uK..+W×bDE jI2`F=lʔ4}A1Ps\[b"^.*~X*-{S"|fd94XJ+ܸ\pNZWC>bC>l(r ݤ=-6Ti&ؾW;I/+ԅ$TUWתhņ~N܀[^NUf3-nmm' d1g.75ǩC*0`xM؃l[Z#eu9ޱ\du2+f8)*_Esn8R^ £~Aۼj [,,]ɅTUKK(5qmȼ7ea'ESlKn3_ݏ9gjw_\Y\aqm;ڴW+ `#lAjD*ϒQ*I;,~Ҳ]F ,REkbG̙зaD;O8M:u~V>Mn(zϮ QڟTAuPOGK B)l{U :GIBGc2\o9sNRPu "ʬZFcWN3KRUQ`8y OyL2qHiUmAs\a7^Y.}ruRNBMu`RZ×%]q봺ůf$Bd…e eT =e7$SDZRsyjImP.&EV2Kɲе 1Hȯ7ZZv~re&U2}xnt}ޫ-e?_f? OҦ>:X˔c+'Y4Qj#Z*DSu*QwəM4&apKS^H ˃.߬THIs:c2 '`Fdڳ^V@Rj b02(ɹw潽 p>,R $fc–ONK%ڱFš/naW}@ Ȍ/m۶Ű 拮kŮb<(f1YZ1 uFByT j.Ƚ[HHN䞮VK}L'DA`^*RK̂WYZr:_\7ne:qW[MI_(q tL` xn@H׾x @1"dMvEX(SEny^"3wtbu@XvUҔ_)?DB-"ZDzE ʸ'rT3,/5bJ9u~sY !8mTy{W^vel(ы.4V BrK 80SeIKAMT{Z'b圝?wEFmS_B5Af3S0Tj nC=2i52 r3V*~KJ7$ȢCrϳ b\/$BVZi" ~KFj-tXǚE͈LخS5`Ra28./O) b1iQ`fʶDW^&+f$C=ݹ~+}$$ODJ+T~B*n1o(]Е||rM٭Xk˗̮X]zzZxHT )L '׌E㖺Y,C坨LLq倦>q|{ѷ"eRVcdUm*El)EgT4]CG(3%ZQ8Ou~7snx~$YA5o+־ a\l4܎;o~W&*pT H[i3Cʬ˄1PQ1%"M)ο 阢X3,="@jBx wՋ`aՐR\t?ru-LZ1t6(<'*T>Cf,qyj8oWv5Y%^BAu `b6dV4 x)!T(?"PHFɐĠ Z"7ɧ 'yL"/RUˣe3syď'|rF+FTrr}߲\(6,^$إVڝ-IA'NJ*Dzd_[y]~MOT u`(vS3۰RNvܹsg:X(Jo{>b``@#$J͐(%Tn0JQ+gL 2 >ΰЗ[S% &sUU^u{r (Ø-gn oqRgv%Lڀlٺ-KA"aK[Iҳ(D";p>fO SjN4ZgRgU zm M 3Km{b];L(t2h+FUTՊUMEֻGl3U@Kkx0H8rdz<+%SqZ6 HƑ@m<تC)]ƺo5 Tղr^D'jakU |OQ6{P*PK`=Lm2Pjݴb=;|PM<X/=%}ۦ ct|HfMVM{Ug)絃n寡@V֪Q긺%cXաo,*j%{ۡ F)zkK`2(PC (Qo g~D FPM{7Yu%=VmV} c>ga0LᦖZE4;4UZ兂aZۈff T)%Ds0TjW( {R[FΆJY*YT9J! Y~_wK~}\[=I1Jy*6=3AF{ k*f @cd"jTڽnv%u~*R s!N̽S77:v1?VPUYD8kO_@^չ @;M- 8jbJ%I*a*,XHrLNڧ*Ku +zO yꪊh:kP)C$ijOYx%.g`OM/F2'$u(P ,X׮]v UtBDA_M]ζh/ =m]^mjEc+X}C (?S鿵1!MpKM w Sb.W#Ӕ[J4N pV!̧H"hS=>S(YVU!΍Ws.M{R}1՞bcZ0˸D*5'wZeW3%1 rLvw2U ,m1VW(6=#'~:kO|&cHN:/>Q^A|Za/H յQlip LN|֟| $=kmDY׭[*}ϋALB=S1hŎ #\\=ӓ |lQ,y:d]cyeMs4M3 &̦(ۯx:sNekd kTfptI֜bj4oBG ; \iRB,~ZY0Sx:HeSqz(gu@wN+" SʾFq{P tdU͏ k+'frیf@i;~4:ѫUc/U˚Bfpd]ls!;"LO_s9jo,ݗ2YQT GrqٙHmr ´̴REЇM[NW }-*Y!7_Ѳ% YhiAn6b^&CJCJ+5)ȃ9*UTl˼ Nٲ^:JJr5!- U-8M`|._Y'3NPMٴ0_M8Ep!J9hP^C׏a6ܸ\J]}Io`Bꌝ{ᇂ&k$ &[TE:L7 + @}A ~ Ҙ{v'r{]aUEYTfklNRb]0e6ŦʯKfwDALVRH4 1 ;zo'[Lܟc|5SWxJKf2*t*[:㳞sAP\T }ͮp-i[C/Bp9AD P}A(j='4cЉb켤|:B =R;TɄEU !6h:.PUNlCX"NQk @ZJGl'<7k?Sɢ|`ol!D1;uت B쐾Qi RPJ.zu-G:S:uU<$R 8~I֞E@,(N'ުa}=`rqR2%m"g U @ѝ2RUɕ7ڟӝ t]k֔]҅}Fa `kGA-{n3*&ҔbaWx{Z1`rFsR+ ԂV+6b]ٵEtw76_rgu:e֪EqYApRAHɕ^gqZ`D~StAU[O V[Lsv\]lZ19pb pϡ iB*EQxav0b_]izVeʣZ©IjPDb6mƪjfTc3S5HfYIE@n# 0Þ(dPld[t۶mc"@̋ Bnv np:/TIV1.嬘ItUUڋ]!'YOdSAP>iYN9dɖ Uz5߽{??ܹ.QkYwZydz*kqP}yWv$|j2rJPQ|uD|b nש nҩ${ R[ ;T4n`Q|[*0:Nt(,TX,%Xb W7 UUr:h_q%=xF,jw/(g>U!.Y2vII4Ss4'6+Pm]۟>sRΫue?x9&EUDkSqWXkcc`R.a($f21Zlx-~*#UGQgK%\BZ;x1TזdS]q0oTgE_V H*ZJJ`y!͒[Ij'\?MOkLKMK<4A9[(=mR@r8CJ'pZSEQ/]|v ED:X-gOS<+;Jɮm"Y>o\EG՟ZT ]WJPMoJȏQ~ |73`.r*eUO哊B*kPQj/0X@9TN$I<w͢55\%vCK|SՋԟ~q̗EY*uXjϊ kپ};"yF4+ p} ǝ$B|%uۀ<ڎe-+P$N*z?_|Fb1aqeZv jTePXeL+oa8=IZZn>zev2YLnt=j P-;"\տ9Vq;0N*|,f0vGz>0Y= Ӵp^; "t Ÿ*FTt~$3` tb gaW% Ԕ.\O"GgoT=ԎQ+BˡY@K]G>9+"i캅^"*c[Xlk ZJ c*Y^QA~4w~L"f.SzTNَug.:"/bmtAB(k&@jGLhJ" O,WDF '4^jYy`>fD\/-ރޛmސ3a(|Y)T2ە:b`bBQ&4Ѭ5m&LL5Ɔ'P33ls҉J- 0iRq 8oPV] Plh\oF91LSkkSTQbd ~`~tqA[2|>k_ a ,ĿrǪG4;#DVB(0Q#@zUYSX;L`6Mn>XiHAƲ8*Y*кR0I<$aO4]c5;dK b㑬6D* v}Kٷ˗2oGM^ƭzj4Vk&X|Sq94UKMtn *bd!;~nBu?\=VVjvyGw]~o{,2m6a & -vZhM:7I|A3GHݾ7G!(E( ׳&=Ipy]+L|`]0sQXl TsMzWڷY66l.YN +f GD10L 'rU۬.ʥebŸO:u2C jꪶJm#ͳ' -EtAڒM1b"+<c;6m~k⊅%5Q Zxvsm6f q#'xb1W\!KV@f?]oQ.-¼p'IЯBl,OZ54LwGA#xGm도W)-i29E<"RNŇս#]ƪS`3 PČuIoRgmT>qY%7Uu?&\AQy4рh<^[qET;QU,HOHYrܭUgOk)_J*v\J|E@)dVSzu-h`UÆ~qu, Lt#xiN#Fzc5bhnWq|#YNzg/eQY(j!U-fPҧaMϗ\%u;}h5IBtDVlB jӕwH]㌂ՠkNJ k_\U9e5O:E *S@Bs1_:UU08{|8֭kᩊTӭUEJ ˪iQHPJar*:ݶL7L[#v$TiJT!y},i5^ tƝ,d3J m"yr,S>1hш~sZcլP&q ՖKeOQ]*cWa ފ@c/$}m ܩgl"=7-U}w^yP[{lLQpcܲ 팢G:4#)L`A{05YVP.Zc*?P~KLԬ6H$i ԭxУvxtObnsCu7U]r1QvUժ '""ErSLٶBAїbgzY._v9C$ FC B CqRmb"XVVG䓮f^j>[dkᢈZq MԝZb.^?+67yq>F*U%  ṣQ!dǬ}u++[t,F(\T%r~zƩPppTlW? `ڧ{Q)ЫRQ6wN:9qp؃4rMBRbza%y֟oS'*6fj^2|G`lnemAt({qʝVxڡ8<_診r%=QQ7t\.:cU &8kO_f(R%flѫUDuUI&lBrsA[4|ysAB MRTJ) T9"N8qEW;rF"+ TѼDIV %(ЀҙNҹ,f`_ر;w]vUR#R R/FjWոpU˕Յ r2(:Z){ԡ~{6qӿX:0ʁ05bju>);A X u!0mg5]!Y\ ӭ$ƳJo]ggqm /q)TK:]i2uu}ھ}A'7sx5 joWkWc=piN %lByhҞd:ez%W22~0 (u\,.ЏhS5o^.+-w+JY}b^W4s˄ue#Zo;-ȩ{:.d?]\각2p&_a&;[ns\>JL^ޭR̽9<\jn'$R8Y5P7QiU,e0wAȸ#;wՠRQUFۘE|.+˅k/bĢ5X`|Ev:b$ _LYyc; ڗSoaSg.ٳ y߽AhU+: w{q|..B1Ვշ>4% 5=(? yC$rD-b[:e2%js2X j N#b`P96usAlQXR.iSv|9%UҬI oavپ\ցNƋ%`}3 :cRbh)Affr[gR+e`%=K~S0YhyXT);T*Bdmlڶ+vk;P}j9!d #w9KEFVtIN @Iw|jM=-I.C/PmYnV-wU{HOT06Q S/t uEg,@,6V-]W0Sb qE $o}o"vV햃m܆LP]bZM0@INhDĊt@26Dc֩SctJ] L8`$Ȏ,NeP93/HjCz-C< mk2UjpK@w*O'zVc L9!xj3K\NV$svV:̪p+(1 *e1=>Ƒ?#?&~"&*XԎ:~ Q33EH*b.ݻwӚ[z[0[(j xlਪB퀊gx|_ז2Qlz âk'f-%7VG1O(tj̏B*Q]J{bVC]Rם9^kww{@*\R!:@+f\NK4tg<93lĊm,Ijf淚h$,unEyR-U-bL|_*ABamh˥a2_cw&m(7L']wa,q!bJ3<gZ5ps*_qKwyNYјRc5b-k>3iW^ѡWdT].;ܸͲp`SFlScupK_1zS=`g`sjSN,4]؛aA~hW=,ĭr8<'>cO_ۅ xU#Vv}U.s"uזJ_A#֤qO͊yUˡmՇ$&fhSn 9fj¯pHIxO[p8s8P]*5t 1Jblt[߽vQp:$ܕjQ̙R@Ӗ6WHIF":*lo8 oJѪ@Fȴ _)<媧rJ~)T VqCM=X9//'UHop~$%s/0A(fuPH\K$reE*u,$LrZ1!! `%*cEAPzxe jR]0&,ؘ *G0m۶msN-g%q]6t]S I?*yrg{Wf9Y_*LI6N:913:okk=lZÄ--;s=˪_˔A.^(a'D-kҮeFL?t1^>wZگGYsa3C}@5]N 0t5)Q)|-P13mTbIvu[5Rp,d(OwԲ`+k@'TZ 뷻'r!hþ>]lњPQ5K(җ0'`3\k^їrRW%mo\2"F1 sA92Pkȶ:Uʆ<-.Zc ]^F*͝wV, t*=| w)SSk|8Z.b'm͓TnE:Kl 毌_SDtH!kGk[4}S'NQ 9U}.;UsONpm?\%Pɾ-y~B+]l!l{5ecֺ:&4 ;բםiJnJ\~hi\Ŏqd%qH&xP1`pLu?K@v՘΃hw鋱@^hS D3YSdZ"R5 0URRmR YA5hO_J]XN"7U b-hOۀW4*S*g2nMT fr㭁SySZ|ܨVOivꩧ֏1u/֚$' e(8E%EbZCh([>mW[Yw-F{Y/?}R{SC k'nZ:GPz/@w­qSy*e;6t_Ng}b\xᅻwr]{}0k$ZG2k)WjlѦʐƸI UR'D1mfIKhz-7ǎ|/ua ${i9{Ջve` ֫J/H NSS'Q/pnB|ZN];Meˀuu Z1r:講i̎ئe~}nV\YCDV"bϵL:ԝ.n A`V,c"XYxV:[Q?StX;(E/)ciy4mXPNOe]K~0zK_A5]'lX_)\65r^uz 6aӨ󋗱>n{ēR1$3Y>Jpg.% -qT~1w-ׄ &sҲQb{-(񶖵bSd%zJm]7m4BE|fTZȼBF{St8[veg+M=')0=>WFog((W򋸧_ᾂ}J=yc8@PF2^}L[4n LT$urYN:e#+6]]vu\JK5-o3s9k#RYvvReu޶>ʝ8L &XO{;ч*L~z/u\ɀ**QZig2mJJ rob$u#bJΓS^17[vsWԺTf0]_C =XQR@9s],gK[Yr2Hnʸ7@py]J)OSo"WI0%l79bu]~}U8vZ@Eg<[eɟSl︪VNV?+?`jP2Ѻ{g%}bkU|J<]! uN6nJbfʵ(¢!JZ6o "`B!$ ) AlAi$V0$ AQ[۷ce$BK]+FF~a͸~/)9bWi+c*GXYmj^@79qGg~]dDbq{7ր]Cs:EWհr9[ *Od"k kM4#aZ|V`}"S(V}mS] aꗃ N>yn.̝ u•֩h쥔zugoX.h!^`5&}vYLvSUC0+T ᆫg5*7x(W&:餓:Ŵ"?@*?&)X DC\=zÑΚ[JHG9i0lf:dCp?[rWtLW-S\7Z3Un]bXє?0 X V=x~Rj )NURFHxIbN!Bc4?  E0cĺ>e*J,LԦ˔J7E)A}h,i Z- йN*Ȩ'%PN}\/0DaiXf5ۅ!`XE!Uw°$6UŤ}l+?XsGˊRM ȶf9 y݉#ZJ=&C}#;]P< lTFkA=RU|h be~%p9qE"|K܁T "6Dzh쑒[TcpFy:5L 1x ĐcXm{; 6Od*C`K븧LmC1^"F)7*of"悈4D.QFG/b7yLRjfjDh/uAJPNQ"ڌݑshTGӷLuӺj:ziҒ ,pРխwr@L408d1& ƤO_2ɵhS ~>' {Z e~-bC)pC;-= #!Hp]%wl85 9&x4%O(t0rSSS|qPH׋d)Aԇ>A n3}7%^ftms||y6t NDBz2V=*Fi慄XCJ7+f "Aν;I c*zAG r1bU:ʃA^c}RpN2JsƄ.H}Rin>D*8J5i]Fi1}^mȝvY ٨EE-Y>~WdSo2{1G=&ZX;>(4av}O( [HKl_*Yr'AS%Ax \ŪٻKV x\Ǵ"5ב*DN#ɱh;GjeV3+1NMJ{U-3 ̋Jaԋ$WpOd*|Jѫi^>U٪PRF,4=9BmPHJM2R%!8O"0&*VA o@4LQ9r,J(2\UE ipVvѦ~hߎ&]y꠴=0:= |%Lቺ<PZO?A*IL%~'3ݩR^- S>rmF㪊РgJr&ѫ*[72CIdFb|mQ+kdjQ+WgjSyr\e4.6jTSV%DQ6uu 74\pĺ*-zS¶ű=7w~*`H5*#H$J[g!YsR %YGuj!:/m|Uĺ\ Y#9(saBubUrsK h2g@R 6=\Ja)* ͉N*LHTZx( 7qTps(1#7"TGe&_ JXf9 ]ۡPpD}jn ?dFQ'7ToрWcJ.4fĖdktvLb!9 *C`B)**B b@@ĄJ E F*Rur'N>Gg4܃Wsk]ZZ:~ ͱě g{@)0Z+-k*:y΂E}ӟ؜G'Z0Q놛NCF] A]odwԳkہ/#(ta>f1xG;ȜDzI.sJꔉ"^ۺdbRϽUʺ7mQzg>BĴ0@1b.4o`hX?{,VĞFWd`L҃_~2">joTy'{;QmQ:tL& Y}nWT hau@͛|?:{ip cI'4ȬÑ ®l;U,]2)Y#\kt ycxw'`Ǣa)>e!zq+_ /gwi0Rqnܸ!PV &$Q|Ԩ^CUP؂Ň B:D'J[?ܵLB9)al 0} "3RnV .wSO) ,F[%o}cACy,RTcߦm7Sl6f][vr;pshq h)?}-imJjBIc2W_}[VRh&ԥxndyhtl; R&}HBXJmPa)mRڵJ jqkG>`x鸣UQbnccR`K0~ 0@a)[g/w׫{W!~5aK H~l[}*M0a˛B>tW2s0oPT6I$oLR)k{BMa9+.)YD"qnT,% ǎXFKİ,A9BzN˭[(){:)`E)Ws_\^>_?zusmӴ8ʑ2*Ir} 8&Mt2nK{`g 6CS,.$b+z]='ㅦi.yVVS@Kvm$9cdfxGW*fpUVpu 7rA}\\4|mcU'% I{ L|g@GvɁ:J~s tenUaaM2/ERmhˍ,xXE9OqFp< 7q; Wӕ7ZmlPKOD(Iz\V'ۓEKMQOd~<_p  PoӶ/ Hue=ٌXWSGD*Gk6[s?F͆յm&!LC@).<poj5.Ԓߟnߢ}JS8ۍAP{{l̜d 4wxE'!,D_KejO"P&El'fXTc2|q/~s#CH8@rD\LtV_)3q\O n*927&SFIJ6 УzBpXLG >k' c%i*KP&CTp]>\$ic '!)ՔojgmjAZ8 ѝ&@6= L!IA%m8k'7z TTS6,Yt7SNW_ K7ZS:4ѿ+QltykM]Rk5hoK4.O))7.^^1^@yHu6=ya=? ,6(STy8>6հT^t/sp;Gs&[h$>' @/`6Lh^I9ɪNA-Uqs=H>ݟVO'ϕaMhP{vpi*&LiS;;wy"9eKDQE×%T9]4sV``72"Fv:OHh [.~#uKdp3x ܕa =X|N  H`Jil֊*gV e+'́ མDN~lШt_KR 81Хrpĵ'$Tz?3F(kIwvrk>t3"O +&nx;w^zUӑxZO .>Yt5]h ^Z#8(Fϟ/pʈD졼[+MZ۴K_ _<_Oŭ!vYap8K ^m:gWBK/ ;YC 6K@WJp0e-^ īxeJG1V߅&,V|zߨW% h4+jފCQOi2"#B_Isi8E2>݈7Ff+5h ڵk|5`<+湻e&+W]-UJ^O¢K2lh)tc!T$.LHZ7>Q Yu*Ő 9yq2qk7zزzlsH0~nJI u2{捨/xP /5u0ӘᕐB\J|D%#c'MOBG$A/ Wj㴤>ɔ!y}Wj^`fPDA6P܄Oq2GDTۀp, <9+$h(S!!0nʞ!k-=c: X! Wp H3<}sօ D8kr \.Lԑ$$?M#z-Kta(CшR4 hP.o]$c$$1}=n44\RƫXqBݩbͱKK v <( Kcj!K熒?DTYdi9pO1I4qAÂ?|j72GzKt$Vwrܪ$1p dd2g)KwO+PVd)?h4b%x;C4L1v_5R,R I |C&5^8Jo-R9&(Υ۵7U=%%% ۈu M'[G>Jj蔯ni刄8NpEғO0!m8n2F?+'z;JvlWJ8D fCpbip \r݃K>B>IPd8!ՂOY3qdT㇒N`c%đ b%Q=URsiҤa=!%N;w׾& T,qL κ^g0jeB;ge!+>9(*m7~p)lWXV f2u^ KQϬF'FVg7QLxJ(T{CJU,Wv0jp] \Wcy)^P>aOWgS!7bEPοwjlrٛx)dN"yiLDPEd ЈJ2JX$L̹m\ Z:RNg}YY4>w_Wv$2HuvF#_Eݗ@.0l,ʭWto'oՀMjC _z>M#Ņ@+۪ᤍ^!l>_}2w-& $_1[4V $"T5.ќZPYN}hWu ío:deOrPϱxJL{A?s0"يC{ JURڐI*yJ|vfƷg*, 3p}:Œpc;+u/3Y亀1xS@*y,ǷPY&ǣ5fά|| ;MV{^nBzGZnk>jü -WOb*H mBׇpȶk? 4yhՎx=}od@.Rzd"bsꂚ+ (+Yd}bn;86cП) a!IՁR{1=g~G>ar3Hx$%ud}||A<'AB+ud/otCS#SRZ.ҝXyNʫWQI#j GXHnsxWLm!|堏Oz"5֟  ~'%,#'*,RTKxc=Ui*6z 2Mm𸱂Nþkup@J;$`Xj7HmyjoJ@=s9 QY(B_Ӧz#HD<1!8 -.K3@3PUH&Ʒ-5DW!5Q>Rp?QsKBj6zxH&'e {`Fd$tMKkv6d)mڈz3/e1Z#Z1R#sξt5sҼnPw7K-黒4ŃP!.F%!?75Bjr$prlٞO|=Xѩn |G2ɽ~֭}}IWUg56ÎY6]@bL LV!K4q)=ۤk9!B@j x sxF&[zcca;Ei^3 d&Pа;9~Nm[K ޸qs$ #ACYjjHaY'gz)qLzz[o՘y0=8#P T7m"rk}/c<Pw HwI a3? v5Pp5I:u.%|d߬>vY&=FI6cz7MAI8n޼)JoVjVP"7Rmjpcuas3yS|on~T,Y $^C=$6o$ʼny)B#R_bdtb=jDx+W<)CMjSc(HJioC4jF:sڵLmc/4q˒QYuSV`aߵ5C洭4IDkPǯxO@JԽ%oS ~ xwD( x"bF|ñ*4rEP41TlN+7ք H<_ zW%>iz/fzr0Tr[eaBgʖKKe@ftUeL.fBV-}$`Bͨ^QIRMݚ%M* R_sIO':42 &|6I֥ r_L-կگZBK1 _LFKG;:լ$R!Sjº??쳩Y45]BKH _`*8 /2Z҆F]r3rO<3-od"I5L6^&QVp>RzK4303/VnZzE]kmk3 SR9euzTpo3A]؄;3)nU]"݉Qq@(n@x)0@l2BKdsdtxrsP7G.60S  XB!_?))wL])LzlkFV_Y!?MCi!q@8tD]f@$J'AL@H 'jĬK?{w d X_ۨ$.*gc6CȺ=rAl22Ju{v9+•+%[L#.HvWrhQ*جB'4Tɤ:81B# \ˑ5𖛴$l& rX8h IT1a \eD.sU{B+°&i<8Ԫ8[^ҫ@IVnF ԯҸa[4'c,U9jy3}i}Sl\A$ڴOZ\jD=89zC`$'۟TId <0y^T6,djD{39yRzB-[ 9{ 7W7gE6Zrd-k>uԂ6YQ#f`=Ԉ6қ4g_D`)k8ɛ u"9ϿS[fB2ST^\NI>UFP y.6-ϖI$;X$>XAR H Kq ik6fA`[w6b\/m}68]HeMp'gUA@#_nI4qe&sC!C@] mIM'hsiX InIxbsh,Ӟn[Gɡlt'i8hĶ|}Ԫlv?ԖFkMjE:e9)ZR|&G+#5K%T:f*!j`:4l'`YkQO=e0RNR hByBhd1|eicèC۔ř_PG`QEYp:EDDgQ.*v1` ވ}i7FJ3$|فʈ>}VJN؏F"USoGl,6pL`nӁ Va'ǘ?h.UwjNB`6B"@3<8}Ҽi )q XhqQvZz]GxR0[ D!mȔ%@{#j9Cm PD{ƪuؔ$bM "rDH]QSAOVAN \hJxnq֜xT)d~fk@ցd(g㿊HXED;hpؼꋒD%%J(= `I#=dmC"FV8 BR3im4?8л6V^s{F8/ d ˼H\MM'rH,AjxĞo\ S>YnH^"t϶P{yPeV100[g1SeeH #O $?GMG4Xdēۋw?#kIh +uI' VyfJP )sˉYdfs m̝i±-1K4ɨѭ{=sՇ~ZND#luEXuKd~&Y)`Wb ĹY$* 9 kZH|?_|IjV׋MWl qh%aR4{~9Mj?ƍr?!|`4Fϗ(ːJ[4pLMBxǐ( ٬Ȅ=3TԢf#5R"9х m iJO)@6CR#fhzy80tӊ@v}@ӏ: nϿ{2Z* }UvMZ,z7RԲ޲_~E+zD67<_cTq> -B:'g3G7Q!XްSxp-/=e; f=š[s jOZanhZ!; A =zdoM>U56#LGΣ"ڏ5jz]@|>7ڰɊ[AIδ4sIJg@[adX f#R4+/v2<zll88ibXe%z?>Q Q^W"|oJ_|c$,SO`(Q ~>1SPаSc#ץȃp%՗'sߚQaRN4#KWd&`;H1-B]b7 s ",@BkH 5IRq+@L('WLNf?t[AO+XNe0FJDEK(0ݠZ-M>I̓D" >mjXeFWT}G"?[5kYj}?o8[RM BRߚ-YN{ 6Y~[Gi.BAp2)S"#T9X+?Aɋ51j9D\GKN -X)0IGPMﮧG'((΍8f/b8%檱pR5|'פ#v-0N1|H֔H;Uo.?Xڋ!Ƀ$CAa%{ӚL;%HRn(TuF"ӈ L\O+ x r04Q/;`H:6|%$g80d=+Ȗ*hʩj\0pK8KrZUtJiH Kuc }K~N;,TPƢ$Y:j:0ƞޣ{\VBY@Y~I)4w~N~GFpNhU2E@AfvJ/~RD|{s6 R_wSX@{Z3ۋzERڶٞ hW ߝ@գ9ӃiA>= i׿;Rh`*Kv$%)_. [ K?' ={^XPجHW-`=԰]JpcOĦ')8P"kKiǍ^IlE|y<\}  ɥat| RAW/(_gvb[I_=y b\S(P8R/Wͤ\NyڟɄd4αˎ1 %|0Z>yp,&dLzړ5c`}S E=Խ$BfWOejޝ #ub,yh>No&?l8Q,c:4W>JhOu8JS }G˂Mp5E?D +y5]vnAMRe_C| MCM\1m~C=tߟQTdH: idFw %6BJ,Zȳn,Fē?*j(L@Z4P[$de5YZ-ܫ|+I Cki`±= T )|ޢ=j @HcP.(4Y'EgMjCbx˛c:\IKP 58 R4^7=n=5Q)z{Ӄ`xRߜY pij0lvOdC4@R_IG#sF77%'007 ZgI*UHj\f cLoOvqsRClǥ%b\BBoPȆ]үz=DvP.Ŗ#"[v[Pz_<<"/eU3ưa]ԝ t?$y@ VI JbvNA|-zN=C[tߛB) .mhPO9pْN I<Ձ{ՖZ9& ;NBJ;D)=I rrʃڛ)E %7ݓ,9Xnw!'"d5NPl0k^Cٞ@u޿'LWS͜&`$gr X;j'F" y5J9jRC&S = 1$@`wl+ɵ9 K!<| _-ςԌI=j]ʖEFSDK/᳒!K (/5˨]F"&(U-okj"a<]كU. 0>xZ.pĬKmE ~BMҎX|Yi?ki[sL޿4 G4T<16[\$ kTV5ݜ l9]}o3!!db(Pٸ> 氝 "53ڵt=Sf:HlGE$%X5Л(udd !eB*swI{ u'T IN^zM~W^y%#((l7%*9*޺kB(tJE* J]9 LH%J3|GOS ǽ#qwTDJ:xy9VT{K^-J4@c=֊ey0`% F  R]h[8xؓU sEa~cu(U`M+Zҿ5.?˔K޲D\d^}7x̝[8ӄSRi$cBnoڋ S I f`N!O&t"m MbɢFpm)EMҝӕp6Ǜ)Е}w)q4*-<>W&Ls^WEZ|$*neV 8уT/Qݽ /$LEDI⚣v#{NJS ܡyڷx9_uJ !~Bl iEj@vPJڀШ2'6aj<\)*8vĺ-.(70ݵqY֍7pDCkDUT5[X c;YL6 qwے_Ic xƤ\H߸ؤ:R Mg{DKyˑ!d'%saAxk†F2}`dz@l6 "u*IHoNA}^XYg?vpkOaWp`P,{s@nX+n,zQw;̯c{RANKZ lm~ @RgZIWV/nTcP\&͉)Q' zދC" ,)P{Q&ܮ KR}7w.>XB]a 3 54O9Cp%F TcVFyD-_ISNp)Sړ+kKJ@ 64n¾I(dyj/u{KK5U,fXH76Cۙ||eR-d_e~K_t>)Qgl'jйrQG6GR|7L(:Z#ReAB4ͤ40G#Nzr4Qr*n̈D)&o^椲]%HY>w8v22^*-yU^#",ڈ4NZ_o_( w͎=K/a_MHbZh)K-^~]8"p 4l|w{טcq5Rw vxaVí;m?8ܟhɴek%&@Iv:^ȧ@-@iOZ[-HԗTwan'6^d QEb2'Ïn"Q)gDln(E =Z`U:` fŠ$#30;Gͷ0iƌ(JK 2dF,0Qglɹ=V,]; b 0e uӅcSX[]4MV ՞X;y˝ c ʃPS6.=nAuQ4D=曩Z3! RMWJ[['M, كsI92#m_uU1-~l p4MF=&Sq;6PJ`fyaG?i<f(RvQBGD֡R+$Ԗtq_UhH |P砄kto`SF ڞ ݿRQ*㍙3ԑO}Xl`9 p/&#%N/+U4-=@$ X|d6F0ԣ"nݺչ$)4břvŒ+ŷ 5~iC+Y f猄*rVXW{$QFbG(+evފ4z`1oF;vgf Q=sW@K{꒴S;i/= a% 3eF^4p5,u;CP9@OC='X+.MU 1*d{u$5Lv;ZIiJz/MmW󙛆/2F:(]H$hZˬfVJj#">tl:F -[cD@/ieiE YPX)7"TΆ;iwpاIvíWBa#>'\'p2lӰ1YS6;euX½r2UV**)&I )QG fs?6ؔmSޓV=zc=.(q73oWL R6 T'gaU"P2k7rŒ>F'S^iK@<uO-8vb/CR;0ժ$A}|??5R;\$hv:I6&p؉ֱ?+=Q*ЉL $M>3M=jau*av@CdIױwu8rŜ>l]9s_T0GX@It otsBό%& 2cqifJbweA3U9n' DpT-X܀&j= enZUWk|,/C9>FEc8sgvZ-CqFbaZԮ2Ej[cPUzf<(\x^R[ jw:|i!p'~#)w?OЂ`5z_JTc *. ljڏ4=AKƝ$j,D(Ձm$c x]~1~@֌͢9Ьhq^WSF1>#<@+@6ig&ޝ? 1LD: Oz<.%~VagVi_hzRjز?YE}_ Ӯ·F^>w\!T&> ƧO%w-L4#zd<*KckXS']u7~ 'Iek LMֹϚɋ4mҤ'8یAU:FF6 H%w0+Xvʘq婏kTv" ~9Am7UMV{Mjx.\AńjeB${_Q WHU-IYD[-r[SpT'>y%KjzQ/0sJgDpHxݦJpa1DUiX*J$ PoUL@(^]bNRK v4XQ)slTSh:%b&XXPPD7fmYXҼCK#~g&ɷU1?p|:"łfHz6; grc5$\T&ގ{0W@@Z'Pfˢ;и16ɷc!E=<"i!Lw_i f~˶o¡̂ %Q3pBdwp˓mC[)L 7IU3˾\ix竵>ȿ u$4]&$u'>JSAy[oSٚ- jQ=cbmq2L*D^6Ա6!K̈́6[;~z/[ ς0`~l'6rsyceU?{2pXz~,h=Dbജa8Iˌ^ p=Ojn$%]zו+W.0d6tZ:`e6'TLEW,ɎʞO晁dA2Jv`Uד2UAVty 8:؃:9 d,Oipro>]L!qJɃ=j$ި4~|h#aMb( ;x6<NQFobW 8q9"'NKdCipVFIDFLIL)=U6+( pZf<9Iz;˕pȇe}C?Cx;pe,!5FeG$< aqvm&2 }L4z+c՘"q+VUݟ* ͤIoz[F@Hdf,+ܡ)os@ZFa?sE(3(z)F !c`q*<|(XU6^܎Rhz\ #K;xq1(Ⱦ(ˁ;kY >&k]ۜHEl,0gE1`ȡ[1jkXqjo)HzT oÜd\ r `teO4`.ڬEQat^?>mtUOr)= >{!\IP#>=dӗԫ۬T\@qٯRjF=Nwy[1U@Q4 -xѓHIY7h\)levu_r}q"C,tD'Zm7fl0,Ȗ̞DA%4g3O;ݻtANRhe\J)N6m>⩵<#^.[m%q"gWW3g`HS)wo/q`s%V%8M [ʔe;ouzjd) Xj 83*ih$ '-ۯWXw ܺu VYBҌˆ2:UA%>u$KHvO 3S7^g7O_A[F+;,]KR8*4YMj};_&~ٲ<@t@jXsW#-?;N7^c !꧞zJ`p,Y5Rd  YKmB2?*@?PM鬍yτZZm\"DjAFCMZH3+rLrc82U="ʻmS3x䇼 \b1kuQ=&ȅ!K ù)Qd]mi;`O0uRtd+ۭҶ~CGnt6=.[X˽7K-&4AF mJ76. [<5Se)xzE;}Sjbtg-L92$H?RyKndɩV.Reg,YOG=4ֶz-z*zё,شL7sP8EJVknãli$Z:^x>pDT"ߘmJ>yRuY wXܠu^x8 --P^VQO wUԖ4m@ac{-"8nm%h>}nU/q}@t;=͖%KtFWWE_MfaoLGҮ<,n.~L2Y'TV0t+ *@җJOPx4IFc"cq8Q$IJ3NuG Y1Ep/CΰbQQ۔Cg*Z5^%é5E|s 5(ͮ3d_0I$9_ ZjMt7^G-ye\=\iIup5~rrE,|I]+mN\ھ,qdv A;AqAQeꬥ)nD sR)PFڐ5/9aQ)'\ CM^̔(u Zo4ؾK9N:pOE eKЇ{ea1s`3U:cJuIQJ~}[v}si:D9HFUR;6$`j 'l鄼݆&뻨%:{! 4 1&IoG駟'/@eIXB(:JL%ʯʑQx&VP#AjL5([9RfWR9K$EiY*Yy9BeŬ.![cQ 9'%<zI\mg!OsIܲƇ*IS͒gR0o zi0ĶY3z1D iS1SߚJi}{N-]wa1T3JJ,ݟp{8&G"L)- P820Ϻ-gnP}T9+Rq-=[%Z9n!ej5hMl氝a#5o OkAG Ev6-Ŧ)LHUR:@#e&B2\ (vPTƩ.QϠFP'jɕ1-1[ϗO@Ķ2lN/ck\F 2j5۷aX$h!()`vhj h[}@8F7S»VUM鮸rM-1 'No](R2ٰn뿵6@l D,X}Y-\^U< ?͇45տzj#nKS_rQosAO\ܾl9,Xf*{fFȩшB>^ /&U`4=:H;P4 rRNf^bQÈ -q(-=GCLNӰҋ$GՔXRӒ +E+g$n-ݔ)"C=Û{h+Ȣc @jO bKU(l?;@9/LXvKrl3 |U [FAQ_[0=g\m H>Q5ڈ7vcvA|~%嶑GYRcG"aEu7gTZa -T9yE+oőRn9GXfTܱ lz+N31KT.88)$4`eoUi=G.W(癍q(&VM ޔ/Uzieg V(*2 A.NR&s7:5;\PU8P١"tQ 'Δ 'ڿ s;3'cVɂ) ? t(zVf) :&6)kڪ%^Z@)' qS U6J#*夠8p(tD[S&)G>X=PBmk*A)H#4$-#n8{P`j`Pnŧ9с}5x vJ(W |/_]y 5́JJCZS#MhlR͛n0RގGzO4dpZ[<Y. f(9_=^ L.={2qѪҙCpRj,@TugunZI\Eb㌝,)U;EQPSk 1l`5z% $Ko?N.Kd"=FG㗅K7 R%uObX[BUT~6uȈ7 R3 5OGg PY 9'-q6p }jgo6̈́@0sd.`7˧x;cdÊ@E4uKBӐ =!q=R <ije:@!X*7[EbHSZ_9 |.$ɾ'a}k ?:^j#B֊!S{MHLH { +#BWCDX6yj從;5sd[+q7$ϺHLX)P |hu1aWBGI:VePeq7~&OW(@?leM8~.MS1Mͷ1^SF4e'ؚj+$mɔ$6NdX)uc5wwPZJ=M"OV_n#Qzu "\1kFT$CY25v[D"W-?.9ꉘqrM%ff̞r͓>nkB,mK;}%HȏiV l,VчΗJ?١o/ %pp; svxG<n 鏞/c$gƾk+:e1S\*w8%:% h9Hu Hʬp8F-HJ\ҙGݵSt JN`o+ %yQ;_I0EL3iղBD"Oj}40Z"0 UJٝz T1Kptzb!^:}1΀H 8at[]·?طdeo4jn`|;JOfԡ6[ڝMiʵj$P^a_<_yP} !-|' .NR}a{c@u-2(|%(S/M謨-v@l ShKTW]SO4fϩ )TdrOǐ/|ޜ3j09L6uK ]ZX<|%7XS)eDky *wN vNxe"RGbW-gLY3u l裏w}Qʑra! G123: ǀf 6Mf) N#z\G Ù6cfՎ+RP)d|zF'iHHefu#ҧ׮]FdHJ(Zix eD1X+QAajs4WoHORFyۢ4:_t"lє)rQZR.FY6„|QaE9ק:!%S X7\|R ,j=EIW,&'j{.Kf_),bm2{ƥHP&E:*ʨ0 D&ԮBFK*#՝'X}&û:'X6 KK, x&`@"R&>؃\šq3 `Gӣ] '0i$Qd C3U9JYeRN^XI^mx;#G8>یKĜf 0LOjv ( 7.Ȥ2Bx*l]@TJ_RH rgpqtΊdT˗&%RҥC*Yrj*Tk-j$lhc@@Ε>":PSA?EqtKi]Rc@1 'UZr˭0)Q7}^4=zrһHRRcWd5T_?\PMiUj&^:jj}7gjd j,\9~`KprfXx+yh1'Q^yMV/}nϘ Ju5mW%t%˱AKD);-P``6&O|6&YцC DU*oAIj(lgң$;dw&eȠP ۏUɿdؠ9Qaת I-.qg9j@a&@ V*uzKC| )tA\`M*rF-%*VxJ$t 'n"$雾)٘x:H+B>3;Ayo.Z&ZZ\'&9+푓WP©M `^}K $W3Ծ4esrmj5l8 {El)o(ެ\.]OTCA$AYP| 'yi'o`yBjIږ탧KkPh(`u@/0} ֥Qb2;n!K7L~x {;;L>LHRǜ F%NZ, "ů0 1U\Ff]r!~yλ&"eP,Wnoa#%kϙP%1ABTĩVAY Khꎄ :G!Q:7BBF4l[ {x[ QMjEs{hqd%;K,4M]@LBm 4*^ ا_4_ghK6Wu;oAfjF8շL94dS$հi9fYeB'+mtRtӭDMẖ>DdbK-A] x`<S͐t$Pk9 :ޟ2- _sV 6LOS'{An2 W1mUO:xwjF'lbo|͛75\ӆĵw7A`wc )j&UoG!!DȃQŠm3Puv vH"z(EIoJ-UzYws^;!(h6>p,3av*_n(ϓs=8 &7N ;M~#DL (9<>O=$ВPz|Y)DvZlRJ hZ-J BBĹ i\Ǔp}QĢ+|Uņ#c]Vn6%zfF`Ÿ渌mD(hg{14 \Æw oo}P#uN{F G~(S=G[mKpǒ%# [\Zegs "&N0Z&>SSSYv~[HD^xugd'Ԓ05!;(y GpmIJ5UzoZNi ّa̺ ؜M?5 _sA8M L@8Hv5AOɤ9 @Ŕ2%.z>Íƶ/Wu\09ܕ&iB:/;R?N67RS. +Il}#fRhT>iJ#2/#wmӶ $SY_6$>$.{Ӌʾޓ噴Ql~V bK/_V~jP\#o ^竝,<f Z+齙IntO3bw9Nx\m`}>,UPrh%Bxjn4 w֩zaJSӻUbbM!9ȇ\r%>T4t̆Q{K'[c ʈĞ06OЦlݞ5[qI[C;f$JD2 WNL۶q ݠdi<V8jaHLje8'믾wi<]?w?9_!j|=jbik4rM]W4Qkg 7}%Y-!js0?yŬ;ȉ8,* Fjw"MIo؄jŽaGWH&%ihtd"7RVhϦm`,;]w|-O['&4W~4nD 3^jp95*UsXE{gdhBٳ6akS 0nKtNAi"EH Gw0P>ݳRRA$͓$x\%E)A՗&}Z꒨x*iFM3qvAU}+cG8YY7p4_g%cս}"WyoI-@յ1{*t˰e{/\Ħ/UZu8:lFd4UCk[N"AEY Pps o&H :+[mb8o%NL_ 1_$l~Sm emˈt"[B9yzZcʠq&@j8{82,IL)4ƞW!jK7inLcǡցl_`^Ch^H <^hmċhC`%f5"u[z9 '䟱h]"lʪz7]Qo0Yd' ov0 Ia@qT. ߶n./+}<op=~++6t m:iS'DpȱA8uAIAcD*e: tHR*oUt~C=nQ3(n߹엵^{g=K]{㓚P_xizET%ɈS2add VYe .;1?YVHvYA z|u&68T64` er\RsoO|dsFq^a2Af$@fSE^N&ԴְCKܰ$$ jeDQd/Y7}Gz@)q <ҟBЋ}GWI ڦ7 Ơ QWD҃^D5Z%gxF_j v<e"H1мl28j[:f$0!rl"E/٥F#^~3crjR W~TUNa|;%;wp5-4DIj%ЁH l,<Eհoı"shrN 4 b? }Lp&B 4cHn/ML&gS;:ediRlT2Ȩގ]QqOZE89ωJar뗃"T,2frA;kx+g656,n%@rlK!lJ3,w Wؾ٣DFbaɸ×(狤2`Y{R2pA6ԿXdg?:_1 nP~SaQk)Ģ DNm#izs+URȴةe~wPJ >cRg`m84 R:d'iNS^J-^IWHv"&u\G  UEd"[^Za :F%RLzU`K<_,2OPVLkQ-EķqG+6f-Dɨ[ۨ^#S}o3%z_4nz@Fߣ9^2}V|˺*GU혡03h ܴ tOVRYRcyv<'&Se}fT8+ ;Y^6Fb:_]"ὺ6) qCTѭZ<j<}9e 22&4Y絳֓lNN%T5T^@ՋԤXے>[s 'bHf&PZ5@ba *[ &)nVB-T͆LUVTSQ VƐ)UqQn"EV[i*^Cyf2%HcF'?},rbI$2`.A^H`dMUqGp5+u[  Z\I?irq9 7.>e{`VM㛑H&jRs3 'x[Vb3:kϱC$UDvB$vn\&Ny&!N},vhEdnb|O} fѺ)w2Hk xXD!UH~&`L36GXL|f a}4؎l#h%?pBDcTt6Ǵ\JYIdK'u1W@_RH&P?4ɺ % 祘QEh{BS;LΖA{qձJڟYmi(c;AP|0 փUږJ]sN$n{&U`S]hnӎH|̌{4 MKKcW l )ҝJaxP+PH)%}뒐$^ 7xHq4\';X˩1AZXYA CxB>M''>0zN4* n>2Ժ[ߗ"m[lXKӆ|ԙlXE]+ rfJN$c`2IU3siУ;IV 4~Bbh0 PM&VR*|`a]vH⒀T&a6I~߾Lʈ͸ \nkō܈" (), ïө=(^6GṲr̮hK1tMB裏~|;nDGi̘PPܣ9yS5ii䈧ORrd10#{^kH%1'2.A4#7}߂+"G/jnP: F6g7PkPk P#lcTYivMD'}dEA!T[LO G&S{J5BZMzN5&= x\0R=YPjC/M\F.r]20묕} cC4$F﷾o|=c=hmC\j,4^΃g%h`߲?/([0G AMOHC/x$3E A]N+ #=g=8 M{KG;Ww*y,դi(W+`<(eԦ$;q7Qy!!F}cL 6Ǎ%ր' PA\hdn6'+CP~uSI$H(dʡS?ї~R#Q5 jCIG W$. #<пB FG2YL{ɓFzxki}vcEoe*-0ѼR X_?3 U% !N :@C@ ܫ pG*ӛ)ò~[ Ƣ+Vs)1GXīoHZ4cYBꫯRYR s}֧A@|p`0'ugwB.fi@1t-lx=ܫ{$lwJ9 ugVӀBA1pz`5Ҹ}=}EY:W' GReO4 B$;m%8F]qC-@%P(TamCizcvl:TUMC ^`Y߈E8 6Ѵg #:c}-c2;Ǜ t*#L,SFߝ/W2> 7HE2.Tm=6XvjTcj$%ǪK]-^j_ G98`\iO\fI;&Oh;~GqecPO8 9f+尬o&J6=\v-ٶM=ߦɵ̤MbH"aZ;=KIS ke6DF-OНYXpIK>ހ, ՇVH%_. 6;^l8 9@ LCJlhAĨ:eQIS^YB ,6*$rV:R9։,>$tjr04Tm&X5!whPXk{lJ Zz?tƴ;kjʼnfׯ߹s?~O?ŀ#AW@6P] !zdշX @>㩳EUwҍf#oH aE9j\ѪbRoTVVRH.I^CckJdt[Bc{@<~Ҡ#[Xwd* c8v@XQ} l[ҫWl#_MZ⠼00v`v6HDMX$(߫:qF/k~mػb$|!l("ݱ2֫&k{EXh„T!Ͳ%UBrġ߂YFMϭ>An 򲉔1,: hB_3KS'Нlё~P:CɽP .1XM"RuƍlG'.~D>Hu|OQzƛ߯zoҏi3YkWD^B8bУK-/K^)W$jt,A'x6}=,Xq>! Q_UX<ȝh:NDH +2#Sqk[ KfHVNXb>%Cq!fth̟Q 3֦p@O׋ IVξj8$1G[*oR U}yvd5QˀZ5M 5D}TXR/9M&KT+p ӑ蜢eլ|0TU#ܴvOc]'2$jxȻX?-]@-)Ն iEڮ8{~E? \"Ptp) ".N95FV{|+w >)N &ӣ3L bU`Fa<'o ZXjNYCG2WNh8n~X>"%% nFWq,kٸ5$RZv .ӆMIKb+-J Pk5fr#%rعš;!ұ< LЈ6:N p _WSkr&.Y*,Km߇O͔nxM13<`Tkjhz֢ GlY  jM[])NkFmhS,C? 'MItjL%K!!_6IROyOE|Bm_d7#xWvi ^­ޜ~g_~C'Σ1 C 1)uO-qPXSUhZ]uiJ8ռ6dRt,)>_WL"ml;b56^;H`$qb߯KrT|QE/| 64x5ﻒDsSuAiLyoҗ}QX4(,±՚V H=Ƥ}!+m5IJZek!GȻg S@[٩o٠,"L`|e`Vk~U#Xrcn6kCHBQ4rѴC9St>a%'RT`UL.*%_9|7 :q6Q77W%uR]^05sWGU1n$pߏ spf?Pu}+$H^AXk[7K @izU537atE MVc61Fz[w2PP}0)>jH 4RCr{ @Enq5c=4NJJ_ V}7n*s/d/K%+4!IRtau:MX[-l~I|Ĵaػ]-'| aӝ*A$KGqo3H/W/H}w0I9/zwک 2=DT7!ϩ 49XZkF ,+Vk^x|ٖ) ÀcȐjʼnZOC&yMhz:Ӝe"&\7:b..ӢQܹsMM(X΂ƒd4]ܚ ZI Ƞ~ Φ?D1kwTfCQCLuOVY&Fx|)?ikW4u*l".a;1D.z3v[%X_t߯|=iIP^#F[f{B>Mi>z,X?9VbtCM jĀLTQmImp]G-x/ WRW4U~҉JBJ.[ocAB(o{|M:_gZ-۷o+ԋ.ikaRo[5Oxf Pi[49†&v0;zjђ QGzLt/[M. l2/,ak7zl3DGl'@, P$5p_ߨ,+ԗՊ`K}`܃KHro-W\k!bQ`lE(H,Eu~HuLҋXB9 I$jJ@(C`.RuAȦV}Md[JP5J &?6 vC[ tA3NXGCA;FE6;I;of߳:`2PP=[9?ɪPҬUl&peDuݖ(N+jĚLci% =4u޸@CO Y)֒01sƽ.sVިc XfMAo`GjM8EF8ƥIX[S"5X({Rdu.QL6nMR.2U'dT%f=$JV(r9mP4sGM ~p9x(d5QIH`X3U:t|!.u[#ilx'--HI}^TPDeV)d.g)sk` R몿PeAIlN$ѻ4<"b@=x0JbzCJ 7 v?f EH0nW"JX]+':Vs]}P"CCC.@d@ؖDB,A} UĘWj7B$aqȪΛbȊƩ L6)hmu,6JV2N*;?&1?6M|(p19۪'ߦ.Gz: $aBbJ=%~`{d(R)IH; d|:x{`3znԤk2!ѾAI%z$:4VsIodD$(!mS@CF+3`]]W e)BL)"`n+jQL45rSF%!Mn`qh%]hzxK}X$c56S<-7n4 3ZzԒWMw h;՜YA=_1Lĭl6dyY-x,1Tv,y- 3(D<`V$վpE5߶2i&<0攢}b=Y$e|r~|aKJYCd`e[!j/B.fU%ۄ5IZhZs'[${l'X{s=onS7?(2R=}@iiH>bAk d j\NXLz; BI+W@>!u ij{Hm;^W 79='4-A5 @aa(K3UR%n6)F787=M-FU6hq5 j6Y; tƴĒK~!q'x%@hґ0E;`y3]fHTHhֶyRJK>R0UݳQRbdi%лDvړO>d6dJ8h~o%4ʩe}$jԪ1:;6Xw=(_;kά` DUIW203 BވB?ԪU0O* #pGǦbqΗ4%BoH[zrDFNE|ܴU8dYBE5bnyw=!HAjոT: 4u9w-*Q17yvk+YI"ñXeUog7 EKM3}4Awz{R_ԂO"y1J@4}]H{l zTh!)]|+'2NR,!M./|W;,CF@c;-#4r*m\s5R]mF^gepI%"r[B^EO7(h2w0n0%Waҕt(O;(؀zr?HW5 kOKDT1|Ý Ha*f($x]bhI%ͮuRr+roeGm2PPK p3(//390bm$[ NVOwbsYh viF(xp1=ߓZ Mg HٵD=1Jk(IlRmܼJ-Jv))l(Z~J;Jl/"h4"-!K'DwqX Sz`ƹh؄ _V )?8CS\W\փe*VgA?>UbObS|sNIP]+ɪ/0&c,2][5ڇُfW)qK R!=^sК'v={5v̺*+_BD p1P6js zZ}[|k ݟB}궟Wk)T\J4rOPnS5r1q+hJEv--4bcln4,$EQz0ѧP`VR00ZxºX"{l:~ ~yo$󅸁wHE ꥐ#VXO9%WI{Xb>E(h5) +}knkk+ oB ׯB|؀KlpsRQg,gdl|Ņ@rJ6 Bc -j+;.s\&Mdj"!A\jk@D,틺L]eWm(q"]%)Z|oqnB #!ߥ#Vu(kEflԊ\Qh1-ei,^֓ +>i;!cZȏLOT a v&JRXoc#84,xBIjШ!ŒU՜z^pD?Y&WC ["HcvgIENDB`PK !Y3`EEword/media/image10.pngPNG  IHDR?1IDATxڬgUJ BH#*(b{2(cbuE#* D:g̨ü_|_z>s]s\߽.k{=k?ꪫ>볾 ۿW~W~7^u{k_'o.???hȏo~|گ//~K^/?:OݏN;3;K.ys㬾+[[x}ޏgy{{c|v4x;_k^~ )___U_5_5__ϟR~,''٢cO~~i `<#>_g ˛<կ~b'MM^//xK_&|gg//"ŏ37 w~~Ї>twvm7|?ۿ}WW''o{~~w~w __c&L~꧘$wg7o6T;7/o#i1%VW~gg࿼ɒ>ϴnoŭ__w9__w{ةW΃4?,Y2'?P4s`Wr X= {[w!7.`LIѐ8} h~~hwgdi d菘977 ~~?${&0if~,'!(}4iw%A8oo/R뮃.ra y?'YA_ E$tAO{4x; k!>f҇=|G+yMyOIn@JO>'J+ϬS`aŢ4@LB7/oD|˿]zB 2 =Q$~ȴL-b7>x57C&??d0$9tlB&y;gbRvWTx5װS' B( ӅYſHK)BtM i?x%A>%JIbFZFde nQRњ^8/C|9#,_rnN_"x"oucEB҇x'9wC=@[x!;PE!+''d2??EÙ;_^CL ^}l7.HpC;_ 8x=+_i&p</;1K'~|%m 2YGűqZ!AF2Ό)!.C띻\ѷ㿜8xV~~SJG|>tK'scR"{AZ_($üs̖2'#<0$E ˾xBb >̼d,)tK@x~|~T.S a2? R`br֢n~Ljz|fBH /c2?‘q.Qi]GPGPȇ-ket 2"rw~r {<ɫWF {c@x\yBo1~;vf@|[َ*l 45k/o'6-c[;g#a,xksNeDխNӽSK SjP}ѐġ+l|w7UaxSiqLdy49%HX wE)?KH䵺,GGCmdc|BR Cн"߃8^[_+._\vW<GMc_.:fSβ '-HҪil;!,Pw !?ؠlHڅb?ؗ mU5/#)"!jcNM7#`*4yU%sxc;&IOC*Txų9so[dE& 6Ttz)u1ؾ~?hk< )gmJ?=ԏt_p=OɁ~t9D>XNp=I{.gZ_zXΜc1\b, ȹNY̐ǒiY@ؖl׎k}Dsu"! ><35kEe#EP1S"NG,cA::]pL#'gV@K7 ^>tæ^mb> VÛHBdPOF6OwVLTḑP?!6 zbx͇:y::R0zW䎝ѓ<_Ӊ@kG#ݮK@[0;L`U7@ϏL4;Q$Tu<$>V"Eӎ i,h!5FŮ9@a졾Ec3."]u3iYVy =3G(q3PEc]*JK'<./<;U"/,lX_f E(;ŖAEZGw,sAZQp83nMӂ8 r-S@ ^zR?Kr-܁|ih:ЮQښ3qf64-z0N[kxG,xZ;Fc9&Rk_a3uh]#jrg!"d!bYЄ#+稴Hʘ{Wzga@weL78~!̨df<)C4@S}~/VqQ5? pnp0./ dԊX/ +|_SD䚖PvNm&E4"x,1#hh!&ںQ2~CTJz)U<)ʇ{DV*q[CWPsIX=R ^DJ$;Յ=oB Alӂ.!q34T~17w]8 pN87"-LAڠuy17~|an]09chY[a^R R 'c_dbԒ`;UC<}*vS5orh}1=7en@Y2h*эiRRm _d8N @1o0JyHN(f1Sj-ĩN/۵D3jt26kg?P-O njfy ]h'gslYSJ9{e!ϕ| Ezspдֈ~[(Ypj$f.DBR=y_L#٤tCL+z*v(d!0C; a1&YW wSu_g69L!='߳H=}jfy dRV2ZنC]q3s]/;?ٰlA09`o$ 1@\3[[pZJb1S,(2U[sIEG]wݵL >W0? qX@U֖MҏjY !cTA`[` H ʊB9_32^y4d Vy$_D9HhT, BmZK:"fL{z죃 `#y^@IQwo׬]ӭqM0ݣgdK|>M73dF:OKYOz:,jôRpz,3_ %ky x8_atB`_tbe 2@&{ l{dgMawXg&Ӿd ?A < L+:2S2]3WvAOZSvKJɝUr0 %R??| !>2Ws霁7iv3sP]qdFFZyՄePh1fej `G욵&Q`̓54xeLc752)3^f}i<4kZfBmFsAH|o،KTrJZMKa.)UfFxi=S,:|j5: c(Nz*R4ĹY5ٯ$̼|/8x WV)n(Y+'&ܘO'ys`6$3c4`Yfln sb~P*E Yli ҉cK$xɋOIhkYS sk"<ЦGc?yIԁ6`Y"gie:h}1̱L(E̡]ud:"sq($<5CڣAi:6S26}(7WONypݳ쫮w3O4yfKW-tW=I]ҏ @[z~M6ȕEb:^nFCu(vOVE0ڙ\_g*?E[b(ZY!] xTnIj,daM%afͼ<e,JDTL @EmO/d'J7mD²70{A bh+*3ea=^#ԯPҙ>cUiI^u9Ns|%40(9?g?vّU U_y ݱ5fLɭ2?'Z<.<=0SLj*9B H[[g0:/ -X^z%\"#e*6zAy.aHrB~}18)=vySJͮE24v;1新wWGĥcI]TXxԴI*Xx 888g3>'`Yc`VDhged6TlKn,%sٱ{x\py睳{ӟtGr–#`bMMEi BGe<` 2Q L#~HiZ)l WY4"S(Z՘_?4&NF!+a]Bӆ+fyVA0sA]8P㴀 2@T-ѣ1SіmZke DF30+l071T Dȇ!>)Oyi8y=%;94+/R6d9/ۤJ*#Wj O1uWkج8-]FbXL0C&BUn'q.|ƒdz%-%/0)R3(|၄b{Hndޔt84̰3$ 6&FcX95Eg+,f65"_t /|Ӟvg3Upe]{0dI [oK ,]sfM1#YQb0}݄ڛ=o݂3K-Lmݑ[|1%LpLs Q| 4W̤ 0EȳadܠXFy3qc?a MPJIY9A4ri d /~W_G؟r)ycG>a{CЇ>Yg=V@/[f-dx;Y) y.d Jϵel2GC!+9ߪKf2,SFЫx֙Y1h?؈wb5AԂBe@12fI@&(VZt weP*)MLz]5jk d!.BAC!<{ /dVY`$; uf A:F+M]% uq2Z4ԃ{f`K շl_{?,G&;c\! F&ty2#4vUb$bQMhaX*\drUC<,5pL_:OݬT}i my/>Ϳ|Ga`!l  * a T?;>1(}(~PڝI\Ydz~bVh-3?q8*7=y)_D24X0 %8m\"Xr *+^p/\iizb7SL%"UW]Ѓ׽Kxf@ vSqƁNh[Qx-| MA"VϤ 0_4=Ub>e6MK`i#Dy3 f5\e }lqJ)&2Bͱ/Zlк|@BA@KI%7[K8@)H7.ҡg Hg,KyՂ,#3;Q p``#{WϲPgr(,@r-qൠ0 ōJD=LDFtY Ꮋ*Se>r E'&hRf  jA1BX)oyv +5kJH@`2A`@2i3[5l eY'i`׺ ]fV^.fST87 1>5"` 9O| eLnMP 4פ|0oqm&.mh]Ѩ\*+F\ 4`&fN44O R2yLfaw)D~y9 `^t̙d9T~121g~߇tekhey[w1-0 4 Hf@hBu*ma鏃)>.F_m'I*b*+ 6fW6kH(*-Yhzm` [7h'4, @,=oLJ@ߔZCTjzy721%/ys;ݠhA؀!y7gq_{Gb&iS3Lj =Yk /h=vlR2}jqi $ fˤQN RN~b6&mh(͝>-WIz\}LzM Z/P(K4 2얙N&f o "+y5Ab: hDr:g!,. `,r0B,oZvQ"kFVf}wtaŞSoڱ"9֗e\s }9@G/{_wu!#誂Y8qMaH馏>zj>iA;fėEf<;g[7`03 DFB=h:ڟ~\`S(fU'QRÅ[?unEx:lm4lx$E/w.ȬH!YI;JֹS͹mtդ#`tٕ5WaǍL=\]L_fz+B_qgyꩧrr)O^YgpW/yeE{ DQ]RR$Z9AY55"&\$j-BV+Qsxِ9>i炬p>WWu!2~8e(Ą(V-"Jn4Bea- LB/zы*l\.xuaS{s>iu'|`ȓyDPC,?j0'?? .붓3ĸ?<N6K tNn}D&>`C>H#a=e%=_ӂgj ,ô~'%W۶׳ϒp^ В()O-HKU!mRmAڀ,g]*l K 0J6sv8{),NAaU!ʜz s ]BׂE:Kcujo- `F4爊@Oߏ /wu8G  L _Tk~U҂"ЊȡlTW=ItxIV``s7*۞^u`saդjNNgi33Jŗ>E$…`[>-qNpaQ|=iY̺-Ҟ15I: ~31?jn`{mv.eڵ1-3jA:7N{$f y|iU?ʪY e]_HYzGCٕ勶#0 $pN=xX6cmX2 R0:3_;Qu5W[ӝ]ڑ!^1$G|f$)ְA܏˳&VˎF0IZ<U`hlXuK(K #`f.1зx3 *vm8LϼX$$X%p?x4`g2k>!CfPYq?( `Me|Z9t9:n}5,,͎%5?5甡uxMڙpVZ`hy ˋs$I^ J6qf#&֊#6M/ߝ :g}*KRd5[v^t僉]98uXb 瞧̆#8?o(|A]55+;+p\Ҕwv&2ɢ0ɑyWRҗ~ 9SKϰfw~,Wj|=U5;b*<7 [B|Zg+El -BseץYJ7Dy0_صA[ Ԅ!8u }P Ԯv DmI/l)#HpT'¾#^5<-e&B7|3w}7<`||0&|؅ʑbߗafjk,2Da֍Y۵EH BikirQc7洠- &BN~*ſ߭;HuEj)d@,  Zo2ga6V3O d,Ɍƒ@NV \|z`$M6ٶ:h%l2+KBhڠč*,P oZ}\ӑSG|%^~04ʃ[7Z_ -4o0" ,y>2,%` !fLnZ!v񃤁` 7 ^[k8K -E˭4)}fj05YfwˉkZYa"P>&NEs-esrbR 7xib@̷ Y.}$5FV_K[5f/8p!&ּ:Y&l#v'Qx @6 Al@<}elŮaA"L# X,%3gRJlzySOj܍.n^*KW&|"6bǶs˙K;MSKW'ZnD<'(O_cS)+&u  PT2c!c-jbI`ܠ: 8z(5}C\[An"얰h9* X[ Sd y&n h_}4j?ñ`}4د?bb()lC?$٦iv,iv5!- Dpxa)|AފlZ9KzQØ!V͝f_ M3~mPtF/b;΄׬+ gf3wbɲx0P plŚ30 UgapV,fU7g rN\9ti&ذÛ>J9pnjYU[\l9;WHLezuQET쾓`/~"X.85ӟ0`9s^@/6t3P).D" X_PKY0ډXa V¹Qɪ9/a:a1RgqVADڌ(r Pbi)܉[;â~w4Aug:==i(\\^ tX+1ԠƌS6fr*d.2-K6@c8W`CQ[9{4-b#OcnacEґ7l/A,B]@bၲfxsf#}SeL** &*.7$͐lDΤfS$KK6ЃwJ>+d 90zc}I̜} tf#Ǡg9G81'j얃<%S{e1GaPJDDs)qTboy(K`[J,KZhG@U`we3Y^j<1, 7T` ͰZGV,Y#/X2i);I6]'f+hd;z %m' pzØ SF)+6gXe`8'qȘ7@{c6y,yw&mџ%;u/3Յ-x"b[8ZzfA\??L Qg*Yo4u.MX9Wܲѯy ÆʐUS/0z,[+gʋreQ*\ +^*,LM5S'4%sRGQgj-w`n~ؙcU `Jn,7.Ub@y\8^An> 2 λ@?/:fj2?mf3 ۹P;$($]Aa;5lݯDt8SC*V,eq|\\Yju9 |b8Qn MYAkh]5qR,mg;K*nf}֠{2jZst"[pDlvpأ:*aYhk,ѳ #ѝ7xЁUvek2^rVZ٣FPz*' Zˉc$QuIYZByaH-k1|Vd(2@-_2ov_ikWTX%#PSryS}m~cE|f?-'m0sT֤5bvۜ׶}r`%ħ!l W|sa3ie&zxWPPϪZg\VT].(N@7e[%%i͚;Sp,K Um7\-~%z:Rz1U*e+,Ꝯ\vYU~ "*?R/ RؓlPM!hDizjzae~z>=k 06_c5$'t mcaeŔ UlM̙6sf:~N DA1eD3d4gTᕻި6P[E ѼġHr & XnXSa%B)1E(X6o@uY'-+C`ǹ !jOO~?3lۀ,.`bJ [.eAq5g! a3gۙ[=fR4UNYm ^zT:lw_C Q-- uAN7Q?oY.{ #JU~K pJd&MNӼ`-R8EyOiT'UR[|VwQCKlbmY?{^@ } _^3,NIwT8M?P< 232No'gRR]r <6 ]uT,zS˅ܹ<% z黥)+J g^yP&)mTbpy0 caz e8UV~U+BQO(htaWd `KC6Q}WsLR?3l24Xb668`1q+p^QRm<7Z_EG3SK! C^3 fk eˆ}7sgSh}ɖS}_~:[ .9ZQt̒kDE/3|^080XӸlce7gXX̞dSjM0GoΆţ@/:%pw DV ٞs_msږ,<`!_.@ܙƪ*liÄ%][P ]HaD^̣QBlmenݿ'TF;j? YQZ娚OE"'hlZВ'*16f KdLf4v?B_ƖRfM̏x.FpLСx//xcf^S2vf-K,bL,gC2=lZm5^bYx+Mޜ S.ɰ0guaeZH ~.hS$Im8f'TDtК^-Man&3%̡Q&VfF H¼JaaSet&՜U}Mij5>bqЙLafn)NmyݣZ`=[t+\ wrU2$vU = 8M:"g92tؖ|P̜y#*aYf5.73D^Q]%G7^#Xhv}; rt|s7k"G('qĦd'^ұa&7NBa* :Qj]H6YjBj8#᭲iMm'z_Y4@u<Z= e@vd?gf KL`׬+lw╡{TT8A=lA l9PE .dbiN /wjk]xY]1%TAn&/mK*ZĢINI jKUלmbNVZ-|ħD-h N~|:*P7þ 0(S@Xٛ\`TUnd^!T;{ڗe=j,hBᚩ ӨUe-g`FtET * 1!9~dw@3¦#4umg,2?UDOt=%i&Io{j9tY3̀n @d,J*uD*7uͨA{R^b3 ~Й6,1TИ? NC=MT@wJ͹GXl`Vkm0`됝~|AuX m'ŃlaYdǵH_iukMj"Q )gQ?( zKH BsTQ1*#Z喧A :’ &hL;8YaB=o?@qjιN_;rvS _j Nwu MHwZ쁚y:ZbE<pfW8#3Uz"{.]JֲVC8G~;quq]ig K`QtlKKTK M VNrȠZ2uo-wmGu)Uu4a}Vt_[W:PWh@kMH!ۼlzW:|1' ZE` }n¶&u P@z.WG9RL%tN"ic=6[Ɵ=VD<ѡCH$IPw WW3ɗ11+Z5 gpS1zAj*XbK]%-Y@4vZ\9l2 ֢:;=S&w+U&D5}>aJqP6d!TPZfL3S BpTeeKG ZP !;)~h[ZVGJٝeb5T@P`ۨx E ۯ5\MPJYʋ޸Ooh\n(*Y=Uͤ5e8D'`M*VBAzlSؠ'ֳ'/VZ%S~v. ݑBlӿAkcDu># !?[U&@f_rJLR7, )UNj^!t]-4 Jyv_0OwdAU˟%]iө>iڢ&8˷(Bo53Uk'';>GSVH*A/|u=G@ȹN3UւыȈ{<BQ=׽ TqKjh:+_Q"04hJ[فW}'-IbXx 3ARH˩f ipi2Kc[5 f~GK ,QX72]*NIkA9^BQobiCҮBp)TrLVć)==Fu9Q鴛KR؂?1~ 8GwK}g؃}cB28@zCMA*" BE'D(SjIҀ'h;FRl%Q>۴$Eq}7s:z6˝Zddsu8@+sD1( LDy CR_0&vKq05!RȻpj7Հ4wsYai$TLx:>ό4GY*z0A3\OSũ3CRY9z%0y`0-HT_(^ E[AbuWtAIٸW17U"j!7@xoz< fPփ#V]6`6SFq_=NIA9@WT7"{ dxfI pJ/#q,.DeV]2lftH2oUKhi%Lzhnt[6ˬvMk8pa`N$GD|%>DJ-OmkIXs3=D3oAX\ [fq .EH~LxIvCl!8 wP+Ylҙ}8/ 0dw9P*,ʲ|@UMoYHÄY˄/ .O:* 6fTN1V?'Ę?iw2bڠ# nz:Ϙ'8ڶ`-rKD$gFUHK+Yd0-1ςgzs7&(ʶËQ0PB-,4=7 I冷7r>ֈv= 9uٺ˳YmvlPߤ;S. yG{yg h4T2Sd˰!`٫@N $28*;S) :'pxdKȥlpZ e *EAGCg}ST^cpdlej]IMuhS<IKnHcTF&>T,@`b6.} Q[H(]v_&7O{R d4.T~+3u%K!5#7k+}?F&pR؁AtՑh碲w}[л7BNOv5:\wygu1 Xl 017 ` `+\lq`b))[iO! ew%78è^@GģgpxV3_`D{l!ٺpC%v(͆iZáҞ`mƒ^u4tw. pL"2DyT&Ru7eJRV42̵vPg< XYtFpW3a;[\iC2}K-Q[tfoߒH%MtbDQ_.[`#8 R Uժߦ֝i솜1S1xRf6֋\R[^:TH2R\rqgO7yO+΅Y1=q4s4HOx͝B,֎Qt*@qjpg^N [,tQBRۣ`d1ԒR_2I';"S ХX`u8891@.יlWV$* 2ܵBK\ib%-_c 0˗/Dkcwr'(6 DZX}j>/ M ;<HN ^bwnܗ7f: hvKىe\@1c4DŌ beXoif:佝^lq t vu!7I^,zjA1PGn L‡g$wxQhMTiؑ_3j4R$ˡu H`Ѷpv_9,-:X9X 3 N92LK1Zw#C&@įړ Tණ]R)'Dkvݛ`>ͬmE; J~4_\bbX.o!0f[ o@ 6[z,Rz4݇]ygJ`Le+ 0cN# 1spY,$qfYM_UB׻`L֪}ޒ^vJgd=\kUo_ :/5v8H!˪\-[u[byd䏪4?f~pj Z8dMoTdi#t׶Ŝ7orm`O&.|r?mXz6 zZ m%SbWaC>ِYR8ny]2@7@Jm_&MU0 O<׺Ԋ g7چ.j;z]ϝIӌv䞂׉ ؂H] #l2^{oB=Z?`45f& O_[JY!ֶK?̓`K/EY W(cߩWi%{!FYϯ8TYmr3S֌FA (}'2xkXHmIǜrQXNGVIUa]RV"9!h,J Xb/ tnoe59j~>k5k1{3(NoUP*LUh۪vLٜ|;ыJ7O[?Z6[7!/^/gmNJekNRq"8 LCg*ymn4'{qV͛=]EaYgr|yլT{XJNn^Q,x;J'_Jʹ2aBj ܪl20VB͔! )50Fwdz,Rz SeG#=s J)?: c!C5*gla`D~'5A,ʖٸ5./O V ͫ YkhDo7;Deglk@*\m"ZOijiy--b;:`S@]6 t5駟=*Lf7h2Bު`3[Lb/aņ*?]&@]ΉMYRKp.]K:w`l'f37y@`l`t֑V"1Ũvo&z㘆7ҼcQ9 ۻ}?wXb%%!HDm~`i7^ w A.Z8_"|I@ Ox©zg,xNW,Z3 bw|676yQpTI*B ޛ2ԉtaZj1@=_=[ yb+/in3v}HG9ſU⺙_d1'Ls`@'~AZR,&">T3@̞X,U,K ~>U>SǺ8Ж3γ xN{Ӟ%>a&ZIh 'X'GYr3;&n&h( -Tu#`ޙ`&uv8f#0,}4D3c3] 637hxRڨy(V1 ^ [(Sw|#>IOB тA;bqi6aR=8S\pW\qƄ~S7y xlc2俜kS`Oĸb[ b\=(̨0wݛ1t .N 8iɭ[#hvg$ļp?Or8-@b׋JIg]LƔtvwĽ!H8 Dz{G?-3 F2'?6תpw+4nPNCjШ7#933ԂloV;] 3vf@fzMoq3[c An 1Q>M/խ1Pf-u,tPaW͆~<ūP b*6Q^t3'LZP1q=U~: `Ib;ϳEuO^XuOQW-ֆBz!oo+UIN, VZ"(Xtx0ǫH K陭Mݪ@ % m[rԂtd_%n=cLbSY9*nLT8Jp} aC3.:_0PQ哟'NGLx6ƫ(ۃ1ۡth!)Cqq ;IV'^dÆP hrڔD5&B6ofx ,ZR1@js[hA Xb (Ś1|JN*S{KKahdZϢfK^ e1-bCOjiuWBF gِ~b'#+Ze y+ATmP9 co@;xa2fpf)%F=JpFfmyן8 lۦ%OPh!a<Qi'/ǭl,p 7 $|VjBC6E^) y 51Hi?sg$dȺRzf؀)pknٗK3KP6]Xs2@*G3aXw/{o8-9KeϜ%w} 2|3q"Y][beTAV~iE) >ښ庘=3jw,=kȆ,Kb.KeU#rQs@; /_i_4%J^f=0_/, VTl, J9Cgf>M+i("Ēn6%G<3ږЕ\X>63Xx[ڰO<`B/VBaaJu)?:v54_Йl(q*`!2K5c@/P,l뷙 &Iψۻ{rrD]*|'k{NuKvM<#ti} }#Q-IFqxi~>5č-m:3jӳ8ϖLd,րڦ Xrm?lDiubŀLgUv魟n:(a@'h2$gW"o:ضR*gA*L%,ţLZ, *Zd٫BNhuKĺS3\{ncɞ O+XFJ"|jpM]^v4YtVNBhTe]Dl2]:MacuLTrHE901UbɊN^H9b]-giVc+X2솒=B4jIbJrdT_b ;} gv6+'O(N6PEQ ,8߇9ӢL4ľ}oe,Z XzIC r)HT8@p8R NXaV [bK8gڃɓccLI:tG®syT''. CCei1fk?< J6¢sKM'Ds"w_E愚՗8Xx`a%&2|ͳWqi/j-=8X&2㕛~P Q`iK'咅}\ J2(w2 *O@e-Ekɔ3IȜ9zߔZ]P *^d٬|"FM-z^ɡ֠3DO 0|m[[n`z[Gٽon?tC #& J&Xʳhm8Jza l4K'1o* zeY :|I,Ό[ַˉYyKS +aډ I@6l3ئYԃ,0 k l_ gtliR(ȏɪ^I儅 b-N7Ѵn3& Qx`d `yCwe2sqmYWk颉#?tڌ.weyI@X&el 8e;)A -ޘ߹uq%f&,0QIA>`;fh̨hە:^/`#& M0F#Z͒!.M[J:yO[j U AP6f9s_ KNu­)z:y1XZLC09kOVhQJ0Pۻ ~o}rK`,--ܩ(>stBwys̒V 4Q XlM>e=$ 5_px`yl Ch A(ڕS@g 4g~s,Zt5.K;k'G7I3}foYEcNe/$b,LbOYF9 'l%HgB?k̪Qtb+0lyZ#teuϬy3tiuȠƐ!\7u`c pXKb[ EޙaMo=k5X͜≀,(8)11u ML?fo9E3-c R$Ɣ;|M.!Xc°şZ"]ږ(Qt&H^ޢ C^1+&RAa̶L6S-JqDw7vk?xV9q,^~E-3M2g%]jbO`bFAu8Zl)/Uo:r-EѪ^`_K%Pj\4zn/>c&D,mVKK)B@g]xj ?%Hc3[$_Z1ZLXUl]>v=L7rݸ;M3u{ a̤<.f#c{ O)6melZϹAڜ'E?/~4Fmyv7}xy.+,5.C ]2iFc٫XIo8?끖[Z[a:C@!1&6DUdz9/[( 4s.nctGM脊}t)6Dg3xA'dR6-Fs6-7隝s7`z!,;G#t)%q;39Vn)u ƀUq C.u F '$yA~҇! .&"g}Yԧ>P.Qu]sEfR$yfňgZ΀IZ:',]8%~Czf_uyE[#2WoԬ/"LdV ϩ` 6/K @- vfhX^~7-+d/x*jTd΃[=bg9i.c'M[Z-ư(dE(s夡? Y#vi=IO:S'/O?tް<~\.Ml# _y啶R,O!L㰙$[op{nH> Xp'ҒZiXm2|MgfI3UG Pymv 66N5G kb (O k>*uh[o;λ~m3\\P*B cEvS kVC4yDiaKE9:>|x5 ڡ~HO~2D>я~#G'xO: -|Jׇ췯I"# -^^, QZv@DZgtvKT_kI39`IG}iXjL#kmubv7IKmOi@˝?i~(?C7p$!]ٿP@ 'ˡ}ڬO`T+ &2rD?% "`68zsg>O|c?a{>x6+N=TT#aaTe܅뫮! E 5Ðo޳Aҟ$N)j4! [gif.6\ffx' ye)ZD Ú;pzG |#>G?Q؀7.|\|]`wvI/(Y ?d]'=^ X*OqP0xBP?<}{{^Az-q#űjx@'A"9km+#s2msZ<$<'6~]Hn˛>{SkVO)0L^Y-2-@Ѷml ׵,?221WRvXf[rD;*ܡ<<={#qW#|Ii4OUHQZ Z/H,H Z\n"]Z#lF A0#GI}v'?w?x}}(%1W6(Yo lBW: 3 j{Mu1lFIKkuf*&Q?GܪiLU./wA+*KwBla 昈F~4lj)^FC'>en -!KFtªZ,'sb«֬7[\u (fR@sVžsH\A: GC~??y=lb1RI t֝af< a#h 7Vk"+R 0A'J٩S!* QxxC~ڈy!L%ӅU4Q&V )NJtթ IW^7/ p*7 U30\xe1|+7tf˭yq0!]^|4fp4~D>??y?x駟s9\\鎮UP9ż)́,}^=Sc鿤R81W`@jL3JT>A,֙ _,a xkX6*cF0?5݂T{21j~b&u,RSa0'SɡWDxJ2472!q/{ ܋.M!{?; .sx@uZVNes/YIDAT":-nv{qBml2Yy8 Z{=ySQ@@wK~x@>@lXBf/E%AL(8`ZxsWHNͱv.LLٕq6)H5V @VCwjIۿ㦶 v.)_J=k,{_:KwOEZ_u)'#"!l(F٨؇PaC.% @@D`~.M/"׉QF2uN€?w3pIv&^Az!5kX¾8v||͞s/<\1{?29jc=gqTyd<[;YC 5 ,y4A,-&I #wv"fve=jBM:Kx*(`g`l6l-[V;Cd Z|N"zi9r=[j\tMGV҇U)UqJ>^ӖK|dbvA!WfsBhg'Q"j-wv/5c /ߚon2 uQ+Z&Ce!r-)<,B<tqyi%-E6_v_ `pZ"{~7qi%P@=QW+#][q UvũrlGsOCql 2 W~9+ Dh* y;'jyδ1kV~–7_i}`;Qlk˳'J3 *$O2x6lG~VSː0Yin/P%pK 2|#~Ke+pڂCL$ /9@oL߰%vMZa&qDž-dD~džL6Y>6t=%dhvC(3Q@"c\˺El%Nfo<,B; 3 b_b]ɽn ?QY$6KFæNT+ǿ⋄y0}b7~Q+Zh`-p% Y2ŔmFKwU@U@rKq']PNv"Oc@X/ג]ϗ"?զ+ȕWp떥+@g@סg-(MbN[ 8xBsvɸ\zn((RCA?gOxw`=|ePO(! ݈I̪<$Log7īyL! > +:aHnkLm/Yeu(AI,ap x`e4֑g8TX?_M vﬖ7~[oyt|, !'un|n,v ?HidFܗ+KT4<|ȴ,FphlNot' N*No'Dj<\O=!h`8.ew6-pB!r:/"qJn{"%F^' D7,Ck cVO>\ﰔ gN-Xdn?WtbESf$ O9;xbÿkELjsRN0fƨ͋-_Al2 rҵ(l5dMpyB5y,]X\TpU`y`/C @Zא,_ύ-Ο]j  ~tO#f*ːJr9K*} K _WؖJ{!SSHXy=^n&Or0C@j,*T]CS)7?x@鼚?<X0Xfq7nTN&!x+'@rW7nU1U!9g+Wۿ$˖õaOY§Y`YM_/]7xدP3WʧDˠgr-/ ARI,V<6Y*knI' KcJOr<lWDsy&@U`:E.\]Kۄ%9@0*Y[d#b:Y^Ž *U.u+kӦȉ$ee<քڶ7uAdmA7 [+YWI$싼4MфȒ:t #qLr878uLUYCWkn=^UB& Zq볩pQPn2y[] pAEAtbݞቯtL۲!Fd@n9j+VY\eޖB;!YNLH+t{&r -_Ւ?xڞ#8]+Dp/ox 7\չhtϲݯP;V`moO@GNAu֔RP 鹂7rgWprb^a]4kG\߻0- ow &4oC&I]m\%{ (ː )u}r畮^U;z!=S*)i+NZخHTJ͆&wXk+mnh+#x f{sS>w\[b?_[h5RЉq.\d5 `oX7iAn|kR [J>Tk U"Zw8ЁژWr6if%YW}U":ka|b;A^Df6WoyȾ+ێbTs [p%8TU;&u6!ےcy\*7p~8۶}M{z5rf`clofI;ל'_ VEV=Fޭ$HTG]bi{r-Qq>y |P5i o&>m‘09C9ɑ,F5pk؝;3I;ÿ u^ji q| /BВXuUk ե1o Y%<ݮr #jGH;=nوjy=<,gmJ |=T:Ds&km(ډIb\QYcFvt q: /URMzni_' tOM@Jxq"2H#5h>nyBͪ.UKA#-?tPw4$[%|M lV.F -+tHS"*E8X{u[i8GʐU2蓥g?FݞM,$/6Bu\+*p3i^6b_gmi&v`j Э6})⮕2#dPA+ry֬a&fϤ#+aҕˮ#W*1+ktd[:ǒ$A^CΧ;@ e/nZum.91{BWqњWDօknYQ¥TH09UM~65`xqS) kAw؞cXcCSRTf$%Y1];:j,w.)_E(B'<-|[n^a1;Whi~y8X"i~70Z[+!U 1Dk3,.5x: WފuKg[:\bZ ے%6wS{e`0wAX8ρzmǸ+\Ȓnp@싶#ˎe!UGvN'mT^ʤD8e2Ď@%Võ+gfVG-QOvbxjQꫯN6x9J=H7-\g’`QjŮߚzRkW6~._]]yҚ.xk8?]"HQMCh6-,WfO$܆[/d04nN-=@W..˧L`Qh9@vQ٭SEeX,VF<WTڪ%pz;ɇ,QEUW%aN+{Zj?,/oWۄ&5g=@R! N \qF|op`[x]>ݕ%ؑ=n@Tue ;UYdg{2 V~ ID9xQ÷rw@*QxO%֯2}dC. !\s}NނwusNjKŦGVcB5 tp7C0 6 .LPxĢP>; P_91+`׹MChe 0Z0Ԩt:rx 8̈&xo5)v;N1¸-U3J/rJPPS!瘓 &,,qO9Z3uU%d!?b1[yg^ ܝs5/Sv;&S_UWP{WhXK8,ŮuwҸ~i ad/E\-`ϖP$ilFu6*xGfq0p-Co/ŜvJ%B+XxT+KdKďϭ3Ky!e9#0wauőx9|e-|.͂p뚵iʨnPDv5t^Z!Y[\h0? 1 m>&zweZ %'[!YVWsv ]1C'H؁KPGh?-譭ZϏQK~I;At:A5Qt?||-[[\|[!aNxDX~EY):hHzǾ<8$p`Y͐~S~<5 *ag?O}'>aOg1&dd2[sM7НfW5]FjEM8n H]sC*|?REu/#J[a7H#CI#gJh^!An'?^wE"#+u-p/)C3 s.rTXI^ݶ:W iYw^|Ї^xᅕaa8YEuT-iiP'H{K=j{%VXqU(nXG.|@4^ʯrӦB ɠ`ogeYE2=Ixb,ō0T[օȎWgWtAw:[6FX!ym-{J:elkœUv-_YزnHaY%7~L_y}PWYMN c"Zi2nnl*Q[;jܲ]uG5=ӀJ!{7eV^)v Av?İUUyV ix[я:1g*Ȭr8Tqqm<SƬy@ 5iC7fly`{ϐŁzBĀh$k//hҗ,%PsgiيaY Uğy,x_~ {饗X^Pn?eKO$bhY%{PtTY.pZ)aBj 񕒀Y"X|[ iU;1VМɜDx0d\??p DsO%#hy^ eStQ^1*ʹ@UṼ}Y^w <,+ |IG|.#yXQS/İj`r/2漎n1PPBR P"4BB_$s`H ,۫0c86M-TX,3`BH֊@Cgc?cB??|4eX.D{ء6"B,3%baoD{=vfrP#KPM |l+/ ##5[ ֠áfuZ0.H6NUlKn`v)_?vZLTwj%kC7-ဘm*E6݆, D}_,߭+bɔ' c?_|  $ 8 Zٽ}IC8ox^~twQWjZ :7,*.X8'Y-K:)X^0h $am z AuK80r 18K˂4%\{+,}1ѿ"1/IvŸi9rZ]1&i2$mbt-UW"$p|3wpH ԧ>:4/ɾ{:QM],Ⱥ)TJ@P7@[7'Jh./?Em. ӚG(hOV;z v@]%9vχZ4C`乔]Nj %+x|U ec`w`!LIӯ͕nnvdtLwu5aA7gh/nOuC80h~@^8 d2hX{ܖ:9+b\hl'ދǯ[C;5$Q3Wʩ&nLHNQ}Zק,ŸrjL>|HڅŊ.? 40-NJ%њx(a$kE&/|"9~MȣDb֣|/.N*aW5-_.&=lsd:ke"Sz Hݎ8,q'o,N+Ӹ_+:l8\Q?O\5%-@V?Yܣi<Ԗ/G젆<'&p_ve6Z!#m-b0|`X.']ODl(nܘǑ{buhx]k-Y{l;H1AZ;ر]cwMӛKbP'l?u!t9WnDhcKK[ՠ$Aػ<:UhGśܳb.eύ+e-+-•|7 >ŔF.YۥqԢC<" lu[L(tg#T:SnWTUwFv ,OX!k`w KƊ^oZhaI[+,1J1ɳhawϯwÒᾸ,v|=\Ƿo}[x6,S|U06N>@;(w~b{Ÿ&ى>y{=uzDdH..u*j܇JEz {iUpmiך!xCo=9Zj:['<5MByD-}f$ICib]S^Li˥|7s[X6G08O7;ZlNv _ݻj+Fv"hyp_ a9xmH7^q4$n|kVxVXɱkOBlE&C37ʉ N|s6  6 G]prEW#'M9¦`[=w]7,_0Z =1v7/1Y<䦯X?|V;+bp|ó|f͍rӘɟ}'+tW71b_;ա=- EDQJ4 Ra+Dҕ@ -q4|#ѤN`_% rɫ/م١d@[º,(gʜ's?fv}GS`71<)ra`ǡXm&_5 Od3.hLz`܍}' !YD¿yVI2j wapoI/KR^@p"( E8O8ۊ^&%;vKOT/8q'% 6 8[~6uvLvF}OO=~0,3ue$i@5"r"9/̗gx* ϲ o Q)M{m`637_/prWdQɝlv_-2<} !nrUtK$.ON o#y ` K1/PJ,j?p8#c:>q сTqOƒaF 8yxiH89<>m/#VKmJ{\ !`ha4k\ۇdGku(Ɣ|`?Wd.v aY{U/g7>! E|D| Mr,q]OekoL0բ`)^m7m`$'>p`O2< +(SP^@B[e@" j)ԾmP%tv+]gؕ #4^Z"R0BPI"b/1+(RZpL>3I8u)ǿ(K 6/BqedЃ7xm1UFٝGm`ߢy>Pp-C8p,O `\  r +G#i-Ů@k` QU'^u"WyBρM@;!9E-G{c\] :3N)'"e% lk'Z>hʃ[h*ܶuKL?x\Saw'8@@?j(e1u7q b;?&fBq/+rJ yWGlr5̗wIUWTy wGTQc|*!0hPS;9@zd{GV.;*;؀1ـN+DPp(%)Tj$㎁V|:H_㗍VnpT޶,$W깈ǧZ66x/ka>6>^b3bMR衅R feGZh2C@E-;Ƹ%+0u.CVϊx&z(Km Zc1<IBOۖ]%)ДUz쨧@^4`a3`w+P Bmvۡ9yapsjS* ve]i[γx՞L)X8v3}IUy56)c'JVU7m9w&~Ua0^ .B5bd{ib)IrT]aٻP za-z}.0!Czrn0x c,?aZrE r^&D+-"DQz4W# :;S{aF]iC bq @~֦,D2Тkhz ظzA}#6X.v&صO^*Azq %6SZvi~@4Lj2呛/Y!oBwCm*< J LTYĆp)3,}wԈQ[# EGKb?2q=I3ና6sl9VuAaӣ?*q7%u~{LF%D^ec ,Ԏkbamz&ډSI:v F){|{KFk") rg W_}Njjɿh>k|PZF׼[W JѲjr}R3]h|aDI{֍:)PQH{hp}R% a1_`¥,:MKxFχ?O~[d88|V8vmA:K_NfǣWBBqvGWZO :+ F/: Òm 7x+P$CQ]L<8.ъWb;tLKuOH6ۭBrWG S] 1 jH[ǣw 56r^V65ı?-^NO<^b&Prө` yYʽ_y啗_~ q B#"-.Ō@]+E9ݞ:o]z gۓօ Pls_o<\N2ɥ=yˠ5rupzpV'N#._xñኜK>`!?|`KG6i!` 2_"||8+(u=AOX["U?tVf Qu!c:LKl}k@:nhZ&; _C8WbuvLj@j`=xRzUX+WZcڤq:t7kR< ڌIxJKx'jtf1<`ȾX??}#%'ߴ"dm $<ŸucKPK?ŝWey@cı SZ;^yB'>9˚p/@<5_sTEySg ՘ eР׉fMu Bۂ-ף:7ʾK=̀~we@wCEH qlD>=s8_$iA֮nu7*:1`ЁEz^{nhw S.S˩3%KK1N/;9$c!~F4ia==^xIUY7,#{\+i-K2TqP!8:+D{X+mڲY!'@kHd /[Ş4VƓ̱L|ǣ8guY?pAmui-Jٶݖ@_\׍Z楚Z`U(}:$3$X+|?|"ʶpY2wl A]t\EȣR(\s(O<*P縜IzEy\9*%D ßipIufFe>S`aDRĺBԮFAFA|5`+.>tߤЮLMPqb e{׋؎q3HH0R㌺e:Yuj[D^p%0ߐB׈-jXBIП[Ͻiղ" ? ^ڭF`%tX[*&y@cˍ]Y]|h dڝhlg>^РV]v|jsRDq }tm.{Im7QF,OӠ.!E(y#XN KE*UiSLkR$.>P Z 8m pWmIʼ'嶷ss:@bK$+Bt}#hsrEwP4{,uޝ[S; t k)+ĹD!'^N&K5.GێE}LUKmZGn"fW4~&2g?+.[/ (mJP,ߎ :y))`ܒ*Ƭ쓗-﷐%[ c"Wv'?"L{y祗2"̣v2!eYjn+NUq:J{F%l0^mX긥F"ߢ'[믣H?ǒj2=;&;vv˝[5]#7qMFhI FX|礊,} 9+XƻW"|ǫ.&ḜykNf__=0WS:q Y ݮ`U]7ihTIqw\Ft"RbY^ص-{Vc ?cn%Qm/qP`v!F7uQ Ct] u> B`8~vHMOl |1ɞR5ޘ[ ǼN>ppЬe#/DmDԑsܴ PձywI{;"/ XStyq^ Fm'T)Gm_IDd ]L('1!3<ZjkKy`|Cb$P [r !O{.;y!=c aXdD6>6ma vJnu妷mrRs{\ƷݸIKiʡmkF$e YؐɲtA!r35?pz>&c6>E”K:%T U,wu nç&6ؽo+V \n7XcQ mX)h &ITe2ǰ2'hgAUC)٤0yD~ά64Ãv;%yTגO,>QcCrmX8W<=c磌~NvB7,™^;\xQ*6Xuo7+M*(,-;hR7kՎZ49:j1M*;!ྣ`z!P LfqPKm~Β[A՞XKjl, 5U/.+mJ(Hu>!NW|)L~iIEF[Qy#YtA͸DP,h2V B.v_Sʌ7|hu0TK*gϛ2z,˃GO1qo/+hje[i:DSs$Iٴ39@C bN!/X o. ymƙS Ioʓ> e<5>s,"zC[K`JY2<_L7ߟ Р^ՈbC`Uh1/Okh_8(7XXˮc! KZ2R0l "V!#6Wrq_ /갱zȨem슡Q y81EtӀήDQĐl* "ܘ%J絁E4[mA:" m寜tJ@TVdQ]E=d|P:@SvLrEaUҦ#'uN85vd%ZEwcRۼmͥġ>rnO n7jbt%}wGe]zay'=}[Y\ s:\BOյ5s0x찈a?.«&$-aXPanmN=ʳ%Gz\E_*'@X2/g¥ ps|u!P؜jAOOU v65j^jOY\QW`}pVϚ>u oj`V+uBtr)7g00}Ꮾd]ӿ:v4M  zw@`^JSgiF_쭺^@ˢD ̾~oX qϠys'bӑ0*F.Ee09^}Mq{nm+> <٪vp;᪯|m[>B!1%[x)?Qݯ7^KydsΠo,Wt.yϲ : Gf߂Qv1㫚HW3@ʪ3ŁP\Ysܰ奁#VAtUTnIT'ր-Z8iO9zK~"B%a:ⷽyZb+mVs+xp-ȯ=q5 Yn#?hhO ~гh.v h #m .מ( <[ `=EBUv@>TL})4j.}GX Qcb~Ko0Wz{x C@ʼnh]ZVn* z}ڻ]/RR =WtcMO` CTo|]-QjY84wO8DIQ+Wk+YykiŴX ¾+n 僜g-)Ndz nv]ІdG6"Ey箪hcsBN9P./gq_;vܪfeƐ)J_ǒ˷jƆsO TǰDnDM `3 iŊI-"[ 2Ҷ+N9tQCLSf nEevir*֞HǼ8;:{ikM#\ƭ`}I{[Zz,[m$(&لS7uzG־#Ttu24Xo0%HlFM D =]QTJN,V},ט+6洮&m!.;}nXV!i)=.¹V@@HVC)6uS;9[R{0)(VtOINle_lߑ5|lG*Dp <rJ6rۆn] "k/h ]&$6J7c(YXӰɞ VY >9ѰAhxf,cm3+_1+5Y믧+si|޴ FhtxvFs?%$uŴg)$MIvw & K[\N9/Īt:Tcz~ E1]%7W%lE=92PP2f:576ZLnxs=Y6%[c}o05 _x|w2n 'UPQoaW뗉_ںpQ_%z%ֶVAzwTV6*P۷q4uy?p+@]']AbBa=*l4ٜ4e/3#],`{Iz.!rt:@@7q[ Y&x )(@'nas k٨w|Js9D&JfXL*U!]75Y1ڽйw!\Ў3\9} yJێU4j=\wit*V4:}_G4b!8:ts tM 𾥉җ4d(1>u!wc3m9qM'S+dJT0ifblT:Am:XUb@ȹ!nxiL1[9dYΐ |.!x j9!+@]4WE}IENDB`PK !=`_@_@word/media/image5.pngPNG  IHDR?1IDATxڜg]U3J  Qy{W{ޱbｗX{`{bGcKH'~k'\"_{5of#|ի^wSԷ_o|~>7/}^Moz;ַs1}sG~ӝt[75q_5]uk>cg=Y/x <'?a{z׻z.w˽u>zԣ|3=q^{[Cҕt+^׾W|Ѓ<=q;M/~'<~#8³ZfͪU.yK^z{\/9OV_?җ|൯} _B<)O<1hFx_u{VoNJ=iq/]"~u{ի^2́?z {'?ˇ?aW^O~[0]Χ?i}$(|ӟ{mo{~{~M?W47w˱{QGyST]'=I=n| _E׿U#/zыE7 k H.}Kpԥp+,&7Moz춷~w"~<^aKk?OLQݩiq$fԺvy_?яb ~3_'>wݱ t3ET~A~v7/oNs9!iv'A |os۸jWUr Ȃ2^4Z6H;ͭnupȏM $0W\yK\׿>5|I'_~ӦM>Zn]}Ox Pf#T)@40`1A4i q@X'F #Txn@~Q.1Ak2$}՘zj° իWXab@d#Aֳ4^)1FF0\:K e!^GIWxRofb6lذqF "<=P)u=_W8u&H}ڢ"@fn;]Tu8X#fV)^(si@ KH: 66A"*2"f}Q#b"4y#_n* YtFPE'dSO=\Ӑ?DDdx!UGFDX%'GV#S u``ݘ N݄Ӄ,{F $flwCIWk$>;spfA?qhR5hg΋0-g&'-7@kOcM #dAHn#-3a;Ӆ,1t=Axp_{`=DBx; ?.tF\ M$,"Zn34p7bn>)0e8WIx|iT4g&-*|Y{J6b&-awیBQ2ZFeT Ffs)l.`Bi0K\eGlHFQT5hN75O @$B.v?Bˡwn{}1qamu f} AcKW;t2(M%fgy !Hw*t=a]eS ;25c#YCIPQ@ɨqlئbes6It /^6;vl޼YXi0ofP/`H1gZǙQ5R`ɒ%`JIF]#0(1!ݿx="x˾ SGЯ/enRFfQz9m߹bC yo*@7& {JG,mm7GѼhpo / M2{c k13j,fl@+fq̛‡խBRߩ(sualw8b",zQXZkj8jMj)vH2:nk::BXgq\qbjmM*~L ƕ%քN43_#,bÁT d/긙gMN?t#?[AdVxAwv"hf pBfDb,0p)If>?.zы B,Z2]S@ {\1^u_[ ?-eթ=L*Dq1>to G|!`:`jaK[h$%mfs2l—4}b6:V2~&bЇyduhX6Sͤ*"f6bS,v/P_O6}* 3a~t҅aΦ,kFCY\*3BjΘ*8}@k:HoY3[1fJFl|>c θ+nt欳:sXq\1 0Cs>$R'4070Qtʟ\w +=Cm1s=&! }Z,:VhX82@jZz -#nd릋&S7aC8]VaoyD,PvV&,n_<"-47I J5D"Hfiox6tybNj%;MV ``"  S5c[)|d^^2f*=@ H(P:@Qż=DQ4{PM 3ݐel!cZ:9myy֔ɝlHՔÆ ۷o߶mMcG0p:BF0c"QB'H_`v9T[JQo:T贂w3{DHS`otuzHָ`4 ǧKO ~GņC01 ft™N}U hR͘f5Zj&RwE4dEE%FPtkjiVPđ=i9/F'z<OaѬqSQR -x< sЦ;u%:¢9m114M$7Tb \2`8NlB[ \ZA(^kmͱP, jl_'ha;S惈h; iI9V8rŠlRHm`dhBU7uh]?]o"fVP^8S.:@HⱪDi 8໿ ffxy10n@}B8;"ڃc$ܡc_hd}${RdASFvjaƬ,a `=`ژL_tGM4dD N0 FYc{݌kX8:ƒHx.S-90tdvJh>BXZ6$1 ܛu2͆,H@ [X8aق ̌`pdDO nc hc;PO68at3r] 5BvQH"J(jiDB::+腈Gpc;Shj,ZYvS&ԏqiϗ|_O]`beJ:_bɂZ!$8Ϛdi[=)֌w^U+>Vn9]Kȅ 蝘8Bh8&L7$BP 0(3xHy/Bqkw AS44qSsXha9Ì~6Rer-0BjU h"._\SԶѤ6=:g<틣Suٞg>:̎(ymG}4^~ƅ)cw0u DPCZG3@9vqt11Fs\:IWF HpABV[?Q MRYsoݺuӦMf.6ʐkO&fmz5CEthb :e䷧ "m"TXymث"TI"Xq6;D/c8tur3;i)Č)NudHasufGIafph `Mpl U>E@4g1 =eZ"V~^Wo? 5SRU8:Efao@_g>Y h()>h|q2۸[\I+ R"즿66oxܫ@nQF?1pH_"{_!D.ѳzNK11y-Hf𤽘BL%~8]nm뛬D("MQ~3]LG e . 7c8':i <\,շPkt X@~|tRՇ׼9;}Lɝh&`F~j YOk@]1,5D0m'&xhBX 5M6P.HztygOtŚxy; 0=*b|*Z7MuC4'1fV +$ #Pn6%d.}=yR oJa5>6"2]{ _|"kg&hMlΞΤAǟL/nFsl~LcjsVI1 (Kz`4Ӏa ) \dAͧ&mݫ_hc8l?=\ ۑ|P4JnPd&%z#zt @zy d`@ǽ mm+,@<ؤPX# 6^SpLsڈ#*`#i5]t?PA(;pY ~= ;?.Tln:.)Oxv}]XXXd/w| m 9bepJNm|HY,a)ztci sN ~T֭[o݆, VtT_ImtA)mnjM ^aނ>kos&!F@R]:!kfzZΒP%ZSi%{Z"̘́dfC MiÆ > =>y G>05Y]-ZD.]j%ec )IQu8qƕ\@;6'5e4)V^B(La1m{YCD+T=bP˯ t{'tkJpAm#fZ%ltB-=Xaݶ!`P0`r)/ِn3F6b\h&ЪBZAV7t ͱޖo:$#٤pOZ# =贃ۡbY/8_5Ҡ0;a7%, uhxGDV` 59fzY SשE1y_ w2`XciK]o|pXFj 8m 1{b&@6[xQ &+*;!ysA^ E"58["[! N ()H2qjCߨwgd[y&-EN@`#pG H&r: ߈lb-~'1cV4Yz}6M3h3 4z t/^SA7!f=7'T0섶tUNyv{)HMLBwQ;I ԲӠc\bT+[=(跾/ZRg^"r;gxhŶ":$yt0=¾@t j- 6q˞bKA1&[B+?`TCPwSPQ/h`, [ S9L9vY,ePjфþJLgkf+;l>y XRMSeږ#4MU<3w+5ΈRf A(֏w+PR\M; _N\tV~T(Fc 4FH\qd8ϤNQCt.hmltѼ $#,7t|tYzN!9G,ɑ’<" ` k E3`0WiHYIۙ|Fd81]n+@̙)oQmFC=K4mT_CfEi^\ f%gozː@_{&}TAYXiTm8fJ#*^xUVh3EeJO`OjPϛujӋJm!Ð |R[i= mC9y r0]_޴4.#. UGgRʒ' dJّbS|?iЀg_RMG_Z/(GGp="8q>R-`f2cqsG`5*xet:NF#bӝGFSX}7[8a0Nxa7;nKLxHʙ2'Co˹Hd9XD:l\'oXfR?ƔtumU3mfKZN) ~tNxTb˱!诺$tz].#,rƷq\MlZf|)2v#Tcy7%cWA[_i[(Q#enZAR{ǧNWq0"> kBH6 Pr(}ZXdNh8.$:xńXQIll,LHs`;KahugzԺMn#+Fn]TA"|ClްZOX’7D=+dziz3g:x RDVGV *:i:-'0iFr#嵦'ewr4lS@"|$z:p)] tPMo@_F۸m[C SA㦋ȣupXS# 170c#|R3ILFЙ5wرe˖X1P*3蔅U,Se|J*˃tc+{|c 0rB9'SN >=]T?ڷ)d X `Bok)[3!Q5vq;a^iʧ6m g]شt]EMKm7 ~שP´>s?x \.,AM ~F$4' kye;B|ô=sUcG9D؊M`3G'1.g^4"`\4ZQ:QC%w-E>[PH{9W U£3ڢQjY=G/֎_sf@tJbR t!iYMǟJy8kGRdy`X/,n1 M%+f,1SCk&isYi?m !Hv(o'd~H)d7U|xD +Si]ȱ„/LB5;ʗ4Bm0vd9絡k%|0QJ%So%i!ۢ7_h0n@}c8"50\Rр B^Pu%,{\i[;P-;XЏ-;r!u?A?gySH3nFW٬~MOuh4V ry2iǬLdE8j{RdY3GD'+mxqȘ^RqdQK% 7\f04/e8%ҴJus鏑n~o/ 2+Cvy@[1g#; h jJzJ* 4<JK&3mٽsNt#%.::uLemNaGϖzc4-{>Bp-ٖ24V,fe6t!tBΛ<' ~$ ?Rfal!'2i~7MӭgpX֪<ԵEiJ'-1 7=;υFvʙhJmmUckG^22Pp]h,좨<*)NU$M EM5k %h' Nԝ2vatNiÉH%y,)Y keLg:L!XTۑ"xjw u|"[n=36n:tO(;gV &DӍ}(PNgFV(S SG.t++V VysW땨iWBsQavӦMyfK>HJbI0{;kF;ar[ez6m. R|Rp.Ue!\s,/J*X;?%iY`1 ^E]bwرm6"HWGEk*Ҫה+U\HNOqXY rZѶЁb=PiVO'0 X`Xo~"w_ty ;˩ݠۅٳ[\jޚi;NVe) #cD[rDc>0\#hnA'PW /5hCm<_V,LUo 4 ikH<0(],ku8DY/L/p@h n@۽fiLf 䠼|6t/(LGZ-;m߾}(9c[DYǿ1]-\4<¦:q(,X+\*{1 CikW[af媶@fG+GrT.9]Z,a6/MHr/eͧE&r``B*QJ%1g},EumuŊ4גL4eeo"|(gPIhaBF'`iƄPMĈ{xXS:[<լRnED͝Ei&>bG*U׺rgR.ʧ 7T2pds)Xu %bR*a_6+>Y2%NEVhZ!ZJxt˗41#@yS1XuP^oH$ḿ UD%`KOV{9rcB%©"ʊ"vfSe!C[g%'<3!h[$57r/X }e_, !rL#aQy s[rsyi LtRޗ1<71}\eP0OT.7G<ԣYoۼ=֒^w&0$.ijہAU.vQs=4AY8k,3/>_bR͵K-ccDȽ$m-@sn\%Zo/z@ywTzDK,K$r``-4q>DD--jrIj+ws/5YePCZ m4YϿlG-CI5B^5.P4k}+/p* ^jCCRR9Я0yA=(1!6|[  -+^imSUIl^KP<Їŋi6M,b-<\t#-fFSKj]jGzgGY:ܦpPZ VWx2@}ULϿ:M4*]dYcK!*ϊVA)ޙ˷XU%0 %}ג_0mR\9EGB PAqږQ_WKU|!IGcKmr3Ur22 s3h5.U'1W㤰R3y//Cj^kTld슎.U8lQ!N9s7, &Y -Z{\b#8P6MGs;@3#rl#K^N P)[@r}USjUʕ5j7.`sWM* }v |OUs rctVZ۽:*iG/h/Ƅ; jOGhŝ˖ GX)o0g4',̅nG- %,gk/C ׉77` O9 n ŊX1kFCzOu~ ֆCVm8ﯺ `}HMj|0d(n:V%C9+ruSk ݃32t k; x(L,\H C~א9QM4Z0  geQ W' Ԇ—|'<#9l3П ݺK셭vfm!cGHDxy p7)262PZ/)Hu +B9 ZDqe=36d|W)pʕ~[Y\|e\5e:-`::C^ӊrԑ]?||*Z70-if2~##pմ!!HaHqjw]0y9I{3B"YV*5 >閿IԻhPv[c1D#N(v)ʅ/_ 77m{+SΦ\F3gTwI|Pf.KiwJބ}\87Nl7&cɞI@Zd`RAL. 5]baKʯXlD)+ԣb`GeNvNOۈ(TfM_ˠ܁tq/U5YbSy3F04b443k%B9$!{tu8܀&ҋ7<o|Ec~9kq\0j)R &ސKAr[9:K((tsb,6Yq 6;YfJ`*/G3Q Bĕ21u% 05]-AAS"H:١eMstg Y}pSXcqH.ƪb\erH*h.~ )mm2nj*$zJͥOG#2}Sk )6XZ[ttLe$H1O0dZ̕v2r.GkDY+Ѐ05!&9zĠQ1S]FF+2gQ%êW; T(W+LWGR=0ކ ͮIBh٬1(ddK Ԁ,I {jN:Uf8JYfn O M{~A+P 7xCYKr r$.yJn35"2%,'q-_KƒQ}I0J8w{ܬf.*5~A[^HclyCf`ƣ@b(Gxd:W'-+oaFms o'6.AbjCW~~T2[1=q(gӕ|14)fM_0#Ⱦ=خ|0$P4NdcmZ͏zp@gRaH,4f͚_9RF)Y̻5$)mmT mNb(>ҙQb!$-e6DVCsh ƍ#ŏV,OƚwyUd@8rLO2`2;*C)s!b )@\Vc5ugу~*6qp_b׌Mg :zWVUVXޜxy>p ݞOў1SNf\1d_ /b ^c>VYǮe鴊+T齴|>hڵkTep+ {~`^-1L<]bqrrJ}e#bsnG.Tf59o55z 1hF]J*@2V:eYe:hy_Y[;a+sy?~S⒨nGmm-b5aecn&`:19mv2ÐE[g*J>}2٪oG+m;vm3&t!@ AJ^`#@GfAFi[?Kb ]]*=R?T\@S +ҁ"]rhR}‰J? ;s(yUXj3+gyMHr8^1`UB#KaFA~,nSLOusQ5kn:\қ͔` d]E }v[]eb쁱m:u G* WRf!DgdU1laEHT'S&bIyp~i T[>Zmiˍ~B!_X_^a)(p(8 +D;U7 kak*2A^b-IJd#UcXV_npߠd8)hJ$"mذiLZʷ)O2mGg̪"y *Q閹-v`Y9ゞShOJ%\zI RAXsIʌoP5+hU(.vM3(ud&%R㒯y>7@7 }p!Ba-FnjYJάu+7i PT:չlh)d őfA;{ӵ̞SZM7{)̗~΋e ](2jjG1@*5]R2a܃L"}gqΓBrv-t kZ%xT%[|9uh40 `g._0yh8JM{r(ϦqdC*U=  s^bPZI|{2ie~mQN*AkhBI^3-a:Wɏ3@abng^ . |8~& ܎cT=M7tgH *K(݊bH?v]+y=Xq* N:~Iă4;.SїP(C,-flz*QYwItk)!Sرcƍ35m1!U_X4hB>Jԡ\\0 5$[-MȖbx"&);d,Muʨ~Un۠_sFhƑks/-cS0Wŀ Y,C 寐/eFmd_6+,%S*27;d S' X-8]0MF8 wԶJ8*tyhN׊0v@^]+ҸZXqrɱ*h*ھk-O*:P0kr}OӢ1+ fȐ-[4jxr_4ݙԼuh )+-%*?r ^ۀqǟ 0)h_hftL$ҸI[{?x G/i6=3'PU =Jm4.W1@#ϙ~Q{:rU&Vd4HQaB0!iV9wvUʳrލ8:kJ^μj9{ O BI `(ȰvLh)uOij2Ee+}jCa_̑H* vpPϙڳuJ{ƈ(-6;xkTXֲZ@*e(}MXOYWY*R*& L+lNX`y#GG!eu6ˑʪV?fDA9Drgpfճ-gYtR6&PKo`\p1{B7s 92juR;[q*`bsޮ0^A!/{6ߟsyE-בoynJYYѶ XЄZ}e2bTPUQ{ [%_6%%aæU-aVJ#5d#@_|/NJaxjMl+ChU$a%Ӧ> )؂);_Fh| UhؿBW#{m—2M.brЖ ]`+cю{DQ=B4ϙ˶ ڒdt6?C9dڵ,oO.\8~BGǧZl&}[噹&P[rBe~ʕ-B=X"2+R 6{88b/)C3!gZ1tVC2MحG8@,,,8r)6Haݚ8D ;D= yk@0J2@uDCI8+UFyYp7*Z󶓫˙UH:wr-zҁh)7SEُ{*gX4kW v_5[wE}{ytWDCJJY*bqpģr 1*Z:FRkgےvF FƂ9xR|C-+&}ߖt{ T/@TkP_m&Rl^2]T8a=$|iS ` UX, n5j?' 6@@svݨ<-d t*+ㅸea!{2o]>sWc*־Qԏgs“vNhzjfFUAVP=šbRЧU-Ԓyeq 02TyJ%܄fTԻrQmЖ3.׀ƥ?%SZtBW}@(N"JXEc5M*qli}V񥓁vx6zg〮d]1hf̩ѐ4n)òbe9APHjnc8G0M av~EP͗b6ïkJ\qv eKKâ XYsklIttl qQ?K<~%9+|iXحXojJO.LaO(!6%fX5 +XvB{.F'QiiԤe>7u=ؕmֲ$_9~@BfZզ'v] g\9:Q}q>~Vg?i nH(@nr,IkG0e͞b* o@XMʩ&%t$U/@i¦Ts8 v]7JpP06J@s!7Xո7LUD mq yU&=$ԯ3; 6oX>RxWTlq<Xϓ o0gLNNP~սg fJp̈o;!Y1WQ vS%ڋu [Z~u 7#1Ѕ{4\DtADXq,ΒV-?JUb6{ZpEccG护ԷdU¢x \]Ts8t Ķe,}S^rK3A-0 x_ix;Ѧ(m_b(/|/i͛9guVYS}Bu[Ht[rȿa%H3.OQRU!f9Yבn5O$Hpmt%h D&5(AP;sc¤ޞ;hH;cm@8NrApKKq)D52U)CCnm.(#8b^{~0DytB`D=RAIvŎjt4hHje4320>/U(G](R S4d˜UR?UF'+N5ds~O=۷Ck@XKeugVwߏmJ-mLW dM<c]NGN@Lp  *NT`I.HiuUm=zˀB UM<c;F'ly_WA-{4[!T 0&g}˓p3NJF Wj{_ 6Ƿ+֋7dYdUlDPt6#Tir9@UƝ 7P, bBzDƶm`.X>e>O6KʣN\̒m>X:a7O@ÎVrd3ot#+st,:?~las00Z51ԯHTK ku1i-ЩzZ@pYOmYz{_ גU K7y.uT^ZgGɃUrI`D(ɵG BPfC%e%a[ :PU.Y*'Xd*!f= &STX)}KI֣UX)v3V0'p|o(yriҺ,gt{ RKM*]B K\>}!-O?5]8k_/ [[ѪTx9qK[]A_xFyVId;Y (.DŦyVW4LXT{hc_>m yl{{2ʞqvK˂Z4f z5C_I+2a,h܌p,Q rR"G%H.Xo=r2y_+͠aMAJ1>yˀv* #jTUCy",xȉO|Ώ>|R` F}e˖ҥKdz^E~!t7<0z˿$y; Pvqqxj=]48mc~a 1bry@{9[@^t^)@Δ ׵Qo6b j)GRy#'wbBRgok%rh5J 9es6!P9o 32dU wfGW !"4nyĈ?tVwղxH="4y JSPf{R⿅W|Tŧ>(Z^tl+ۛǻ8&:3'*LeR*ˀYØ֒sopJFEYT!Bd+ +SN*ᑷBo,T /XCBFp͉t_qB[GK+ޯEcJ́Q„7 4Tm "Ѓ? 2iׯ7HbnD c=*;SpV#e5Fv6rQA`׎‛$ՁBJtO1` OzvpS$l*1{㦫\gzʫ^N𪆕rW2MМf.U-*2h1<^:Xp[Xn]eal9*ݪyTvrTg]E?U\*O[dUqC~,AdXE|um۶ut1#mꜦnzK*g:clMp8BCR@^֪Qʼ L2i,P[0r(/|`}ǖ*zt\L9蜓N:MVIJ6m-~˃Y;^ZˑIv3PsϬjQW!"/-xy"2&LF1i'7n nګv~2t]cE{RǛq*$)rD hY&iHqmyyy )\AX~ Y)\F@Vlմ-`NtPz 9jEāNcswXgZfMNюNe2tQU-"s-qR3 ezxּ{ ﴜf/ NCW*^!0[bwgt&EiEZh5Jrd䂴dhk֬AaG4e@1\'P @߭ѩ< c %OL1?khBR q4Op&#Ό+怤zg)50qvm2+'n34'm$_ѵE XvfTu:]bYI,tRH=ꨣLQ()_1,-Յ5n@i ]bM;iTFPP&%ȅLZ%@re[ `M/ֿ߸k6W'4=]P]}ϴJ%*F9km"ﮦah?0O)m-CNU-f0-RrʎVILf䉨Ua?DSব kX`g^ bŽwFSRZ2 kaF}a10ɂPBK6L8YPϙ&Wʠ;3'A*d=+E{L.ODy+Ti[cH=+\ęt@k4{Yжl2BMcsq؟-9¿Z4J %b>䛟oRr&w;c)5Ժ$q.rA W@D,:j䓃iNOˋ_Md>Y"`G 7&W Dք[N۷U7p2-A6\.Z'V.*?Pt("jІi[EQ4 vH{f8\jFFՊ(o[2){V- P<Hw6D:WY|q(sw7G0 6((1~:?~,|nR(Pp 2WQw5)%QCAێZdOK?Y0id*We :̼m-"(#}I1:)Iy@ U)pgړ-Tl =&?XTD[c){uhѢ=c=\d 0/RsiRبmEgUD6m2< K; cZ*Mv934v("Tmbd dKg}uGM&d&skRW]E^7+,( "("^x7^" {WXp\X^xՒdrL& |;/~''29߯W WXY SVP+;*Ch%3r xlpR|c ;hHc`R={|8̈(;:ih?zgVT<[[>,RJZ"rbEwן:.?d7(S #l-bw~3L=M@sC죴MC i&fmc4>h:,PB  ya T_TqRiddUc^aTY8#V G&41iIE>*}4O- =+ʣc-J$soW7R[Ecrq4|FےZiFqa05AvbBＺ5@haz<;ekϢa{ǯ^ `_Ӂ[Ө"xuXeOQ 6/Z84%,&7hK5|}}{p"B*=? ݄2{&>R qYI4~sI~Ve^۔1fbUUMw"kFgg8 eNȞKR4HPf kgj&EQ\DxTq3%bj+{Kg%7Ih<8"1pW[i_%2y $?b:m"5#x](ob7ńGjUDw 2__gQU?MnBQ3_wk1|Luʊ複e<駏_2Pu"_f{=a^V:@ Gk``|o ֥DYFImVRll͈\%&"l~I2+擾r~+fw{&DQ@L W"(BJc;,Q9Y@2[ o'{[˪r%iJJ)/J/< @-X|za} VIq#h?WUTZ&(e7GG<^9߇.-ɪDmxX[{f^Nq۞C,DF KŞ< [? cժieEU)c_ ޸$R "(ҳVt :44H;}y0C(T;ygyxt >m:Is(<(lK ܈SUyyΏfFCe^7hA_\\ M]fu8ImU!HejyN / zYJ) pk4܉VЄ uVgĔ;І[|\:**Y6{! 񛠴;2)x_,8OeY^h-V(:yZ/:wy9-rpꗛO&y&Zb@YD/=0[8[sb\+ZuWH>1UTBvFVܩ~:P((DXÍQc*m%d)īʬjoޫ3gUA=!flowID8t'B{J"ɔ}Ta-X3NOUIܻ m MB: F#c *q-/@w +贂EXtli:yH)M<|$o m*ha`6Az>3sY#UC[W%Qu*"d_W#!/,zlNB5/ԙrE*%&#-Dصp}~UbU) \+dTUA[[bFKڦ=]ϓuv%UV 0&FL1(7׫"=f䝯 저9U)٥|ˎ 9$w"jb;]I-UvusYoɆŜ*ȤmV|y޽{O7Ԑo.k*T.Bh9Ic R(%XDP Q6Z&e#`rDLaG _zbg_djT|aU/)ţ#9h-"R<.g6I.=Bg[IږKMQ[~U# >6<UYx DOxv\DC 2VhaTXUͅ(l"[}\D=i5+WhbYtl&ͳ家x9 ̀DӼNxFNWwHL\Xmx){_I8;7kgͭ4>CSZddf:La#_ `/TGq86lD ]ÖVַ>VyBq4% Gm=TQUA@;*"AK.oad*>fysy~# _;iǽӴwW ࢦc!ADQ{(s^kaYCeDԐƗ]"6k0x?NY5&}KOӣ;5 D Euz 8 7;(o݅8K3,pa)AȼM(#rI#MʂfA&Sn쁍JƵXB:z 10(a k\ƮF-vɅ(qRn*)-t[FFKO_E\`=öȈ1; b\aڴMf,"JsAx \YW>ہY&5 /&/4#.=nctDZNG¥dm*=A/\Lu~TwsIDAT8^BhY9=96`+P$W{EWU6M<`WbgӼ eg^h9Ui-CjS5$@%tXNdtnh]Aby|ҝnJ-:.Rn:@ @&v$Ԣ"D$?TQDbIe+w(zU?B9k+塪`Jj^h员 C͝b|-Dz[c [Ph`ںUZĝi'W[}޶s7}ۂb̃GE&TfS ls"͐L/5,!8JK9n5 ^5ׯ ĿW.ym)Y٨t%i UByEgL;-'53sWZU([D#ɀbZne)=(?$3B u8|cw?R`2yuA6(*c[;Oϼ,It 6<ʘ:jΰx"ArAVX3o H%zMLHVEgo@  sY>' bByj29YIm{Dg|zUF:߾A^x[~`C>݄G2h,=y-WB DKXntJJX\/Ugd=4W'4iR}ŵ@gZ| J){q{G UGXyJ{VwQ.vwiTS4IP^~b):i}A77(L4-oZ+ i J--.vҋߠHS8֕}dȧ3N-Iτ'*ީ+TxOv?6?`mϘO~ PAу|`SZU慡A֐nK#8 OFoFs͊%E帚Sfi ҧjj)4Cd>$d$\( .-rxϲ'J(q{dX1DJ,6_dC Zi<[-q:.6) T9venP-XE]\DA?c kX\yg9!51nth $d[slC{3*/t2!WC"/0B`* s{QVo[pb-ϼ'&˲W#^A+v:K^s饓%,Uإ8dz)ͯMFJh@>gFg–;;`em=ԑ+ֻ8I/4xdS0v˳0ַ]"Ri_ΐY36x[g-ityܬAl6W%,@ϭCx@@%tQb mp?l,AXջ 퇠ρ+3P mgr#=0%ܿwwAQ3uoRb6;%N A+;BMٝ@#9k Q3 A!BhˋDZ]^54 msms&}A%Mxty~Ѱ1Jʍdt}L,p!FI?}UO<I %x 9 <=}IJ{+3Tba69~k9@Tv v:uV[zĘ̄t6[`N;a,R5>lC!mG27uam3ՙ+ /=Ƿ~8EC%Wkp턲Œm$]]#7o`|Y%S kؘNDl֕ȝʭ@1>$qNz?H9;T*x㵝 Eile%YtעWK" GQrZҌ՚QH@1\k*"RWՑ9$?ޝ 9@w~_R1x)7{EW9MmMW3sjԷAZ#\ݑCA'q+1x~Z~oTQh"7 P飣b>PYiqyF/}} ~H(C,JgQ:oQZ𐶽b4cr P#8 )!cT'ZhWp-zXiL߿*|Sr@6-wƊ⽙L<[GH-{Zޘ@:`VK,DL-Jah<~7QɋK{3B>}? %<0I+n!*UjpW4רJZǢ& >$NB" UR/8VUɗ%z4U11ϭS +l8G8!M Dql%4JO!*.d:'t0l'T^b+yCSԚÐ NWS]+*^W)# EkC~C.?* #aiLjr!Y*}d&~bټ(>=uvb%(:'jױ@哵2!pS`dy!FY%_L1秕I\~s4Y|Mu(fA-?r*좺(ٞ&@bi<> T9xy0za Y$Trzi~APJ\R$.tL:K(êЀn{ڼjb4'=V0I1!{}D }ZIaLV]W8B7ղrNt-&6@6p a͓-,4IfS7x÷x8]Fs0'v_)*mK_a^4]L)nw~jUWRz%yVEf1Uk3RvDŽA+]F74b$_˂L.3P@ɆȘľ96[lE kk{Tho2K nyY\G!c"+{)*}IvI{TekD)cU,oĨ +ַ=b)=x=tWRF`䱋޽{WDhD2;կ8! rRL iJnZ(Fo1eTnm& @=11yҾmq{Cn e( ʜ*P_g1>qDF ҄p~rYCٔfciIg[ēOZa[RwRN=ќ.kmqv,W!8\h͈)G4 oݸq㩧}j,ueЬ% UdQT~ ?;.?o +@ &TK'&B%G5sڶܜA&+*%tDQ̙ѩ zy _igܩSYSf/$/8WQ} ;7lMIY1kN"B4{^wq1Eb3| Q1OJ<̓,Kt~\} z 4c  u{Eё0erUvPzGX)% q$w\ݶ׹$(7JCu0`_z饸S۷ O5ӳ@~V6_U+Zc-(ocVMiwF\|ϐg:묪–|<"W~XNpmcF^IщAWCx/Ets1!kvXr-R ʪ[a[٘b5^{a,DY$-J*]q]UC^MDO~g"O~UƘ;>_cg"9ѕLE/bD>չꅾ~ ds6ҌWiE;7#=w3,;If !Uفc/*KԖ|2ڛՀB Y,U=N, T;)8maڶO-VK=q] _\Q~NR<+`NbPpO@oX:T{!d=l(߳Nֶ52X#f ݀Fp-!{Vy'(%g] 5Bm+Yg70\#~ߖ|ISKdJZ8?`^v]&E$9cFs!2*gͿdU s/ʵwdt$+4|E ZwI>B%Xfj DJ#;ufY,j}13齉 9#y?9n7G{:(JvB15 a2!&CpP-nC+ KxDpu[:u) غdMf}T=|`Tאq=r{$6/$zQ꬐wҽfPf.JEmgI2,$a=$gBcѮAHmb@(B AJ-k\L+f߭r:901mD@5>cϼxl Eg;3j*yen+"R 0kl\#X?LyV\0\O*K<z ө$QH_ȓsɵQ (B:|rmZZm݈_Lڵk=ؕ+Wnܸk5yRW#FsǕQD&<̝+8@aSRCGW>ch7 m)\]P4Phev-#w\r`C822l5;kTKMN1jzc: j e7/Q9ZݶČz[Q]Zj: mlZ!DAlEQ)Ihd7!ly&e#^S^T˓Qa-gI̐L4:g&Uqy)$x{\zըX[wÌc3i&A7G~=ET@1=T"Bp=4h0u&3/R/r8σ S{Rn&sf7-ߕ.Њ@,b< ϾG!bYaͲViC4H4b1h-7MC""hiç3 +pQw鷢-ߗVd :yW6S;CHA!mnNwU:p'b "豔<[ u[:0mԨuͧ.k:ȴ̢,5C*>W6wV:")y\sdUK5`^5 dc~Ha *LM VddDc(Fey6 e[RA+g=:؆hMFF\Y8.o9!w+gk姵96y!A{CzŘd5)E\&jb5KtOE٨n}2֛Ti-V7R6" Pʕpn:*PZnju O `Ǣ4 )N#y}O 8X$3b9 _C0SXMlv&0&ƚҰʍ ¿&)WvH|q1k4:ʲzdg]y"nWiÚ0z\r :ZGWO;A>[gyUӢƎXVBӑ_{/8'+2jo)_k<'9:ˠ8JX}*oT ȁ8^׳(m6U.7fAjjU eK#Vqf.ZEAՠS`ro!`)zx/D9,.MT)jwf~SK+ b@#%”2]~\GPAj&-A3ۊxFFmox\M#vJd W\^cX*(B,ׅp*i3://'hpܛa]u,grṻ0kĠXF|-p* 32v;ܹs'ׂWHg2SyZU<)5oJq? ЎO$7b%r!k"mMǿomFL4;%'zW±) 7LI zB7=e|;,6fKmGȴ tx~!Zv}VIځä6 _k~Xy)!j#Ng"fIlٽǵk׬Afc I Աk{n ?,43k3P?A 7DӋUȐ+ ŖOG@ZsNZ.\?DqY0ױUЋ@ӾKxLbK2)T%!1zhAJ4_X$۴ ص}N鸞1VRmk$+|C DR?}K/Īٮ8DL鼊oRhvx\ 0O[0FspܩAm0 Z,v9eB2S # W t^imj`<_w\Q7ĂDS gN1tPDxPJ mMHEЊ6Eeӂq[]v(ɒVTx9wvS]A a:whs Î 1xq 8m؏ZU^~Lu~n1S%ZQ"٢O`d6m+ByvR5SL DcQb) 2Bbx_ʥ mF8\*RQ, bҦQLI7*;EҀ\?.?pMT Q3pb"e:+r@CfW5TJK&'8١5U1r1>tu(qq7|aL_|'µD &19*# j73B <^#xn(΀h9@FAJ(_1ɪ h XS\jO"d?WIѺ8AQs7yt&tf`H"hcb5 x ! Lȑ$~ da՘ŕEzvƍf 2\Rz lQ,UcBG 1δe[(ؕ.x* :p6=p%p >$~DXQEgoʾ ~NZE4fo!XX| D^)RiI>l^aU]n .1 s^z J ,NϴhB8(, ýV"߫z(F 㺌+4B/+LmH!n"`|iw t!URXj:8=:6\N'+a|.Kp,EbLDVhٕuC;-p'Y~(^|͛C=*kK-\ * GG93AH }1Hje*\W+J@ ~->\Bi Hʑ~@1c |.M4!/aH̶-2C(M:z07k{$Rd`Y0kA<8J dG$s]#Q5QTD#yI2`W H+ #А"'[YxaI:hOk 90QݴG^m f V; Vs*"hfYX㩮ӫG1$Z,h[)`꧵AC>Q)w T%{R)ޡJ*dͮKxο]oǽߜ5x,QaXrL_9.X4MyT~J`% XnĽgwFm\8O<*RAzXӑ6 : sq{ -UX _7^Mᅣ]=H-loFjW,z e%db` L&ĢWU2>aǔ}qo|r+ő΂XKZaW+(,N\4F_ - ʈ~qƪͫ)9sfk۠]0f]o>XC@7зe& 'ؤ.T|̯L!_X`80+_iy@=TiRQ^PmYRDV4pFv٘&lט| :Jtjߣh;BKxmgUBѤm`H+0Q ˫=V̭;]yr;g`US 4Wz2˧gvLMO/uMi5,{"f 1)}mU`fgEx Ƅ6V#qAcb,fmL̂ر)l{>\5hvC’3'x6 S3X@9j'UM|Pڜ=:ϜJPA_hDh^: egSIo|#yݎEBV{<'W%DhIt $ y''Mcp3.]ek 0:3V,a^ToH-B %#% H_-zq(o/_8T**Q.7cYfb )@iq1S F{h?*sL477兩"p41r=HI(b?ZO"ΝJ=/Q m@Ll&;O# 3 >߁WxS S?`<" nyVZ0ESRIKQL^Ʌ>AEKVUl\5B\%Ú'iDF1yoln}ԋ9qKxkli/-^ci "F/֘SE3fZ+vZ >8?,c,dcKHl,Q4JWnK!^^`; dx1#]x8lϊ"`E#.s+.o_A3!Nxh]G!E_Q|.,-->]%]T Ufq\sZz=2ݦD&&1Y3?яL,L:'jO\!_lmtFcРm$t,RU{ />M~v6PmLdZ1L"Im!ҙ ;tuօNUSfz 4|CA]qWv rφx9?ZT;7ڥblKaF_?lH++KW*F215P"1g4 M%-N WxNi c(U0q>3zҨ׎l@㵬s ǵgTXiA5aN-rh谯3\"2]}6EUAz`hj]8NRtnܸQEFb5o[sv",-|_.ߤS|\c.V)N  #ᮑ^̮pqcbJS٬ZWeV=O|/ofaK%,V f <)igogB +޶' at2JҌr& FAKLmX'}"Em^^aC픹f9LQ+!6+n5^}{C̋1٥EA1"kjyDy]Qxa&8j~E-ƏE{SX54f+BK\Z!"2?0Z*u-j msQgKԧaTiak_i<-c%By>gfՋS#Dې!c x ;RN\oƊNaztGP"܋ +8 .JX ݔ0:QYqfYj[y{&\e7&;IBOpAUKY@m@zlZxښU(me',>me diH#@yA"q cjpζUNSof yfI$'%M7,ם*ۧ)"eRPo7+c%Æ\ڒ3dv  :++^]HIOc^; ryٖ"X 6KPFV@[F:Hߖ ^:;@HlZo8+x+b=b=a( _zxnmU{} 2 { {MoGؚ1#EG_󬨟Kku:e3mP>TFYz@>IVQp KKV;?~aLP}WesuP>i7ƴb\7( ѭ9s%3<ݦ︄sJ˕imX&*"P0 )YCA- Ί>`t'UN mx}K,U>-MwBJmje|@[%.xQ=jbtS?*F XrX#O"L2zjƣ0do:̑6!{4q@l#Hf"w ׯ_rի| +^!+b?~\.A2!XCTU/=yҼ:05ъ 8,xpPW 加0yfgWr68YiNUByčLTۏ4+:Uat*Hdɭ_^$F&LKT` tÞ.%o-H3XQ7zY_R?=>㶖)Ҷ`wYuT56Bt2tOFΰ/~ak `y%nxi3#3-dqIhOP@e`JB.SO=/m0)Jx9ß;(u3H^x"6gsNU=  [|BJtSo; -X;孮 0Kok^ys5++GTo)]G}*t6O潰MmgTOg=Q51ǣz\Def"Pٙz=TYGƏo.GFja/ aQS9ⶨ48$NOmw~϶_8\R~"[} H+{dXev9fK6 R֢tόģ)Xi3mU,Mjf"sAIڜIe/&h%fnf114]Zc/'fӾLuQƲQO,%i~!Dצ-.F2:򗎫:;dmvJK`hPX`I0xI:[ PNEvJS#ky*` ;T,yU Z G磌nO*+7ioDZQ`cz+6S:Җ&g޸)\TSyiEagS(dsԛ|P#d|=P%{99."=%-g V$3a/nÜzg(9."c F:/[TKޅ6⦿@ I,}kk/(鋡5{ A$|VYVyiMƤ ;282zPw` (*2縵M In#3]De} ~ǂFnP"D.}] 3* L(@lMϝF|>iWe"صj#>Gj66HHvh'۝c,P窕4lC䷵T[%Edʔ~WjiiJPj'Tq M> u46SHB0NBIy]Aj8@ReK}Li2,φ|h" D ba &$#~m9û mI,Hhj-}wҞaMnӂ~Z @ZKfwI&IiEYM3?&&K?5~*ڟ 3WieH,LvzPib'|5YkG*,w\%2GM5y->Ȁ[4{E(gsLLtYaaj HGT!p(Ӷ$6F.QP}tC` $㦚#~ F5~c4mPgըAst,㝤Cn*&*p5vY扑!<Ǜp _vQ4DD,#[Ϗ݈ؐPM*06,Z/ dFEf~ܿ?Y[WuXδ^:R)-:)Ӊ34rx\~h3ph+E1k%,cQY0AEhɃz J7W%Qic-x Ez{Kp5(x;(}Y te"pvv9m88I!4Cy-!x{Җ=G@fb"^lb(%'xpR%ti}dԕ/5]h/ /&Z,`S#:S~flw+a#‰J; fAl1&_Wuʇ?H՛W(I\N!8ڲMsT>|is( #0uTHoc^s HXWv Tv_qrmy ط"=Űlb86cDn-Z՞XC2ðK<}g 5i\vCF jˍsO+ 2}t8FIDT0^^CٹAZ"0x('@ГFK͌Crgdn/l&M<ڹ< Co(f\?`)mE{"k'XvN&v9' PSH32gqU?b?s ޢI |[%o/t8敱&b>pX4ĀY;Ia=t D5q.u ֕\+O c 2_۷i.{}ڵkAznlNFXĄlP;nk|cqt~NRL?iYZdl4S(. ռQ Pp̅`4{f~֪Bg>V,-W>뜾@QNAQhUD)ĐТ}S][~X~zd/F0a%Pi8B4pi.n4tEo+jtfI%2ȘHLiWuT=fj!/Py׶ kennKn#*:6HZlpw[M=Zr-%uor}i~۫XT*i+*X;2fCV0,5( @Z7&hr.T8e/Qf54N.tNVR[PFumejŤHWʫqrÖkI{pq1eM2mkD\ -+[c#-m 5u H mT|ޅFW @͋n6?x`޿a'6D@BWIfTW %Q6WhDki=_L7kMopn -KeڣIE2kĹwZOIAu VU#)tVR^TYAsObDe r/*Qʊb5Ce@FH} 1zvYUdU{Eu~xTKƖ ǹv7y EI@3b~*$x쩹 $Xu1Q @%mt (1UUpٲ=Scl56e\Lkhoђ@ɵfXumFt(*| {L˸, ] zb@5\IkT3W]7U.`hoM{S\xm\22iT1xI Q$v W/juXJ4'Mi$_ȡU&*9Lz-9Lytl ,6im2G=P,R6q/5Hå0E?n03K sȌgF6.tܛ(~^@MT)hp5$Y=WaW/Do|.nA;K_Z1 :˫nD($q''v61X{E7zN I$4?N uwfvnl$N`~7[I%x$1gB7 1Mt& <_^vTϮ TtoNU7|PU ?BO+"w.gnv1aV\pKTZI(J]o]c+F۷ܹĝh=q_<.FY m{t^/xfؐF/( u<g'gFnYMN:f 3Fp!2:+"vY?\V!@}8A֑Vy=r1#ޱ_~Y'/( 5 .:f"F ?ƨYpC"ǒ|4VµxaRNJ8lkLU G)(,,j+CZv Š|#5ED&%V%}оgh%5kWheTq/:XKPT j]o_U`?6OYQPk\ +ϥR5*E-\^EEF@[F,)x]g>CWCeR.qhMwvP+bk-|ΪB?.ǨWWEܩmX $aۛWLc 5sv qg1MK8N> Җr&jw#fcљU^2z|9KXcM f0RSx '_‘'vCKVDw!ubo}_cBjfRYh{Me_a2@fhԫY@C:5ndCW:t8raha %*@рy\:/mQg9,=n.υdtbv0W} TJi>ѝ>Ѿgm$CQ`$ToQQLl1X&){ . r2uuˣ׶ՁC{z1AF$PZi8:j @|OCX(vaWdهf{J )=-%jQP[+bFC\12"jMhS+ŹV23o{ ~G\ ؝;w^{53CCb- ܂AI7ۡs^'t]SZڥOqU^] [qYa )]0C7S>ӸAuw٥@g, Jrl5G~12"M&aղW6y ,,Nxߟ6 G'H|ԐX9wҷ4/:n\ Abr35\dDkӦq|Q}Qs3dg|-CZW\1`hp=W%­TQ#bIx" 6+ۄN(Xdl}j.QvZ5*K9yI苩ЧN|FbҌdy4d/Y2FjB +C3gi+fTRҞP%lDž^J1}r +~? k3Gĝn%پ`haVj^$'2s`ߜ_ٍOh!}y.t<N[_9@cTyOŅD]io$4,F̿$8ۜҎ8'֗gP=yz"c͒K$2}cM(^: &LbIo` /$#,`mhVo[KÝ]I|تa+,UrGe͗:jfa>a߅ VLSmWWd>-^\4K )lEl obbV#1x).a1 syRz3KQ1n;o< g6(  Q/N@fDQY7|kbU +I\Nh(ʏ:kCgҵ'މXI MKJGԜ<)y9{Dط`ߊ߈evB,0I]PK NgCLBiA%@} y+{502h͢, ^} C%"@)dXOJ07׺&3BEE(5#:$3BG^"CMaOZ1TJ^LWqo374z*KuMr~r밼x9 Ɏ8 \XjUNro N[;yQYI,o'FǎRN$=!6#zA.qp4<(Yyr@3@9} _(JԼڷB9(k<`ƊO 6_C}ݰq0@&pvV:~KA,B]y.hJ,!1 ұHTsD(ewp9|Dp(Q|'B+Ӊ 1v~@O?0f4@Y&C 7uINѸq' ,&tjʕ W)AW= u^v/M6u+(%oEm0ؑܵ?Њ6H6o(_AءHrY=Bź\q+̔B\\0Cf&?W&uJy_äCz^BМU͵,!SЛn5EA٢jCm W El'L26 i6h^jE> (IuʶV;3/}\IM:@lT-U'K_Cla$: jDOU! yA~il j*Lwixa +f.$2QiXTG4M( PrpL6 HbjKB*QpYW>Yv[GU{0z3`p*"&^&(}"`>~^k!z!"P}Vm;b~&p z5ؖUX"ZS gyČ('* @8@5=} Y?0t| bYuJK+pPT!خ.]VK>Opuf.Ǣ[-5G&a1N(G9W&^+js"t~HDUQ_^mV;A$Q*16qx | /~|^ XLBb;2yB=ߑӰZZiނ,BRQS"#BX wv'~oCr36mR E򏶂Z"8Еnܸ8…nDQP"BR 7Mҍ|p޶993}|ߺuCa]v||߽{իqw8NsK蠗C W(bELUͬ|( ]VG,s35=V4 f݄}FdZQm%kvf!t~L)BO;Nuf5%zK"bL[^xl)1TlEЕ|_U}ѭF,,]Y:||&<bk~MjηxNSazJ1fON/T[kjU%2j+¨TVd"x)Ĕ=r?: G*U+?u - ZV颵VĢewYx[y<  6r|gZ\[FF,ٕc$W83ug>ظ<פ@t'O4pˡãF+cGB7F:ʡﺻًiAwFXk7ַ#@K"ptcÈVTB#FzK"(_^(UDnLz9%'  `T#R]~Lc$ Mws]YFClMjK<3&Z~'|bjgATKE<3H<3\W_c?4a縢B6߫%@D8p:v p4ZI,#m5h|y]zN=H>Ę%n1 (L[`)Ku<4`\mkQg׺M" /4T3_bg(RG{_/SQbأ-bh6'~xՌ#k6=N o5+t, viBBo[mB[W<Ղ-vΝ>Fyz;zJuL5^fBkmN\uYjB!àkeDig^7Ku,zc@ժATQqv4 a cpmº)nd0ϛ@FX c ƺ6am7*k_kW + ɵcK4txR`;gKG n .h։CҐf{Hr}}&V-g˲ᢢ a)<>E^01 zKLly7!hKo1Z\;$E-j; FȊ7VFh6:oft^{ ~RN20-[Q77yORK{韟" S1o/=*}yPE۲.k|i0xg]>AXR8ɤ*(1Jv"[?Om)gâ+Db'50ڛ4I0Xm68R9MlCҾ78f_tP5XRԤ0r"A}M=D 茅 -I*30:l%̈́hJ_7Lud'~7ۉH&xiGFKG~b^luVkL&h?õm6!q"DɀQE$T4Bv6{  kcy UE+m1 ; ū  De}UrMvhG$hpoCߒڗ!&*BZ /MI^5dO>@$^*ZV}'M˘?he2x;{"I6V|pppb# \>dZC2Gbat`x߭+)M!aG`ux,V,zH8LoHFT }0:5X`.68X zAar | Ol7#([ nLKo xӇ:e%p g\ӃX0-l^]U%fۯR>gWvL^t3 n(0{NHMghЗ4Eur1N4)*JXjZnoL)D*4q m4 9}0]._BTEi2ڮ.cvTXI%rxJ0 ޡ'&W1&ծ6 laup G㚦5$Ӻ|($HܞI߬+TJmZKaШfs'#35Ҍ J^%NU|˅im{+f%^W{+xM < Gnl6mꗄX͗JW_JL 7FMw]:KdܕIG:i%ɝ 04Xxc8o]_'ZSK :>'Q:R=wZZxbڿ]>%҅'LMs 9e!ڠY3-L8M0H lPQ|:Y+(lXNQ[lKae"%ID "1!2eIƛƣ*W:T߁ZF\!ch@WBץ;ր}c%ZwdKh/ Kc1VwzE~ȨዙEZᇝ:U\RX:l,>CU4n)n"+R[A( 󙐨fFhn2m(#pl*Bt4dӊ,FM{2zr U{͝ζB\]@muѢ?%&d]v>O WH\;YH_Jz{Zׯ 7NOcv>Y~km~Kma˅fGvtttm(`@QwRkFmi4e1Ӣl̓%MMƱiB t mSћ-Z4ߔ6^.y.*.*@_諒j򥹮Ȩ@n͂ ә)J/6mPd: o:i#G6L Ÿ* ?uǠ+Ǯ2(dU+) Kl,Js}ŭ/,ݠYa^tǍ7ܹCmEdYXBxw]Đs)B?)63>#fCh6 26#4#r&`8VT_-'&2eQH6UROb -ӛI I~CY1$-߳g>SN?wEBl%.1cnuqgc=z޹ϧg":Ȍc9>RY{ΩĘ*Yd|P*dc/ 2ǥ6}dC딑es,jCHsYjnQzWKᑸ!8 B 3]4C{J\+|QooW4UhQRPhc͸فHώY[fXpΰ #24*? (I2쀟Mԥp1"BQR!OA35ϒ;ʈL2]xtҾ׭u tYhd"EBQ_znnUW_䴶VCF*x-nВiu<* !ۍlLʁIZU1PtSgCD{Pݠ%aV"7,+ES}OjCFD[tTd!1py, &Zzo^(\#aT!e0&i 2@R rt૸md8`*UZH mw4D%bzZumpiܸ`9g Z뎮UHM^7 L=+lz)i;Z J*yB/1Q(xрA( cho ZTM誄-BE m1j^vsJٲ g͈D< vTmwh: Drq>MMn>D(cjUj?ME*"](K(QZ ]6xh'\!kGܴGBfJGbvT%@D84; @M"I6hoCOeTM$O"$;ݥNXe_gt"NX4ފ;0Fܩ֖Z&35(ltM + Wie1r᧋g*6n$Ffj*gTqwwb^Ux87mtBrSt Ÿ$&Z o̙TKm_(RĆz&KA4#*aIȋtZP:#*"$/W 3 L~nR6[;\,2Q) ?MsnQ?BFnF;OxF~{t9"px=(7P݌"U\T˵J 9\Cˌ´TlLGOpfM ϋ#hFM Tk |Ζn;W5Nf.4䂆KH_|{AT{e.$M:o|phfޓc0dv7GEeFQw/+o E~.GU>p(oS]e5 1ěr^dpĺ҆Q Br4I׆D$fpa/sA/LcF ɧ Ef`-g x\MYOI1,MOnOP2togHS'y3#gE dĄ`sѪöښkYlc4m|oK#CcE5{>UtJNB !G$8mWj-f'1&&A &B'wc UzesYUّhʔh؄IP?{_J24~G5Eplmfqg8o9ʦY<5.!+Vu羁\OsOD~\!#sЯJ=ަ5|j»88  Sh!4l$=NuCzU:X7!s6GQAWRN]ˌCG1.?l&=\A[;i[,%Vi~6',8h1bʒ e|* 7Egׄ F׬`[ZANs0 c oa P` .IG4Tږ YrF)U? ɌZЪB.ІAS/[QRZp=8ʴ)mGb܏^Z]YW 7q&ڎ,:ŋ0+JHr6HiGB[U/rJ^̴mj2+k.*ҢM6@S"͢;VD30X*" =1$XT?%s\ ִٛFT46M],lYjc|9ȴYc3!ᨛs\cXVܠ18mP0.OӮCAJ a@P^XwҹxblDY^,;q0I !1MEf1Y Mምrv8xBmX{E츉4Aycp} ^]%[! £,k:&6fHf jQp]W\)rΟ?ppID 7͛,BV4] M75WҺ~ыCOt9D>x2?tOi60D=}]$_m;N!AcL+ˈ\Sl3)LK6J,)pbK8-uL< y׾~`\\4ե(L'ch܎ja;8tF8ddXá03#5-s#tщZȭ):h+><|p2GoVƹsW7Vf*B날RrqWrzCXT:ZMo;kέanD'._+v@r&=qʪt\÷zѺ?tգHݔ]\`5WA_/G9,mnoz mT{Hd9qi>9ߒRAT~0#Dj^xcMe)Qf̊sg~oAKpYA<ďmkUCiB"TCuke.<Nlb-K\N)JЕyM!Tg7. 40wU`n<WG0Y) `A.l◸@q2 -i0h&/#A/+o$|^WEmM>I!&x|М[V֪z:⌺q,7&svi(`+Ӳq+Qߊ:h tTNbs(FUsxhUVg$yseڼJq :FF͕6uBfMҝY?-AjA^-špuF飇 EY/BYi!I?-yqx xB苌f5I=Qh!kM+k]Z fOLPWQ6Q]?u uYUj͎uv d%~әk/^پa [euñ V,B0`0m$)"=TTݐB+!l=F`Ky$8 Fr=h\WԶlIj9oadVȘnD1JCl#uWXf_,=x{x [Ԉ Og oWkipTkQO(^$tRvj]Ud{1Wka\ O&EQ2#^mR7߭ˉjzn qu7'A!r0Ii'TUq#aT!e͜n%rZÚowo zui]L TkΪfɔJ`O*WT C v54>_S}~lfxQ.'pO錦Y6hd)M0:fd̗ h8fL0 *%Y\͂}X=%f/{V[1a-F|r|lWw(գl]fQ1AE1y)'G|B& ።\JsWKD+.fQ m[vNK1_P4$[}GL;I@sUWN)!36ck mQؒ=TE3(ꙴv2afƥtۖGDȕ/L :נc \!Vۨ*4n`qs…gϞ9sƿ>WVlud2?m3ayo~"Sxsm2hb0U@VYFO@BޱBegA0ɟ37SCZ6ceKjoi9~.3r镎Kw̴Jb]v?(E] tOh*FTRF&r 0ClW~irI&->G^ax2zϰz5Vd S+wFJ4}U&AmLO߼C\Wu:-ƩiW[Q~ϔ+*]8?p-}$R=t:u=Νkx#zP>vԦŢobהQYOᄾNTQ =EL[d ME㡈@ aOY|h׍Fl2i]-_:KzA@5Xae%w]55ë+Wxk}Yh)JJ6Y*4 )taaR QnZ;;pU !] &F>ϮSrKyjy)XcQA(<[s66?R*-a -#VC/T}H:e٫OwŽ")x{w zEGH\E X:TD7Sܦ%Xei:St'ߦTs1̷EN̄uwݻw||(""t z{\C(2lZBk앂jJ.3 FL+CiDUy-EO!hvѴ޵ּe/1ېQ1\yZm !!lX-)ex")<w lBL3&:0 #>9@6RuAYTkl7GA{Lu4˞HCrx'\)ވ5A!rۍ\1] c~mTN*61N~z)[MÍca3@AbFĸ!JOűFXhqdŰ ̮m84p)1i/'V|I{дjڔYNt&nݡA=Č)Ҝ9Puأ2,vuUzN(أ@bX"A~a!iTDѤS=#vHMg+B0nr&ϷX ϡwrW*pgK< !>x8 6̅P*֣jM#2l]WZBl`P}h&B+a.G<9#qMZ@2.b#oovi'rX|Da %toRBVB%V.XITJ .s_yo.g&T9g륯UfRu%5T9#x I1\dm TH3"s\8s<KxZ!w UrIeH֬J8=G+\-"מY`UŬS(A]l.\7>%߆&&:}'bghp;ǑYeU~V.jlLB ¦vbv[28֯DƷr-j [?T}?7utt^հѴ mBui$}1hŚAM9L0_3<Pfܨ"0d"JT"è¼˭Ȩ94aeޛ\ipĤg,L# 4eT6y/$ uzlH B|%7YoajdvZKi.0BA,Į&$lc'xu6?)OBUshb(B" Ҟx]~.CįDy bXɝ6c]퇊僄q3Jmh"W9Tt!4S("4EO&o[E2;UA>+kbEq#s$j-q7J)acGe)LǂSgޡ$A8@J8&hI)=5Mijy% bAiAcDJ7rlpSkJ: m\vؠYaW{qb -ǐ'LR #0ND)*G  [ezI!8U:aڰG4#PC }_ stt5M (XC]]â hCF&tYjIG6G?q-F0Ju>C^R!ח*W]e ]fA073Γp_BW֗-^ !y1'9?ѣݐly5}c; IPCj 맚1#cy%J8[3񲣊1澾 eu͇~ȣ3%:=N^u kTr4Iyuy3k$?`m`"yP\)(pxv(+{a3 &*E 1L/ ZHvTx`گĻ:}h3Z`6ZE 7ft-if^Z$,_j*;sNsrts]DlwǤRP[%M.3x}ragy[ )׌yUg8uy4RS#P~.KyNet_)LKsLtL0nR !R[`O7"8K1)f:҈ CDjhZ4%*2o%gLR K(a[&%o-{B<;ޔZ .j%ݙkYOøp3 |"h\ƌ7֬ Sh%R|Q(a jd$D53MS+70g P9'E Hs߰2^7, I2w44t4LK_To:Ė8D&ͦ4\!0zϬn<Ŀ%!WwYUͧ ܏<ZDX/rmcl$.NsЂk0#s'MPvЉRX^ԆzF <+ :j'SxP X$"Y' f:^Hq6_*swm<~͎%~i_\AWM~?2h*6"@B_˚0ĈbUI\9# q'JF`v"qh "@6Ũg*ph;SdЂy (RnnFazpaaF,8 #/謭1T8;wW|5Xy#<<*hXZpeBQh=󰞦7RDL!҄*0Cc y\v\F)<4 -d,j[lIV0`U]O,ONåZu^]>xLD'Y4Ɍ b[$dOp:NDN4p{LHU.fZ~9[𣼸Xdz bh^7U@Oq# g pILEnܸaCV C6*f=%YP˔t .p Yd'5l1 |DyoX4C$TɽAfP 1%2sZʙ RƲ*jLH"^0* b{D4Ftqu4};Bfl*㼪j C*Ck! 0{'s&$Rˆ~PB@ΕgNSwRn a ŹReȊD"*i,kN>YuYрT[ILZ4IhX+pp++$H Q]אlY@.OwȿL硕 {X.lƠhmfʦ X< GGG-ȯ}Xe:HRu_+~E[Go^B9UI"d偷FQMcXM}yz~f}DG(%+Gbߵ.O.EPΪV [4Ugd坸( ӓ e(,7=Go=W8P4jPh*OOCRtq]#!uXuKfDq2 uZozK-[ N/ɾirz1 dbг<_@181 =$/+8f0c,My&|8@[QX9V5Mqo[q7QdrѪ4BR\Ľ]0]r0!y-yE'ceqʨ-YC܋bauZFj=@ijBJWp$5c:7vx 68QLAmYBm3c48VT12>I[@~qZ #<9ŕfWC ወ$_<&j/USR2zT gA->B~AgΒ"2 dBǩINPͺWbVz7ުtXp]>QFQ4Rm; pfEB@ٵW *G.r0ގE:URMbi\ * Cێu1Soas&?yD> H%ČCYCiAqOY ZJ# ϐ$†o# 4#3S>c91_6#65a;4hTre| styΉ}C~8ߟ_e(t:p`bNPux05r| ͫLivs4"Rź>Sd¿GZvx{0t%cmZh!aoOެ$7v~: #0Bo|*Dׇ9ȧB; ha3 v\(mq8cZbs~B ()SuBW;g'amTP9f(Lp0hƣ- x} muiDt-[cjѢ#[=G }Yw?-ҁS*(R?Y9'#_iWՙTf:Ѫ_RT瞳D.S8ă@yVj\5bU6ISB fއ) 5O _ok$Y^r>́<ʹͫcjєh*|}3;jg~py%b->X̶NL;Z(CJᰨjʿW'C@#eUPTU,FvTfDI~Xm7J ݫ_?%1iD媽@SȘfgl.BN`638bP[QG(g^ͺJf!ƀg~EqR֡], l2+Q"T!ҥK?^+ QF ;WK{k1+X)CSPo̕9f&AF\H6.8$K0$Ik (Q1{,34 '$)LT+kbZwl£~`ijbR1' aШcVdEHbno|kyx>>=R%jǬ<"PUiBX \uR[,te6?͈;'@\-}$o&( 1pIENDB`PK !XDSword/media/image9.pngPNG  IHDR?1IDATxڌuWUg{> $B H@HAPCDQ@ETŦ 14DPPDpGpf'>9gךsnl㛾雾O}7~ Oӟg~}//ʯoou?7Mo{ۮ⊿ۿ}W޿o|x؏ _~~~G~'~'~g%/y//?????? p ~3?3??={{;;;w}w}~/r;nw^җ2~\27 L-oy wW_}5+y?s׼*w?s??<ŏ8rGˇz^m\~~~_̓3~!uyg?m____x#/K.˾˾˿~W|8U_U___e[Y~s^E/bl+ |O~'lO|Ⓨ?yc~l7~fL=/̹8.0l 1K~_̖s'f ~s ol]B|P#ȇo"{ԣ' ~| b_Yz>=|$ sm1Pgp|ɗ@o7/K/@f\[,<;\} ېNX7cM ˿K2003GȖ fxxnm2@%F̰LO{0'SX7L977x;޹ C[LŒ>[cvB^7d! ARB.jSe߸ 0.x״a]BP?t~l<ĶqA͕i82x ޳h/ㇶ%g/9w8CG_u_9"V!GnC"!I7zS #V ZaJYg'l=Ґs.e+/DC{ws;@ 3C~Mp2)+Ȑ2B'Vex oqaâڳmp$!8f@@\^XL &!hcHΣlՂO3ų̌yX3~82 ~$ ={6xx]d܋_1[:66Z>Xa<-q ,\ܣ]/f|h_Cl $iB9PVCl5d1LR^!RO%eۀd^y}:T/< jџ}guG_c=D +s)8R @ "d9 Yx4t?v9223xaD+a l&#UQ:'asjĜP9WX8ó,j1b҇!]vϙ6 BLLX`zH$z_C7l7|4[D2 )=ngoC'Lc94x|_8<3ql!ݻ*.\6aTF&d 4u L}4xLMc>@Rܚr#6F2 s`Z%ay!n$m >ōgD)ϛ\qy ؀pd]^&̉޿ L"cCf/BI\'Yptm^_Trѧu~3ga3P࿜Z86'W^!qy6>uB>:|2n'p y > E=U2 X"vu[J첇*.x6Jlp߁*X EY%ÊL^_.1KfG3Uc{t&_ gUe '0KO|&< 9Ftqmd6ET_mx` },@ YP?h9A ' :3[]s {]N Ol~c)\#q -e ['2@. U)HCE6xр/')SeVlPe6Uye,᷼&!B( ҞaxF^P0\ MZ\n@~RDiM%;z-Y$0L/d/Ȁ c\'nPxY_~+r1ykdN ~+ K/Hs3[&BpO< lż!A-Du%A)}#Db2Ǎ#~np0|ZQ_A7Ķ"8eUc*c>h, ^ Ġ^<ʭ%v@3C'81+oXtL+-*߼.XGhnJ;{mFÜX Aocza #Md'0@6sP}PԩʲRHAV2f1~UW}zPpMvКTO6hl ɺPnu5l^ygXsM]@4~RO17cOm@yl*WdϤwX~88 1 nks7LG O| E ` 'yKjRtxB, W`; 0qG^Z O?nhj?4% vsM&P$q>#@-#ˈ',pRcoQDPgm!)x<+Df B]g[j[c(D~g jm,%lpW|>}FU8:A_؏WCyX(ՆX^VAoEfl3BP'cpU)fzܚr׺e^QE(O3}D8&Aa]7'L2:o=$ғPC=bw86(vċfɦT~~Ag G٘=a3QW:HTeˇ0w@^%`KSxuіlзO먹 UaB6]kFy~/qTt; 1[Beh>L2Y \C%*6={hBa=;Ne7U6RjaiS}fKХ ].IPRt3xcv c)B|Yǖ6/ð";K=ΫMS) I3!+ Ґ#FY@%oԬ,CQUUF)\0QEU/-s ir֬W#}eԤNazu1]PxϜ<`d._bE ܂4eV8om$OMm9E1>?Lxpe>)6'I$}d|tbCC|:Jyg>b7)wZ CtqRQc,liHԿB&j[C%MQ'!SN3j6\N)"`O6dUsfϙ${MM>`JN6=ι}bfW\q,p+x~܂<Ot׮Ec6xS\c 8Uba N^ jV:|_ 1Yz]JBn_c`'^TPɑm&5{m 60s!)͔@ԡ=Pcz?IR11}eeS_IJzNX4B̖ ЉaMYno z@_~^:4]Cktsͯ\`Cl*Sx.qGBIy$P׫AfJRl9VH6PG^E(yV',a2& j#z+?>n͒",!Z7+۸+yw fOFC6-\pיLZ&Y5ۥ ^YzC֮)Jܻ(5J0.R YS_@ k !gkd3?f]iī4o+ȳ,\*\6Ō?t(!ǭ&oC+&v(DY1KVcSP2ըZX-9"ex $2[h,㛩Ϝ2:}W@&D]s5I!l`ZTY!Į~i3]+IK;y Q҇RR(E"P?%֓܂pPUw<G`xi":ҽjJ6cQ > *ưJ7 }+1nLD"V) |e x(Nvh 0-kZ:,Od ]iPݬ6,CgC&ZQ@dtФxxRG>O|`sFo4s +qǞVT*,5p`I~^UjK9?ܡjtshQ~Ao93uh+$Ō?O;4xssA)@fz|+j &By/?)8YFaNxgPb2oy&\ӂ`u7nf%S\(J.s&`?%5_uUpk],!+|S !Il`Bh}*;d!SVgR@{e)% 37)VK6Y׍S5Y:pfO)DŽjCB[Eߴl+qŬwGE#c&yj%B v&0xtCqڳ(VJ*+r2C^c]pV߉ TunaR a5@&3JS*(RlJ7-'Y^K/AC. x? XœLJN $"IdRO9U T%XOe%tM[YrogoTTH'jr7$gխ|A}LVg "25I.V!w>ۀ`b0 L"SP-Żk?~4Pm2.߄~$ep5DvK&N -M3Ȩjx4 `o 8v3u0K 8}QXA; +kwW&q_~5u+_ yV3j+66p:WS@|4&nDw)pTu@|W0xe1%ߖ8\XEd0סo]О3!t2 Ⱥ \t<s|dXYpV̱עBML 3G A1@jJ S$JR6n9Tn#@f0:]z 6,2@k !g> 1ytj8j;oDzT`Lpw6s=3TQ S=[7K`5P?|ժ3IqពOJV=.Lo1n8E˼7 <{$3̇քE! o?+*x߄ Y 4"$`@0XV/d#]Y,KgnRSRO%'[A3`xXf`K>R o ӉOF POr!ņ 3P85l(y A} l1_E|T߼LP+A>$',b]F9'T _Il!& Jc+*8Q? G 33^cSDsb^9s!)>=#33 Vʸ9e,y T4l;U(K\}7(<io pш 5 !Ϙ /1=VY.E&@mCk࿓tH$b|: 4dp @{bV2=ȒdQ;',LE)A ҹ,3(h$2h "&M @ВVk4bJo`6ɴjx `E:SķY %PȞ17YK tg}cO&e`=5 c[☥ dr#F(Y"ߔCoM )@Ձ 9!x'5d S^W'[~߽~JDU]I*3RUI֖ѥS/JIӫ7 z< =gEFٚ38$OM2銳c1YBa|yYo"T+xݤ5D|PB Ged}~zbW,>18h&(܁PP<:kX3 RjJFEDp;Y)n2F5,T 4ϡ|nHTò go!`.Pk^̈́Y ?(x9 PRKC[Fu\^>?-υ A  ;9j@3S^͑-)(y̆@lUY.ÒQG1 樂e8,[uӨ@zA,IIB Qw[ bҁͱս3pfd%Qp@:B|'()L.GuIKR{].DDr5X;g,g]X :LJRy) ybvcK&Y•&/3?c={q\F:ӃTN@K~?,'Dxb3jXV\vBj $=#8ƞJ=3W, fY**a¯E(x`*4Ktf:eF,]lz>yK9Jְ5QS\I(U~rzXI\ ̀0'APP(SA?GH<M/QSj6`oj`M eҁᨚəw!U"F^HYTie|\\~q{1=gn釺wy*1'D}UӐ_ͦCbHUB0<qH 0sFC6KF^ @fh!4Y^mU|S & / Kj!|C`9(R/W{"— }4t#|^ץl}0|ᬹ%+O/XzG}OXFD@PS 9XJj̚)p4tT ʌ"MƴMm,Kսj~ii~ )|bi, ɜ0 oøUSOŝv̖{zfcd%_?Α՝L\iEQ+,A(B3ϊs5ULLiMNj2u!AMbk6u6 Xeu=M4BGjD3f`倘.'zI(P-6%KEOמ-8k<1G~VZa!QZ`û"R!VpY}YBg 8{ L2zV9VJhs_ZҊ Sd?$3 Tz[gHzcz6)ng k&d׉'ϗ>ͪhP< +ty@H'bn\EfZw90 T](!Us4-0a8SfBP . ŋtj2"EOMibAeXg(,7WQTTZb؅ 4rR@MXx!H n&Qf2$T('5 yqU5s:ebfb|ǐfrk?aULzN 5xl C=x`!eTHR i, Fa疥/- m@wK3nR䞵pN+ ]eâ'3iO('2!+cTL~Ps#.eV_lH'sQ (ųg,/s$~RJZBu@-ZL-,˗aH\tEfq̤zF;KoE AV9Z^?Ds GVXQ-'\@prYAYw&_f(nxԖZ+1`eDE6<~gzE-h2S olPtMIkZ~CjԢ4l">^@_paXM(r2ob:&@;CLI>Ea35ʸ f6WWJy/1z2ƥ‚uUA62yξiKz,tLVhwV-gbPE2I«PGd}x0q:D\DٰCDY,`ځa>NbJ܅d< xU*c:3sɋ1Qp{Pq4/⵾+WVTyE :WFsX<`‰g5dJk!˴-Fб3H5.uc7%ɱ .k4LnƘyA1NN?t+ܣ(o &VPؓ0"IuT BUwygV5ҮpOfŲ}<7,x<|R`#Qms+VDCm 0" Wp\X oEZcVHpG~&{"+؀1+&_h/~SJrt.m\-93SkGE1dFgQ4"1st%tb0$D JP8b`mY%յBV2M[F3&d~e-MV%=IEu1mnKBzPD1Pln0P[PWl,ؐInm B&BR]k|r[ `+auo`fw~|J5IGCʮdf{Xƻl^Q=qjtEJv(%J+8 ո,;Dx Su2@(p{$`ׄ6L"V^ OZ@l"m(͔;X5y^)VLTsfվ=W.~;e4ԗQd,deK]ԫ``zŕ }b0L!Y.ӪY8g㜃^%ӗ5rE-sg#/Pq?մ.r3Ia<@+sXj p b;nZ9 B|6f!a`kI3`"ZͰk-Btߡ ߯%HyU.Ey"   Ę@ZZ`ha]@5q X;T28*- M $%A3tN=BӼ.RST2fwCC`3Q HЌg Odu3~Ɲfq4&$= /1u(?"ä́Abvڑſ0!`Ix;z\ At&w :̟aִIiƊL̖3!z8c`qr#̋KBά3qZ'l; n4j*Uv7/UBo8h& ֫y[AY ̼LyLMtYM䒓4*i/tI9.7WE$}yҽ0J54 빨Sv _cJ*{oiz׻ze!dډ9X,fQkK6'̃=Dܣ(zڧ:2bA,8:=X|0P[rI_o g]yTCl`J!Yoi:BG.ԟDWkʞcZq:}'Q1>EZA3HtӹK"~fVYi߆ej($ 6.Mbnd60ؚ0UdV<b^Dtbةep􋨥q:v}HJ3XHĦ 5> èz*uv(l= 6FYSӛ:B0^i/c;obUfgvATLp)BHm 6 /DAN`mq*AH ݠ%czPlgurԙ=4%]&گ˷gqr5zSoQf*?LɶV ע2 IE+wMxgsH5.ϸ. hN0Ze쉺P-~_FU,mD:V,R0CvH_h c=u{0}ss9Vj0 eZLNmucT_B|s|UV 5BR CoZZ5%YpE9K 0Sua&ӍS9G ÔXҤ!B|Sl)o-cq9jAS̝Ndsϊ!QM VF!wJ|[~-_3gξIm~6f߷Y,ET V 뮻onAr PD#P)d9' f:=Cwu_4t r;ղ*=7NByHa>zYJKMb"/5de"Di&æs 2W(2we [(h jY|xN12g.Y^1CzwhA-ܓ M+QxO閨Djde4M`tXpvCm~09;BG7F$ 31)]"7GXb*Lf;3`1\X 4reBL-cȇbɿt*?1$k8c15`]g)4vڄa8:gőȪxun9'j(ťnB5DmA E0Y`h_uUM[ $we%fF9;IϥR_֥LtOO@ J8iq.lI>K! bF8˽>H/im݄$ȋ'1#\o`vY= @'rhy%ͣ2ȟ'T0e|Q9A0M fqU MMF`me4e0 JHJi~- KO6i򀴨=*(qRlqծ^Un:\n3ӎ]YRDp9 p뭷(B[:xHG<um &dkJY*ATQ2X]vqsp Rҷ9SЇ>ćJCdftCH-o2Yz]j,`Sxـv*3v::@a>qvB00S@&>q/u!qz.Q6 "ȭ_>0.Cl@ <3܇jO"$Igg;@UG:+ڢf#!Hu$*t6 FXFeRk6qEYnqm+A"_lg~$0\h~-A MDl4MmGiѐ8+U+uVس*Ҽk1ͩ fkQf3f+:c6%+òp䢮*36qIulZwNzrI3[, NObg1gPƎJ-giGu)UjJF'TM#X/7(g.6Ġwj= Uۼ=C3S ]@7o@/bbf2X .6RZ" VFZj&lZO|ߊgۑ|);'b׭mħstTIv:@[:ؚH֝5brUPޑF;*\TPf߬4MٳTҖtCjřʫk/V2*˦NWھXfLTE935 iuL%nh2<e1[J>yerdn(1;BqM)#Hqtjj# D- M~}g \+-Hb-{ba}7z2fR]ajdc{֋eb!'<kXٳ/bͳG1J?Rmy¶y[!N N[(CW74ˊ)!מ4OVff. 58 YXjJhmihSX0#Y73Ckf~lPQw9WZѺ Ը5"}';LN_E|z-x{Rk=)kϽ0M,4OJ@(D` , 8=` {#71`fsGA t>F^O!iV脍F+4Q41&߬i,~ܢ y aKM4?U9>Nպl--Ŵ'j<kQcVYGvtNlH| kD jufRE(6uri>128+WYk7=mG,Ug)xjpilFggП2XN~TI]iv\fW8Y2F3/cfݺ b4QT~{SjQQi\L 1طJx(3O=fP\)V토!7Wq_$&jK4tuf":+71E;ՌY0 񝙪i=OeN=fK5D=B ~c^n/)Al,_[WjڲѦtbG~0&i}gR6rڊp%޺j6(GyM+} udko[nV:+5&2λYe;kMYl-zk~Z¥z)S1[o饭p?UXV4NqŦKqeA=OxHcw~ΔRLt(r2Mj9Y*+X`LV% ԗ*u 5`Źқ.o|*חj 3x4/08zoSқf'Ygb{XX!fD0D".`:V\6#3-QRYWљJ_z~-;2R"&X0aڂXdm*.,tL+#{ C\Ě.λ}k:sιoK.L ౰OxuKL[x<$GqNrGoSH*]*oEI[ϩ֊JkPYDB3ZUMM:nf?O}ӟ8 ¦'ـ翺N0_`0@\Gr< k F {h Q5㝒] ȣ)\V`95zr&kVZSОG D@ `'HeVxƒ`r< 7h9 3g)VY ̚sG֐g.!)&|gp w] ׻npI'āpqԉ,-aI0bfD\Hh={laXXBjY`ڥ\xm. UY݆  GeYkj.t prp&)Y7oͱǍpnfwY2el{oY"%WbAs_fe G«0nӸIvNl3lo#D2B]WѺvd`8(@q5e6lvE d2P!yGzg?I Y X23/d{ 8!Pjuf&LuHB%cIypM]nk=c๢73 XG(:'[HDp02`EЬ\|ٚYmBba[6Jydbg.xPrіQz\(I w {tн1DY^DkԱ `_q՗3@FKA%lJL&x|}ٟټ~|]zWO>A;BD P% ,VfSuEy6/fpbAm m]KPLsDfyٽ !`:WczJV"K%7YOlC5[S췷;ԃ1!Q?qka8X\) >`x'gX5=?흣MϷw>z]lMcʄ˭OMfvc;g& APT>5QxS;[H%:0||g}"t{-K0t 28erd96l[,"c6utq^ }$tqҴ!Ե"ФCO8 %u4FlMmAl'o.%SQit$ovJ sN$  ! nĭ!+Q Gc! ]|l6Nt{A~ &t,זd})7h֔@< hT|,hz'rVήKͻe3S bnnCB\pqJ+- G)0xa(Wܺm ԏ0\.,kP\{s<LNT*$܋;r_~M7}# a}ΏF+zdjބd7KS-EХ 2)JY`q=@ކpً  L4yR,F0DZ@P*giڦ n +kbb C1Ģ(zg#.'\CQZte㶴(`a-!Y6&rg@XV7(R{Yu 7۠y*!L8}d! y`Xv7Hw '`(ƨݼN@LeHԄ/x()w7ԳyŹ}M;h%D#83maO$c:gi y~̙z&7g L(~ʘP'MmLT $3TB[1}7ɰ> vt:LcS!I  cd*Q+e r P;VgCe9֜EffŃ[?SE;ш?a 1liK:!WAlBlS_@ݣُȗmoήϘ2QsRi%5c|^B`~8g|W&P/n?af Sܓ 4_,d9*`*Oj.2̀Z O6PЊD)v5;++,hi[Rka(5B24fn>7[TAZufpӌxX#'k ='fhfID4B,dĜ#6HS-tMG drGy4W@tʐybbznAm:52mzNۀ` ߧ!+M7"+nFfRLia7.3gqHP.Pf.TKLWj&MybcW УD$C1^ₘI R^ nemSt.`Y$ !\w٘q&Q"ү ]۝ڦ{/!Pk^̾]jwr=$_iC+Hؙ5m;nr*qiNpcݸ:T@#KU*g3z L{oQ)rPxrQpRV='# Mdŀ+&_yUT e%9ԔhN&g6[-$MPB,7Xe\6GԳ~݋Im:ٱ0T `xN}=e*||2$l * 3jR2[hj6}f!FlZ[L N ~XW+U ɾdaU@?/k_o[f5dlÜOc.YC []7Wcn _0tLwJd0p$ 邞DU"ORW, 7; v0U紼m8ԓN:O<!0=[ӲτDm퐡!4DKf^ʼ?dٔ>SyfACP2f>dl}ɟ`3$L P.X{Ґj(?v9FeV}nՖWnR ՞ug2g6=,}IlXFj17 z̹O+I;P<ro) ADO:OZYݷxSOCX Hvw@{[s~,4hl#SɫDN׺ ,1".#H3p$c]1&=~1D]P! t(Վ3&`nl<\S.dZ`"Ph9BU\Ybb)KC<|b? R)<A* :p&l9qggJ&~Q:s}519xTp6FZ#6q{ߙb{~ aAV<5|^n.ђǪ`BӼ 7PaYh~]I5FWCU C]IEke?ʟF$'0I@`k=3  bb+zҮ1] OfC_@Cw~rAՅ83O6A47kH5LFY ` bja_#]l*Tz׻.w \9zfsPk,׾J9{yBcZ{\SGm#zR8Rٔ+x%`lj7\mt|uG}2A-dXt)^|ZL؅⠳c2~Vի oxb 郻JPP*l7lV-*Wjn>0apH7Q(+R\:#3aF!뿟ax|J_'GakNB$2v~1^5e6 5O`6 ojIҥ@ C.NIhAsZzZ憉O<}@!1 鳣l',/x,l6T.a}137f#ldd2 mE[pT95S"DyQj8a|s"P0tl& h'(C2kLb Yl_&]ڎGleƴ07X/ӥaXTavm6CZ_\fHOUlpX37S/PSSf2r! ńR>bY+(Б ޘv^b"5͏+N?tl>5ݒ,h-9 QjuMxtHeYAB-p K7A[$REHE,wD 3 &nʕc;?7<`jW8 +y3y ]D2\IyxO1M Z@,J!}646W`Ib`V^4]$M1]F!!]!;K8XlVCcИY 67%:w{02I?a@dK 4f(]&dLm) 4,(d<Te9Y*Z&7Gcb3mZ`cZo3_3yWuK;c',QMDdPq( l3}ְG;05ong7\٠G]eU֝-V<+Z&LhJ.\Tj\鰵~sn|v0VP,țil0\Z?NR'*5QfhUL2dY72JkCkb\A:KԦM/^{ve^=a8 wX(^y`6 C-8x T45pD8JjOgHty^^lxiG0_:S#+Nl_p0Ů`{7s$*xg~W1kmR'xCKWq)95UĈ;ۇ ,E(,ªBpaW ~ ̸Z>Z9J= dB.U76@ 3[4Xqs`2AZ60XeY_s 2paG1fn̍HUL7u~M݀67`+rw"D0b#Ԛi# f!{ ~ pkc;o!2 fu 150Pg+賯6A͔. 0a;-SGZ{x=qn*UFB X# iW"иwfH Y bvE Nqƕ6sc %X8^{hQs+3}t+J ̊9fbϬ*؀υ;`܅' TȈZ P"\ycF7Ks8zH ){D4mSyYϽS%хR{)uh ;w3īgv3%d40,2Lc>lo| @͡mRI@di;,.R<@f`09qކ$<<葬?D:AEA0s /,w1;] "4];MX}LYOʛ!#7%gIUR2XԚ*zٶ0tf&f2926ֶdo8v =\7X@E ,Qm C7talbD=~u2wgIV(׭<2OGt>p@8qX_׫qG 0*@g%CP;Py2skXg(yF,u)P?6;)B H\ =G s~U #ufau%jQ^='tQ U+9kc-U避q4LK`>ZAe ;&%6lJnߨM½t%`c*T:dAr}T(R>xue,}#hoǮSJo*,:V"fBHj[$XX=x9`ON[]i؜<܋c0'@ZX֔kCB /-bfJ)ZsodUWSi `ܔ)9RPK>E@^ kluU>[0@'Zԙ^(孍}Q!<*/R3dl"ثXxވ{57Rt((6m4t匚B Zy{B 0Fax&Ayo 3B *EbۖfbU( !Bys{jʂ6!B{X *פCԐ+N VBTܜ'ɰUp:3KcPi>:AFpV`(J IV:f_{yk-3,ECS|Z6Nu.ԣ:QgfApP?(;Ӯ`7,-GTc뷠򃼗o֏l~@R~hzNϽzV7j@/,3 xE̺be Z>Օ Kҝi6!`Dyϕ 7{ HofQAAۄjad|_1\*GGk TjRN,JbnvdZ* M׈q1 &*!z~SfMXVYiyQ|<ޥja :K񝉾33k5yO1}T [ y=tvXUnP-3Xvk_ZȮ^-[]uv  Cf0~/̇STЩܺ B'A `,sY1u'Nc_(l\Sq5 mo0$~m v:tyyW&u'6oܸ`gT\-MWV-K'6Ifr,yxF!fWP; 4;! UGtvmB7~tR-S,#VDQ0Y]N.3al?T́hgܲ htxv- f dl@eYO4+I=XG&dŎL;! (6TW\'Jit};BsyaK(,gQk/ӌ'زlH E6a֣~ 5fpy@cEOK@%+a'8IGzaR \%Pʘ`2[<F2Rvm~no9|n:E'M6c0#Ī7U{_IiJsٷ#L(KyL< &ˏFK|5C-8g f1w5L(#1 ZE=I%YHUjSyu,UQ0ȯ`ErL(y{6&Ef¬?lB'nöP>P0;f_6Z ?2]3Lj-[jDTS˜*fUfs ')1Lᰜ ǎ2T4y4ֆ376HӳyP{z^jDmV ėPtҺ#y -6 Ml)5 IĮ2'jm#L_&Y_=G3DPNOC:8X ;|~O͒:Vx5m xRy6{Uh̰-VԿujyStli5-?cdE!♱o(l*J[68 gтѨLUCYX* 燐O"n[]ȊcO4h©8SUW@%x 6ߑ繐6E_LR\جƔ,%fk騋xbMm%68 6[l ;jR2RC\QsG"{p`[s&AC:< OΖnYݹgJC9& P ԃ(6 P,1.O ba8b@ȶD]sZ]:uk ֒͊|>b xN/\ 41|-a[  UgG4<8 TCA*/EXRű $$ncvn<{U:55"T pIDATH[U@Vs) !<7\EMxHi9۹5Uֲ MtT,Y%:(لjl+]ٰ - 7=ωF(M@tlX 7u^yMXe@a"T cB5wd=eOB$8η6"@  W _{YHvgd75>\yH9l<"dZS _BfnFKd֩Cw_crd,p$V*QSSN1&$8~Y ނقde Mi+Tcԧ/.qM:.U:?fΪA=!iwe{plM]6Z5i|<6hrT `ʬ)ObpغSlp2B*pJEefQ%if WR~Wo 1vQlXu0١o}[//;ȷNR9#m앒Sx`@t `ޭ:z8f&皟Ğ@ E36ikk鯕,%m4 aUpǽ) 1e=VT8r//ߣrw+DŤ+"o_ fndE"+IQȳWlGbx<6C?:8q9hagc: z!k;f~G4"/?;H[8y&nR%+w}?-o%.UõR#{TTc'Ɨxf~5>;Ddï(vZ"?#<}LAy2x_@EA|o B:tpEG ?lw[鼅w/fDW~ qf:` A2vx||X&n`vZ@Z<XM+XZ;벡D*YV7O`a+8a0w"O.!\^ا|Q۴S ^&1찤l/s-CXqV gxx6јW h}*#$UBC?Ac|g 8$b&{Ik3<>o^t J2xXON.A, N: 7Z f]z]X~Ϋ`K^*ps Z9tlN(aYD"u(P}?;q1 Q]3. "co\?O.b$~L%#X}IQggT\mv_{GrcsC<[;ʪȂ~ ys-Έ5Ah߲q<*2_^ƊdX~XQۿg5+5Y1k=x-.y w}lC}o'&}ʒa||3@6]ɦXk`~ =?>9p DA|#[UK[\SaY^:'bi=FA$"UV+*#nWߺ玍JLU|әAq}lǾ7cq^>A<뚹.nkɺx*l` iV,G:W ٞfbAQgȤBjڴBC?fGl'1G6(x0=|+1W$/QWh^|E/OgZ"Jzz^Q#@I[k ƾ_߽QIC%la;R;9&GrΌ>xsu5Jcur 5p5/ RΈ@Z9{@!S?-Ţ5\X/!@u-~tr1ʮoBX;X\M؍TA %m}Ƹ7Qhu6¸8 =T7 "DpғtX<4P+b? a#Z$㶸EtӕZjw ;FD$?  hc +>_o.i*OWGaa?cC LH<9>@.;ɭHNgVuB c%آ=Hw޴Y]YrL ToVje2QZ+W~ye8UϤA?d'x 7ɧa T12  HZ i9} ڭ0\F6fU`񐌌3t7^v(kRn:؂nuEi z.UXm`̗=Eu| Ƴ?V@. ^2y;8RQީfRR@{s>r.Sb*k"~%04 T_M5-0yG !o ώi)"zPB FWY [g,ڊd $1{/m|_y*%_Lҳ}$i&PW"gaf,65_sҼ]fvͤ(\6UNy࠱8x\ԑZ).y!4nɦI֊F*'/u!vIx0G +&)pϛU)U):E0{iqeLY }.H <"o yvLIևKv?sw(_pϛsY[r G;gĝl!nf<X~UH.U<({L]zFo~T%c?'8hr3 dڣͬzrNVirB51laƻX:i#R#߶Eוh^wh)Zí5ٱjC,(1VyrCEnlH%]3V@v[}qn+}.']" bJ0e:-=Dyjy^ȱvى~dx&_קB٨aqR{\yؓ2Df'EAtZÎڤcWU.c .AKDu,#jn†)'nzo;cS!Ut'vҖ"~xȊnȉ{i|, s}bMN5_7ji$r :oӃ:*6g UvEK*n@|¯8! 5.vmn1Ɠ&bLg /UuƎJ"'ztʧ'NU2J"~<=71X^x "h:%k~ xun6c Q&'bKKM, _j79qWaYj%fn2p06'|7rnG]+?2MY+M 9kq3%t߯"2Ud࿸xk5"\2%>RIHG V虾 RGkt]^Fb~#q[FAXHޓ98F o81 JDͺ.a .D4r: ˱#]V=qKg\$۞op:ycڙ=&3 /q,G:'5%^nR1+3ckD8x|3'Y֠'> ߝӄJ^_(ޔ: ϩcqAA;8vKgmK^FЫb,[dVHK/]fQdE#KBdX ZQ89FA<|:yFzL`قʝt:e6X$(/]" 8~ C\L_)0j!LN~gN8@ zq8mSA%](wY!c5f9ˬצ9"y7g:ߪ*_ 0eC$,;{͵+-e7:@N*dcWedcp{qB~~!]II<Z5Kz[^' Χ?H}b/^Rmˬ.G(x4aSh H6ݭI$B9٭dVS51ܒ+X"y@/o+Z aD-E|K<3.SYbs_D`(5'X&UAIލM8tfinRjlT uXVpU6}ykQX>'?]a:O$5qz|gLWevn*dzu /蚊kDB!%%[uVZ0kT _v͒hC Յ԰V'G- /gLmĢ,ʪ,] :I 16IYX8+ĸ,63.Oqbǀꉳc.{6DҊ/IG aĹ  pZ3ۍ4<,AnF޼ uÊjb-Z!e:`Uc  ϊŷecж,qEFV9+[Ox q~PYcS/N + ׄ͝UŴ֐ͥn#u ݳ݄(!‚^"Vv<+G*< mw9ڃW,a-xaXɛkVS 1 S$ تd4k拼+79[ScN0ބ|lmx߿sB%XI+6כ4}fF@Z`{NgS̭Ǝ@Ҵ7Iģ6LuCrX7šBHDkA&aG\Q<jc`R۟;tXSU5!;_BfI(o1YL8=ŅuTe8M$&%a4XO11gp/oX:$R*OV?FŻY7b218T#`2g xO' &*Bp|%9]^eP^`\H)cG4یE*[L% J }XhnF/LVlĹv LNEr=gG\SȾR80bWK jt }kr +ѨP;Q{nOȱ-*aBZ~%l8Gm%è;~H8Q vRwԨk^ZzSEʠcnn_(V,K`y#0Sz|q^ڲΚ_yHvn[m@__s@NƈX'4XtMޙa @͖O1p?| nO*b+.0,Oh9EyѪж9@g.};EXI uvبaXCHohuFbV+)w5/YyAlf/O4'M.x “s3Ndg^.1wk$ױ.?|AQl"w;<17BKUY#h L^miro۷|^"D4V€E 5%0H- pj9.9%w!>).?alX3q|n1%?<|ъf嵀j.%QX.ÝvPF,av^\*/lӀª|DIevR TCY/_R[S$T,[ct(/'U=_Ds=Tڠc/aN@:.思,|mC|U@8WY_sJrGjN\wլR2::\:Rk5$ȉM]%R!ղǷln:b̊[񄹜dzT3s<QXk~UW:B==e+FrTN XaqYϝѐ[]V4)+߭nj-e-79]<(VnQtIewgly_*us@b:cs`'F/uqnsc$6etY)OCwjraWMcN>N$?M-02 A^w)bŽQU2o5E]sؖ3]0W^IMFav5$ uW#hӒC:@[gi!F hlG8-1kCE.$Afm#3RDz |⫀Ԏ޴T:mYȷr+e†v$< 6Ɠ𘺾"j8޿qsI3lAœTq;_-Y$(E )?BwxRQCrh Vdu.O;v:YchdC\ !!="]\&c^=K0.GO8jW튒YWm;:(_ܪ% ,@E@}ٿrh bk '85oeC:Sdu,,^Ng@_-EDݛ;T=|KR,K-6,sHyӂp`JfU9jYYMn6WkU(1]e'd9nvjзhWsK8Wݫrtecx%!Us)}0"r֪}̔%} 씛?s?[A^c BUA?u}Lw[?NY>`-ul'v"' <nemUo4%uݫzvQU[j6QS[Bm0 :NC F+_T[ Gǫl!9*'(v"ed#Vw]C2]ah>f}(ց͂r FRKVTxW\Z؃H9҃4j%=-f mfbd-*>O-yRY C|G%|ݠ++]Tvum]<%ͽG&DM--NXސ܊h g9̀P$'yZ `T-HA>0ޓQ9^wHSO{>]JgAY:kD: s݆WwF>a:Rk[ SHD옘,/hvC]ӨfSiqM0/Zwܠ!.)Pɀ?3eAY,!/ç5K@%5sD8^h1j/o[t;jXc^I54\@S֝l$9B·ݴ<>0j}6R4u-޲^> Q//|r*_Z.^z(FLkrhۮzy{L h56Ru3-C8eE0R!b#ӎxΔI/zA,>qߖ(㕑72K:jVBs!T LnWs?[܌a傴 mf[wd_M%ڱ8PvXO`llzԑQ@`jb\ڕzBtX(o GJdÐZrɷtR#eB}& c?4ic2'!ŇyhDIF˜U3y:mwhhN!}1p ըC#߉<1~TwlqeП'm8j%UW6s奱ZI"\$H[u:Ȧi˼@qrj2$]hkh*gSBVw ,PLo{i:6o:ISgV?i.̧l we .4UjA}{Pk |tr4/M AkH` P(k~dn.-ӤbFC=|q[1SHr  `R? .&%i>Kg旧zgMi?H/d@⇙flE;`IOzpJ|aBYL/Zܨwذ \'` F)^w,yd#܉ R$3 %7|&w`YP8bJjk d qQE`44p,T '+)!qֿ?͵v@%V;q=m)tS/JtU:s`ރ4v]nF\{[N}kvXO}Ӟrڗ\1͍;'ILQł`31u*Pl;E5ia*Ĥ s7mހ Ahq.selBM8lpA)ւŬ-/;q ".EOKdaV犧#В(rf^SK/a~+_c?,1׳<4(D}(N7}Ns+i6VUQ +<5?9~r[;#QN u[ ٿ?Wjըx4WPzCdH]ٽf9sToXC@K s/nFOThEn$*qQœ+5\H_|\x)ev;۲HY0mE51,yt@P2Ľ*]%lS+}'i*ٱYx ;iZKĄ 2,F.ټW6ޫJKaxM- bg[? ΃HFoe3%V64wU7\JS9Ibew3Gt@D%oa)0K.`scSO7`s-_*lɪڼك,Y::*|t$KbVRiwWI֯2`@ui˳䵓*eHLb l#(ͺs؜kr+ӎW8EyZC[F,`I*,{oGjT)S=I; Fãa|q'qypA,BۃhŒۏ6>o$rMm@6X O\k;?{JR¢v96ɫX&2cw/iIܷtIP1E b:wnK.sj@ 9TbT]ތ]U`oK9T˖zXH)1Y +^BtމMn"C5{Ď!{HAax7>}#?)۳S|Wi,SJo66w}(E,EO8Z=:$Vl*یS0#?x\` 0 T8b@sM0g sȆ6f7s\h `}|<^dFyxJcM1sO?/}uW-&Fa dy,ٵ[r[2Xe%1p窤c?>C\?a@\#s =87rq8^]`mzQxDž /0 %㏋㈐ x'v5ԭ*b5ϔ :<F=Eyd)FRHVϥ=@2jeQʰRT[B;/sVMێbn;w+ȧr3X(kA=dQ܂v|N¦s?s s."rzp'_*>֬/!&x>tU!LcN. Hww;S5K0dQX FԹ\)DAN+y}*֏)ȸSف,1Չ=Ȑ_PÂE+6aKGx] o!\ϙ\XYv܀_v߰f]"THWǦN t1jrHcUhݽ V,P:gRT׉,77%"d0>¦x5١%4lk6n`f!M:?HU MxGoPDff'Vѡ&cNB܀aC"Nu)Ѓ!S X^ +KG7JÁ:#BcTӗ<',w\tVؾ"!Y/gOSfIs$ asb'8ԟIK0;'"#q_x2YN0撚ȼ7> ttK'ݽD;yy:<)| H=M.B%֚lZC&-q\;D!܁YpaVlt^f?E3蜗R~೟?8Q%7< ht+G홻\||c\E"M9dT!`r_\MR>bٛyFgg9u6,J=fd7*}5fC]TnŜty#"JE jA@ xB ߱+XjE!* AI@2S CL}MoRc?~KUP܁ ?E\b;Zʹ h\91_>@ DfO|p?;^A͞E,.[X \:@'rD862=wacHc0 .; pVZ@UKgá K=Hh(V-L iG✦.@' @JQѾNJI](;+t\]͵#ҮuU&S:͵ [r2jN>_apŧqsn0v^c/rD,ZfUݩMڔ^um[j1A6!&,/;¿Gaܤ ([Fɫ;w P.@@9o9eZ(ESS +֤˭:ǽlTq5pi@@=1Bk?0 qZ̓Ժ Ij8"eiWPKu-f9ş_Z+X;'1ӓYz/V05nHjKҖ5{<c,imKYd_,)ouZ:Vv形5kp GDcf /9ެ!w9vDŽ~"Ė@zG`u?sNyɎ#hzRTje{`% ×ˮ~ͩU!:Zl ^:_gqDHX}Khu噓I,kSづLG;lEŚ>t_ Ϣ\:@ҍ<+ ?r!T1w ^?lVKz0b\+bhb5Z㻣_(W UŸtxd9=m_|&®OX6'qJ]$aV.2J[sHg#I˿,ɡCB-3 &$0դ mL@puQe I#.]l6[;~#%uH.e1׿~qu7H#ՠ]/̆![,ےEymzMEw\kMƄz᳜ѰxMD(Xj) :* Ih̺?eG4n& "Vs-y% `܉]oZӃ2{0Fokwy-wGyD{P7D% ^SY\MkKuG#i~մQW{=tzvZ#c]~aY ^i ⭯vxG1: iNv˷vulڢQK1[w#\([@@浏;72%YRkmC& &c@M&8`#\vm0w,GnX??{JZǪ*3{Jµ&(k);2UC@%coJQ^pD%c`ZhͿXڄmT7 RҵX>'߽D-MM uX <y?f<w8g,Kbammga B\y8DﵴM6ƞ^ j4w`a3-zTm&YLd훏|.:کŸm>'Jd7kkxMʪ u7H^?nԪg`1X7,kb)QZ, 9<%74ftm_SOpG7(N*ONif'a ! :`_Y;q)DѶ:W6v}N5kQQC7ŸyhK$j:7I\{C=Ī9*A}(I+,VQF (P?EKϩNHa%YkEz XBޖ:Y7%;; joLh'vSȽ_&26 ֈcӟ4?T$/g!*ZzңVswGbRH2YS(nްp"vJ|n>V*޵,rxuM̺9ΎȓBҋMc#\dFogWN_((KmI,CM)tcĎd~$.ctS称,=UiZ"/}k7r <,]*'QGHY(Bۭ~F/pK,%7MX)]D:N dQ!mf"^^NaK^A|y'4w@nEC] e`yL$p?dxOۼ7~"fwT'p1jSwC[g79w<4?r{4T1RR#qX81ކξa bёp[:ԛvid7)PҹҒԛ[8\%H`Jm\Kh'{r۱ )I1߭Dr 'ptMjU^+3m4uXB&η{ -o]%S 5$偐.qXb![V`O-FVBLVDݺQ'5A[cR3cY%YTukaa]]x'~3&> jMXQ$\q%&Kse-4jM<-6;bIS[Uk4e{ѿ2rJ2ïD/~cPT% ^n#\`o&Ǭf~WoX|2oAV Ai*Qӽ9{Yb;P[O J|rzu "\ժ@"[mp'=Uצ[KCLlJۢX ;#"%| r_iM|!6Q3ec"䚶@;yRŗ9Q8.aZިUyY0Ye{$|zѪ@Dez9˹ہhCԆ{9[Ȯs!c&$U&}J%^S;+#hvk@ _$$pT]`|Gh1m7lƦhqpRFwչJQNZ^s~K_+iRqJ?,[98wcQA,>0Yuq;H(ԋb$0!Q``MAѬ ջ%p-;\A ;Qd^S'otqi"IU"^EpYSw ̸:/c_1W 9d(cb<:ت,$?o9Ȑ'ȐveFTۛuݢgóTd>K)蠀neVز6q XN#4(H,C{x nۑԦv~ R1mķ[G 2hW].+{x!{~' $XHc"y#>@df3:V (ײeLWx_&m'rr_웬@45+ (z]MˡP7[$u{w]??CBj-7'°רi &nZj4A4gf-XUK`TDPhdc1{Ν;_4`p" 9=gFaGH^YaT|xhNZ1): Chr vy堘zmE p0PT^Ub-yD+Q:[cKKV<Ӡ89fQ&#ֈO |O?UXH P--EëouWc`)J 714`-ln8M|CCxꩧ?s%Y1-íMTq8#=KFR z",ʷ096~ð4&ҫ6^ 4Rذjxr,w;ޥW9ǵ+u _!L_`1h8$q Rsi:ɃuEM-]XȂ{Snb \%= PM0ڽ9yn] ܺra!L- Tkt{ϊĖe6ä4M;r%/)3N)sam?{2 [UI?n}-&~,(IS)ll<?&T6 l,TEJ<n.=ijUM<k\8.Z+YhisbKT߮Xgl(gvnB6fH-E2°ۢ\:n vkpFVx#XvLլm^NgbcN~G2~הc~~4(<'y9߽D@h♮Z+%+t^xYju1t=d Đ*:m ]=7ւ@8_Xk=tay{@ւh&BP!g@㹮ܱو*JYl_A mnH7*3@]lO_8 X>f4{\{_^.Gq*1__|G~a~ jE2P*k!7(T;Nye{j6/V_%"y^&dY~fMVOyD8<ɐ%死Sťm#IԽn{#ҏnndlsqH*ί|pT`kÈ 枽V¶ 3[-1G* ^I8>S 6{\RnC~U6VO On4c(6sM5dAZV&R6F]շp)f܌6+m./,H5V0}qT7ĆMRD߹{ZV`u[3 ^!Q.qfL(m4*e*b({ j߼!l|M WtE-Ü*粲p-_mH,ĺS†@@U6`\~_8<<$wp/l646:1N[ o6.ߎs 5j3\|YJFKr*ͣq-廦te xW{_3|¤-|jr"~rL,Etxu,{|=x.(K{CY Y?>Fⴸ8L`mtΦUTE:h?m"X݀E}k j,8>1(0w4fI94wmA*|`WC %T2ԙ$[U vM5+ kڻXkP5L ,E*'/ d4G$[ X G?=y׻wGl7D}v`)A,S󉛋u;}mm8dh^}R:̱DOi,7[o2^ J[oEKSLRWǙLˠ+Spu}!q`gq,)~&c + G]ԃPv.5U>@+p^ Mx|] (|Mɜ2f-c{;{:Q,i}[Q՚q&\ Nj%Jws")ARbۢYnQ15Dz/6Q͂%r(4bZkAy8MXv1#~uu8W3B4Q^q q0pVN*0uԺ}|{˶o]7;K[j)[6Q (b3v-Z+YTaѝ`g{.bogL?>Z>`ԡV֌Nc|>}KX\3-it&Z3hUۿ4*J#D2`E;,G Rʼn 5Mò =$/Sy[k?f1 {5dkwN&0pfGTW!O{;ڛFTN wnD>o}݇K8@ :55bVT urus_fM8^kIuǾ1t)׾'|TiE޶W!fUZSH˜%3CİJ8v*`Քۊ@c rk*eWe[͸.n&`L00}-5tv{[vhVUݢJFqO:+Žpf#ﶏS5ݐPD܇>!:̀q /x`Duxiv'[1N ;cYn5)x"knaK/o}?o=/107WP߁^ɣНVrөnXF`VF"_%5}:yS:bt-j)vW68"d ʵM$eIW)L~iT^% &TqS@#yB؀ipd@p^79I,c,Wo}[CCӗe9]F}p;w }w/@RCAs8› Xeqq<*Ew^y+φ9WC&ك*vruA\VR7Hq6,sJ $6j쨌h[H)HpiB.-e7b"C%DQ|?wKy1>'yq}c4ndX;,fSWP-?p~ V tj;@zPNxUJu~L!m 7W]@sUtڋ$+)vN;$xѦu}`"ה0,&-1l)m[K-4cġeT +J1fO bIENDB`PK !riword/media/image7.pngPNG  IHDR?1IDATxڴwWQ - ^H(!H5<6;{E{wB BBB)`9=ɼk_Zff͚ίگO__^Wk^󚗿{m_Y'>zc=3>3>s>KKk替뻾G/{??#?#?ܗ=ӝ~~~W~W~PO{E/zяՇ٣[[k6WۿOd6Wkk1??3?? 41oƯ~雾黿|]=EφKOOuCoon??5D,۾[[zE_U__e74~s8{H "r4_4USp埭Ol&ؗ"4Fۿ.*)!Շo\g1__e_X˝}O~?3?9yNh6Wo7z76y7Wa4;qog_("Mbҗ%/yI?E^ٟ N;餓N9G? Z4\ :E73+M#iDx(Y͖_(s$ G^n__}ل2Sogi|sW$vtWӛOl6k+ OP 4lj87iOl iË/n>Ͼj~ۼsEnXYW7$6oEՇi\_6KĤ(aO9__x9<=3GOzғN=ԣ>#|~g6~Dnjs' -s 7E[ l`>Ԉ_/5R0?>ws KK#tjbz#OTb^A7UdjUZP*\}=dE=؝&m81hx׮co/iG ֯mͥg?In놙ΨHD 6{~E F#c*4>>??hT(F4l_Fc9X.=͕З8}r?!٢W;fvzDiO{=g> _vSOc19VOobAwav衇{Iӟ&RG7_\q@b)'Qy&Ѩ/yw^&fބmMk??] L#M7"3ʉR_Mo.2F/-h`}٘39~???nj6d7hX=qx1S ,*4ޝ-8ʬf ^}Q 3m>8%mR##5LC+ oxv%]=|]ͭG5%[=/&ٛ+KNA$мX /+U$8U^{^W2VcƜL6F"flݾHb2&轎8ho>wC9$O}jΓEH#W Uc ؠ8 hg ej95¨&~(ņt&Ylj%pHѪ14{vۣdm+˵ϦϓS MZ&;f4o\{{>fbGon׏SH&ly?F-+4fLSjsA2@УiP8n@MO<1D^c/ַ5ΞF]Q%..o[׽uINoF5FbϵlOxQ" QwnH;k6̞>DT~l;z_1#iSn'&Hmzѳ14M;;J-d\:Lg{qwF<9ѫ@?9\XͽבOZeQIЎM5rt$5&yQG^zЃRrkSQO"N_:֘S -qdD$)׿\cj}lb [WeVxUW͡ih~E[Z&X=y饗馛wIN<-vﶫkI7Fڋ l+b(Ihb I#R6¥<>c*ݰ:7lx-[$126ڄyC֝`4h2b5VǶpM36WMZ-⸌HJ*:S9[+ޓ@>?8#9}zHמ'"6 rg+5x+bzC,C+ӳN=wf OyiR6)twd1PÊZV+ڈZ4Y2o}Ə;"VQA gΛIlqa{QF9ZuOz=[O=7MW\q?l/ @ͱ.Emܙѽ4HIm Z7[ۋv3sCL&P7+UagtiQq@/Jwlᒁ;,[e%^yid 1c}2gXKW`X YDi~(ӝѳ%Ivm}٧c@{ZCbX(5 |B́ӪqZ+ddН=굯}mw^tEܯcpShi!LbG P @I> kbMNޫa<1lMWͤF֠Hy1ez%x|o1w El>} @rr __|/UJ7:@tP2л"B֌ZhG} f^ *'.l`\1K!FP{!X4։&y1y(jL-j2ےNAqjjz8__ fK1,j"Bn_oӐrKmGq+ꍩߊ(} feXlƜ ',26X;3 9@>VGh3Gmfӈ\iV٭6ր띅t˽ӗ}^anWr9DN-^l[ -p9E %1?QQL&[/\}HzHwF&A[̆,k5UzGG #YR /J&+U ͵mĤ>Fs$vL+aF~=ℰ4DoqlbvE[o>V i|gVOFsmEjkvqrc`A>ǐi'6[ȴL"A/1eZȲjWo G'-M4t3 UsK$!-F*GB1e{$9:[ȕgjMu\"TolO=LL#fj[zZGߘ/]`= n 'M$DEH[`$JQ@wqBtFc~w2Z^h;y~0V >:7}O/roLV3~02}mq[#IR[IWD 8R1kx7Ƒ%zH#m{l'z#~Bu3_M(F.ѩ#i~`v"\Ԫ2ʉ%E?\}h=yx&^OW!r ֌M&$a\.j⏞+şeѱ Ø#.{(_L1+a#"VO-ȁ${-5FFF nDv[Ø}{,v#Ob֬}N$b'qj{EL/d&q,8G|WgkjȪ-*["KYAbQ&ےpF5ZL)e[R౱Iz80}o,W787d_FRLlŅXTn4NN7k?&𻛫O286z^o Voop-nF5VԔRQ7Um&ٔ0xS")tfv4C"nYElspU4=+C ys/$w䍘%~#'wp^{mI<|M3UUmowȣ|r{~ljB,If LiLnev 9UQՇĸu#ƫ8IٴPI1@F)aA!;_xf+?ksq&#FHDpbk6> ki4h qfWEcըxئY`76A@z}X }͑ : Qg0h]j'vщKa}9XT;˨%)8!>Ro` g#dO66#ޘoͷqaR?"A|JR:i`𽮕iW/h lSp ?`egrFA+U&J%|\(cXۢ׬zcoXiO{Z7Qb? 6k "5KPAw$fc︽[% 9(DgwĊ}PJȆzqnvL/ Eը(z*Yq7WfFz4H2́Z? _=m\dž"' kjwb )?\}ep$YD,c  R%  qMW:"of -S>fc%( hHLMg$[?[65υQR!Z?O9]$O~;xnN:QzTP٩&~&L^A& #yk'IJ5Rb( :kV͚OG5A'Gy"K QIءGaFE$jao;41}?O|b2\\ŋݐ?&P>~{sJIN93a @$)=H*#7^2mQl~ܰxq`tX] 4D'<ډ_8e >!5z3ݻs9řJci L lb:BF<6?f?>k>JJcqv3P?iާAhIR:/"G҂!i@JSkT= 1-zuR:9t-6Gm[,p9a`ST{Q,)zޗd'DX$jnS4Ykjzs >MӚՓ<&b&~M2$2$JUGG[MG^쓄X:Ţ"N[e!ѹ9 x|3p }6.#K];qtiW0mo 18"`9g.qj8 96ke%:ǀɣ-$EvizYSIQ>.+1 G϶iunnm%zuZo:+Qm!|~Tm ־{淿7pû6WMpD^g_\NNaJEK^2DgV(Je 𭱞Km&L[Fgp[S.5g>8/t`n.!B4dYl &hoo{oe{f.ݑF)S͕Yio2RH\|57 .J|MJ5bDDZTU-vl[bЎsH32[F:.Zsm#qGq~BT9E RʍR& JvZkVMi?GO(!rCi"Pw*py2XIN vaǮ闶VxԈ2)q 1'Z${=*}"fs F= (wC.vQ NhX %釡aҢ~=ġ91#B$e?/mXL Vzh AW[҃:h=}wߞ%Z:h$6cσԇ3Q1 bܭD=Dԛ@  eज़&ȻQN %ѐ]~:fhjב,"W"PP^n=Ϛ)9P=[6D>iP@q`*iWIS3~"$3%O&=;B[TJ:g@ "O |aBpX>SdEpÍgz0Q]-מ/e:qseϤ(NU bX_qǒ_aBZ}6^{uQGpDӣQt8̌s=)B^"e#3DC4elz6 G?:K9JN"`^ ּ%h||0mY>>wOs\*RdkYt+5#0mZ31F@B(J9~pyURsR g N֓4^ kX>YT њSWEqs Lo4ueCX&hY!y{q$`qaOlT5ݑ &n SX Y6:>(cqN*@z>61e y !y&Moi})b#&OP{iV,y--:B;[fmݏ=P_Z`08g\,6Nrh{=n:P' b͖2> L@)Dvi J&cю,+7q,æ 64}GF8 9cQ$j*4\xŠUG%0+vo"k6q$C==';"i &:BdP*^%m{Lp:.)="u9#v{QA/~鞜+뙪YU:Q-Oߡbоl[]'Pa7>O(#As%I-A$bs"S2EjH;iAɲ@ Brq:5m ta(ߴQc#k=6`.tYxl@6ǎ\Ncw/ d*[V' \J93cJΥtp 15gڵPM/eqҥ| KLʪjO&ͫ8nቡRʖ1)fm#OV,FϪ&hY8?1(,3 1,1 +]PӅ"%S1_+7! 5=}y|Ob5hڈ>}7ׁؘ::6) wquVR&l9\k©N<4 ŃV߮/I fzN/Fߧ?l.EQų*I%NIg2z#2<Ҿ3sƩdM /CsYtN r^ 4H%@\S؆%;e>%.&=Ur, iLSD8Cڍ8∓O>餎! X߱_aZ=gd@XfInuJPˠUJug}s΅ (y`$֪|&iVIu]wP\VU[5=e+֜9J~5)aQY~6nI~}i6<7m}.J=ǺGgX(oZ2F2%w"--91>dWߍ]KCur*0=|-@:>MovvVrWXŽkatd7N2Ϝb}c |/ 7*) ?S}ǽM'h߾(nTh!X͓_'i)gNh&c+) >;v""{(Z*3P'^?IXaFڗ"WYکLt#Hs 1yH'@\[;9 О[7ȗ5Lıa(bjKV@c @t['K=mSZNO$H6& 2eQ(n2nn+&tQۘO6GF:1ZTC/H W頞/(&-(I 8\(*E2WpM˔=X|fd_~'vU@R >#iCX++FG©7|@=LyfM@qx 혩tU+\Us/w0Ԋ| } "|"E gz]pWmwe 5TW|$9W[(N 7)ˢ%}2ɜM+op19J53oSW zȲ!o醦07_|%\?mp z|n=_~0xe# i0]`۩VocW7x%/hJڷw֊B$P'?}>ړ8_Tvt:%5 4c8$C9`2 z[@87^#Fq/I kaqx\q tX2M/J >c'KwLU不_UImOU)"Wܥy(Owy))%V6 S^rLFV}:+ըd}_آ+Ad-ɋnv}<H"1ךHf x8?/JJAFK1H%+UhVJ5" 5>,rJ@; KjVcQ+M@c}^+A{Q6Wb ERcrqU>V+i iܟ74PG[ж[2)3aKT_^SErPac[( @CGv{m|4ꪫRK* ; TR d,؈zԁm TZy'6hRЇnfG@ 8a it}7WGMհc(rQ a'MVQ05#>B:+y0@q7,j@km Nk&Glqn8 &9J4b=, nLn-Yg>3h 4aLD6`Y>]}k6^N:t 8یkޒg5dRuGUJkݦ͉Nh9FO':kGբ vԳ]h!~뭷qL:8>f@sVH=Ե@r. |#C}&ۨz`ƺܮEk{B{ò|qǀhc֯OIxo 5' tܽ88Ė_ d MPzkLߑ? >5y1FmD qLT D\_*CGĊnyj;MrE\GɾWlicx:dKnɭҢ w1﮻;"Hoi{PXj# ]PxwkEdR! _F5j/-TKR7ovO?=J8B#H-w|{Z [;?A;!s ků-LܠD/HaύO'K Xi>2؈ln9+ ڶδdA1f'\O13IƑiE0He:o?cbQP)b-m4xD-p99"4;xJMM1ҦNRp|>dƥXoBXXߪsTTN׼]ksr-b.==dxKǁ ˫ę+q؛F&cQ|mb}FC:&@nJ~uam ݐ8% I)$yAQB'Ѝ;be<[1^Bqpz]:6sTW ij=D|1Ӆ B%:epqvFCL3LaZn< }jSG^ PKz̙$ָVŋ?   A@@drqJ¢@&a ڻ o\hҸVM(TiE F{&* ؓ ;[t)h к42yk,t\abfw;y;%O!2'<2UrwHi] @HLۤz@Qyd Ey$>$ =۩R F-QhƗ7k$ǻqOOZZH5Ib ЛL_eL cOb^*J6[|e}&ӂq7Wt2 6)+^$HZD=g?WG+g5 1 sg1fa>Z4MRH$rƿⰖ<}`\͗|2iQq\ji^{2wb,G>j;M;N46E wFЦ-2`!\ݴZ " {Į>S̿ soפx"zߪxT&z_{xBb^Z(g9^&l.g"Sy[YR]SQ0prʤyvLG;@DkR"ɪvkd@D(W=~{W3^c.KdVb42!W\MSv tN0wPݨ9*ǔWd>ts4N w|>3?dmMˬ(g&GXkԢ@ V`q %7~J( 7U<C{󞬱ȭ d6PNTjXy:8sfّ5Uu@4dOO1wUÀIXQqAd()9~<*93v'I0mWdR GU7R4pR|3C(>ڎ;V{A-,b6L<4*\=5ƕX+ahĬ46lq{ESܖC0STKș"tHlM՚@,fNlmv6VyH߲(lofyVY+ם$ݦbZ:_6H~Z\ v8+D&M2; 6gV45e'#<- jz:~!WҶRzFj#36ަ.3diHk׈̛@WIE=2jc jO k~d @tR=݆ۣuAzN3j+)\5ˠSW8i"IUPaJI鯂62="47 ;㼃"M-k2In D5;,+l2'V~v0+b<,޴& k#{?@k[IzbSAE i~:)S@M:O)Sy-jIh$eT+kkͺNňa1 i7V :T >s!t"oW]M+Ƈi|'6pQZO#Uy'T1TZOԒԩ)](gRBwǜ4.үzZ#I+_at\ϵ&q*Vyi 'uPRӱ0n1ŦǗW,V6uyuxr^Q(k@tJjuҸ%p ch>eNC1ȵijkCr!@,OSS>0o/ܯH+7X@?&_ܲJs!PSeyGIMj:g}JZxIy5ee&/@4ؠslҰVK%-B=KWqu:oR̶v-UÙ͔.}k ֊!dOi6/Y' =o$KbExQ{cask ”Rdi xuyvskv(9IMG-u3/Zq|(]kSho];IzH ǟ  C%A2̵ +ЊNS/u2)SW\qUW]߶d0[kbWτSՂQުf*Кͽ ɬtcmrv&17evd#<&N#IM&l`}:u/Lpǯv6a5l)6%\3y0}^DoF4m`uyM}5ll ֯ZŪBAYKlݠQ90dv?裧CcC\Al4(p))5onI?ss5MC2E!jwO`8<zzQasvֶWHK{ e="R\`6f w&.4Gst\2k?OER)bؽKxyߟ ٜ=vIu(J`Qz'cqBx;zEJMj6:͗\rIw^yP-i 55 Z' $*]oo_%RR]HhK8%MEfv[zLp'?YϚ]d(˝2U"t"̰A2L%25L{7S_G9OT•'~b[鵵T~}̲рbQ@Y;2E)EF[M "oYR25JWm.2̄)6,iNNZmw`I Ԡ @b@G2ILՇ8NI҈s9{.>Y===;31S-MK_!̏Qiô Q|H49-ӓKS7ƕ $nN"Hc~"EL.fr2w 0ۊ (>N~ؘ/Z~dj~e;:Î?vOϏC"]wݕo"C"6 _*$;9LZ`jiNFy/'՝OzSMJ -VihİUC#䰺eTTtWAFqq..0cK$1R֎Lvȸm`\ɴ>t Mlgy2' ;p`G T=R=$Ӧzߟ~Uo ߯ʀۣh>-9mc4V*)jRju4^ԠN5ڈ[ FDwc" %<#63'E+:5aHE,O8v> #bTϖ4y (ЪNրD&I5<՚>3(6VPUKX0N8 )~mO6j}w=v@=L[a8If+_:+Q9U4yT. .D;>[5uHeFnk [*(P8KP#m8驛J]oy|aI;v]*رwl.Ӱ{c?W˶t@ j\w9l~GP?]'[%ǦӈUB`sz[, kI4=v zꩧ?S?>n@2'ThSr!S)30&$xazg,[wD{.ЄjB79J j%0`e\\퇰fI,NE2*FYd?ʨ(_E(Rt2B$ O8HqO^n^zio@;l?ԋMYLAhVhq&CTpH墕)'I߯Vfǚ1Sbg$s#`Ӓz:<e29=3hCAnj>XdBgM8&EF-h@\]3s;Hp;ӻvFLfTV양ȍ ԹL܋rx'{Hjr@CwvOs^3`s)=TwB+ }b).]qSH9K,A{r,qjܙ΋4O/qz JCTXվ[؞9.]KN44XmݽbJ*t;|Il>bJW@;(RMj;bY_"~g_ub?3H+=~3S4d3Aҹ{PGѩOLq-?*{pѬQ%[v߿^+O ndE~ORRF RfXq=k zl ׽IofwzՈ$B7:}7[mzGL'x'5i(+ Iؑ GjkC0Rfp*N-g'mQPQk7WVT >?BZNLz'ӕQ0Z6T g2ZUHOg'qd*)E‰X 7귕nUa[_f Ǖ iʡ7 ԻS.5QdK+ClW?oTšBkMu7vt Ne#%u{Nmw9Ke&тS fи$XGJATUK}Fbv*r0ߜ8`9ͦ74ǘ*@Եs*bq`*;-u=unsx̩@LCm*29l]NG=4 JpTzE*+pfH :6p7Phz٩:_T L,ed'6D33ԶrT-܊+ b]{irI]6@ Aǭ] C8UT>V˞$od ٪>|E.v?wrqvhFť+7"420m$aD}o _?<餓;N!JNG5UpL+ABd$L}fO@QbXM (K%H=uQpIeq~U ۣ'|a>g}9.+_\v Д.+Ke|^o5ӞSHCpv)O+2[8ė/#S"s|kNkw9AR˽z0/$'Bx8nJO<Շ!Jr8(Tpѱ:9[!3%uj^(y67O )TA2ji6@gֹ ̰rC׆mj u0&MXJ5xq{z L9):Kpv燀 ZA5I0O%f[4ڑds|mA[HNBT]o *؜:;W1t8iO2Eg9j#cY|Ӝ8q.PB}Ee; މdS8mg<ӎ}2@UMY)YfM'3AZ M6Tp?iKq{()@=r2{d-efncM\x_ C'$0ekz[Tuӽ4"/kwLOQ+TI_!=3+IlEHePϩM^:V7ea4Bڽu6=V5s<ؔ%L:ӺđBPHPg&y8K=ڮѤu\pFn<@]Ma(DNmGQFTc@EMW>eSf H:IC0nk򖷬iǸAyfq'pItr\{6iCFS9 E<`3jg/)t۝tk}) 5' _ޡ)Z>,їYZǸͥqhtL\dd%j< .&93u^4/z 4{VsC] 2l <( H 'Cڼ@ (="DN5X!iOB7u>MȰ@P0V0o xDfkUໄh!~zK_5XŃvۭCv'/uqwĔC W׽.Έ>i5z 6Ez:bd)W+r?h1JF) HzHg{G9}+G%nR.nj.&Ջ$]qz +:ŊqItLhg~qNY{z:I7 S:(:fAN2Tpg<\J#z eѨa(w!>d)ΡʤܷİGizNiDv Q%y3RP1=iH|{wQG}"o۵k-9UlT1!FtO *!3iWN>䣏>ZW[Ǭi =M`$eaa"]wX̘ KГi;+ϡdݡ|,W (P+B6 $FR9fF7o!eX@`/ݡNJWܶ-s| *)!{ [F͕x - 7_1R?ꪖAPY1]Y>{iieŔ*4JK/ ;*Uam;&z!}JJ`IZUmd\0G%4 CB &C 8'kGו (1a)o#Z/n0c3}`iz e9M1"H/n-6m89MhqҠqAA%^!\vo'1llĂv _~y?:ˊB< LF4/"Iud J!9A56zm%ubJ^ 'T }˃FQ3Ewm:*~8*#r-ͩ2܆AHW"+d=[ה5:ndz)dTLGnw20C du!<4ң2\ X!=k#O 6ێiz(?7ȧ.K~ q24q*r-7xڸcb&r:AX (wŴ*4XZ SaO֤ɻekjDHؽuhX߅uΞgN\} ߻%%HqrvM\v ^Oi@!|AaZ+f28nXNjN'A7=Z|jb2:6SX7]^ZA1ݳ}a¦0 (ᫀfUFi+8=۔UӜNT`V|t@H;I\R߆j\ܒ Q9zb1q.jk < z0=⬳Β ). T) Yl+y^:E*,7CZYr`#NC~cN,pGPmHuxH8>m*_K0eª^sa\N)n_*ĠЮa=[)f*j&`2%ƟUlq;:\GvW|x> S4, IlBګ{ZhᶘA)->XO?ysqcy œؽbvE}Sgm*[±F+NE)Ќ67Μ&ǃz.Z )0d!XAP;tLs4 冲暫:o~JriDˬ[2Ri{.Tb_ݪo> xMi Uإ۲5[ib('dqLi&Ē g[gө-O4t~.N¡pC3La<0e8>`zUw '|HP#ъD\S@{SxqԶL=0^ZI)(a6>Nkc8M2tIOށQ&ZSeMcp ݄8ae\sAm&&K)e㰂}`[Jr6@V d>xh@(%}MbSQ€Rf,ԦjV rAeOIAQ/My`5)K9[5 %`$` kڇE]="g cBqX\,P@ ǐMy|?[CVu] DJ|Wvlִ~S{ѐ6 knvF1DB{DIhOv=`NTұ9U:m+уcR|KI i] L֨bC88XT0H8bWU\ƬNN>qꩧNؠ՜ijJE0'6Jd7F#}M\bVMtatCeeF2DEb*U.ɴ_+vЪ(*@ oD[:{.11q@}ܥɫf \ySeN(ѝNN%VrU )O*.&h/١:v[B,p?E5Z?ߢLd&ɒ81I8}zDL8)xv&LGAG*SG}HO;+yU >fM3 Hs;ԫNzuݙZ2I`QӘ tTRSrʒA; 1} srQ adt/b VK r|8YKa^i+lSlkFi*kDm|sqN6H3.S_Rmi{ZZ?5 a|Qok#TPy8i2Ԇ"&xxO@d;iPe|;U|c'`RUaK3wNP'kA+j+׳A݁Tdk ט,GMH5) 3z'6ܶV}gyi}[Lf49HYϔsY>-Tva ~E*suh"QhE.7AvwSЎ,UkQ̪y4nHpajr)7סn?vKӫuIkn _,$)r:gxCV@NLHĩ1=lUַm?D>XQeݙZlcqY"l9c5OH2}b bX(iK4y4S~0ǧVviki~~ens(c'40SʩF$a)hEޕ%GsYS]4H:笝eZ بjC+Cbi{4c5SQ?裏;x"2.:J֐dO$IIcD.. lS0W;!K;L O߯h f5$*c]Ql{-[Ҕ^׀Hcd7u c5UqyO(I$ ʥ9fvshN\.g!xĭm\Cl1p?քAHM&:fkЅ(&%aVKLe{T'*\A[UIe0A%g+կؙ}9PL'zm)R_X e*fchÈ)`U5?R|qw`U6s>A|pEOҬ~Cz+vjn&ΖsPXx-G붡ҩ՘&K(^rPㄻ8L2iA!\SjSV&\^xhԊD {)W::8w-țbUm 7N; q s&g3Q8QBHDHݜOytIO8 O$B55?E }55R;&kiI;:* :3vܟDtwVh]% o:e4=Ʋ:9u[&q>Y:;J+ 1q]AvZ3tVL(`ud1E%eL452Rir79H("RW?QZvFS@Z&!5Uf̠Flwqrc\o~;p+ޫzs0hyt)ʺksQj2akx]ݠ ߝ+?t5t4Oj}㓝!% Ft@袋ono#Sr JnU5{vf}VLA#kYI ~p_[ Ia`>x$x,I̒t_Έ;([pJjOU;_M75S&>kf!L&zҨdc:5F."ͪk"KTY1!=gf[4p̣xg"*c7rlS ?jS+_pqpr($)ZoL;,;ihE6FЦ5ܘіpj`uƱ:^87ڗ=eO;*2E`_k"3Fkq?`^b ."Z$JNDr^5Z{ÁM)k4P /ֈMt?^km hL-&.l|ZӽOZ(9Xouvɝ.}ѪtW|?D,+t7 ^^8R 5A^hbg;^vt 7xUh@e8(@^ŃӐg6XOSsXgp b0Ot,;@NSpVF)35#s&8 a''n +Cm9oTmN6dWӗ]${v?m}w(s2N,Ӥl߅ox S$?I!hۋPzKhoؙ"aefɵ3vSmf7tBZ :_ lT% zbJNUaiV j6Hf& P3cHsFTGh Gaz, p) AyPgEK)CGxO2&j$'Ql9%H\<ݽJ)gUr KL*{h~Ӝ+K.15ZU/ W *6֬ig터eU5aYXT`yT$eiǻ2;8 A,$',Ɲ*Tj|rt)98㮸_ݭv.:l!1/0R=  qfk g$sLƧkM!k! $ަ[TeSuAbZ7iY1cC0ݠxK & 16%5g㶆OSqxOZn yăe6Zr1#Ȑ7bJ#Ǫ?E IZlCcG19jEM7}*)ٌ}RHYu Dw SpԝҦ1G@mwM8nzCʚ < Y @ |a} #)^ (u3i\D @&1ȴB SuꅴWܠ[DN d.蝚\ 3( Th>uSINC=t}ko?<~E+$VVf 8L!oAe *<0Kjd5;..ު q5کƑ,^%}j*b_W${>x 4os<#w""48^i56G#.A%2;D3bC򐬈?>q[T]JSi^ 6ԏSjڋiAJL~Р~J1Avx{&qq-AgKњZ/M6ƽ4tmk:n-D/cMZ7}7r>+IZ騷K8rsF7j'6)+1(fn4>}>S>~p&k_b?JفCpxpkiRƙqw>@TH-niZʜe,dhzB cpr:&4Q5YoΨڦ~7x.:kդz6{K6b ׽u-^ =p+cvf=ԏޝXϓ>nxɦA1i^B}W!h{:餓*v)W!`#^\M9ID}/۾Ok|T^/`j)b5UthFv[v"P1% ecأDt]|mC-0_r.첷mR۶׶*s0Dä g8Z2دʩ`{2ЪJ85^S,B՗B ΖDiJ}b=4OMvCm!'60OLIڵlǧJL߶D%f7h\ ̢VʢDN%FٙiɲMJ^k3<~5VZ/ALeF݁OJa@\k"znx{{w\{iWn5\s7z)?0ek<ϩ~ c=KxcA~ٱ7 v:X M7 |& MnҽTҬV "5Ȃ]+s:'Ե={&ҬyX IQ*9VNOԊ*E*ʑU$􊞓\5Y!j(Nk}Cqymg+->΄BWNziǺr[ŏ?/\}Py*r(UTAȵ# Hs0~S-Y!r[8 =ZqVœ{15y1(-@T#O%"æ cfQ kaE*64 O:\5 }3xѦ&+馛(K/4e:g'^#m:Q0hAQ.зerEi}N7np׷9Av1fy;Jaccpcn=Z=j+UVJVZ)'=zң֕Xc'$ya00pbX9wOI}{}kuksXFʗ 42#?,~^~HVc:uv,SqC`؃MwSc9 DҊòi@4: JprN#w2 O Au5:hxlmFz7?˺4Eibz ΟdJ(@\&-ʭc+4!Op˒~ o/Ma G[tNQZK"z*jOИ9j KnZ ?vH&iN$%T'5}HC&k'@zؐڻdTQ+(SD=d}}Z is_I]CP%t?5t`7t?Xu+R|,3PINսN,5EYmNodZe*xmMB\iNz;4) zgj?gy#%p8uߑ_Qd3kl\3f` 0r>+/6Yhdxk5GYY)V1|]W` ' E"c @fЗ_8ѩ =d<={y'1)萍- yk0hsfi9'Ϣ'ӷjvNCdG챵:Ɲwo}pq-SQLO>d?Y v`%K)]RG\F:\`jѫ`>MuE󩧞N}N?U3 _m`i<7{sN/0;Z^{}&gф5$KYn;q2z}9HJR_?n>%'2S; 7!uHP4\ӠI!1Mm5PHȟP8Ya8$ !Ř'ݹ9tYVY6]z4n`LOgGtIijG[4?^J~NKwڦmJQu~bZTKg0tQǓ v_BJu N~qIm=+qLAj05BI"ƹbcS  Z!ј8Eq\6J3h/rTܽ3 xi]ȋfdjNFU(Zڙ+ީTD5]:AUj3r]`GHѺ;<(vU"ϙdJ@'$fi#q!7\9F46/qg0t\k@pu`^~eS?b +7Zsl]ӱSXmr^톚@gn>;Lj$jFKKFh *a)BCٗE(WY4{R 5V|?k;Ӂ #-_ϑA(ml͙[3yNh{ SJ#b)@?auYƝ3r͗=lJ/d%5,Ӿ$MV(/nIDAT+2rQ5gW7. PF]ܾ\i\%=InȼyJJ>1:K[Tݧu6qW{`s89,-@ 2"A"^r=GpRCƎ^T<Bl' 3fwo[W0:& 挢]KcU(cĒ7~T%+W <g~tm9)3j۝R&&{u#7|5*JCwT Kgu#aُmgӵd@_[G>VCfbzZlv_q3闖l ц'2DFQӢYPm ܓblm|Їt6EV#i!%dc0g#U{zIc{G Ր|b!'< )!WDM7 f_aL5|4^s`{X:;‡,n#C5z*$&qF3*\$~}衇Pq}"ol; J6b!T%xD(; WJ++I7o~wgV"Eix{o !dkr\w` (vic͙sʋ `^Ph_}[NWO~{ieqT*'^6ѧ$Q@ZG #u;h7&.30 udםi;׿|+_׶MKMzTq>8c[SgFbl-~jY&dozn"x-l0A*ڱ*6ۃ2I qA_./u1T.`P&^aF;هM_L}; .PȍilxG2?*K9#7h4 HY@ݕ *ia"Bc_ijAOJM洷%Do\_`灢{Ͳ6ܤ65kx Y&Q Ơ'I[(@2Y 8l+k}Tj-s3o&?>WJ{"4(6}{jP!J 5nrn HF\GsABh=G$^E1uv3Al PFR)'2oZ]iֵJҡ*ʸ rt0c*PĪ˓HMzAfGvԢ_ у5nwv&+nKt`D-",e;$ e{ƝB}jV=KT# (SZfe׊Yע4)Znn׼/}7ߜ_sO}k_wsϥbV'k;7Z tTm[,no_җJ#;BX)¹FB!OIMiSݧ~@סER^pZˑ l"5Y!Z+?1ZcyXHx|-k*LögGfR+}}Lސz655;ӽ򖷴rX {&ۊTY:.S˙~7n2fO\_MezB'd`T~h*l@¤Oܬnѓ3[.?/4qo*P+_mf{[oMCLٚ}wۉK/5@eAidbk ^Gmٹd.~$ME.*?..U 5mP 7~eb PiZ|+ǡ̓-i:7ơuaޤlI1]N/{GгmZs i^://ȆJKEG~Beۦ.hR+Y~x7MR&/UzU*ܦݤmdڍ$w~dDT/!qMP&^'-׿?QRR h&)yLI0yA:.5EKTtfG`_* w&Ybfi2 )9ۭSԯZΗ| ع09S^La}2AM_k4}mpb}ytljlIS2`o"RHX:2}s7AȻ)F!:,`HZmgmߊ[^,ITvƐ6hqvÎV v0\޵ܓV#8&bS}}v@#7+!}٭:>IJ"}*`FzLU uk2b-mŹ+W: M I6Nmtx}j=ez~N@d"]HP^{ֱGݒe7yM`OIB'lGm>ق4-'16ؖfӐ5> j"Uuk!:($y'5-Z/m{UnMZ771h)aB?okoqաx,kQ05.j9=.|WwkDeP:,7R!A&0ݓY J݊iؔ~J{f:"F+>LFj]TV+D%CkK c-\iYj $O[z iDsی9"C! u@"J f&z׎Zt%a2L*Bsa^qӍ.7&^Ɂ=A׸{,?h>>`}˖4nh;֕)Qߏ9;<(G"F} ghjLFTͫPoGDX^^ SyepOިցX~FLSi Hd])?=\@Y,.#=z;L$Ef;njxmk$rXRdMT.X(O޽l,G#z2㏘/pX@PK@4V|vUO+P[{EmB8~e)lVKO\l)Z_L#&+*zUySHNZxIXW/NžRz+͇Sֳ;<,Ɗ'WcpVjV@g#eb_׆NR}XYv}䩥7@Ffp#6|ѓ~̲#%,@1VusmQ#˻!& -,=H!oIև4FQ9upLqq yłZwGOr}am.pяINC3'z|\,\ˠ! ND?vg3Fo0<+yo=I5*QhiN$J5e}5vYݱ|e0;6IrX&ʊ{8밚!γjd/m+@pjh@> -跳 R쮭0ZOfC_5~,Hz@,21c0fU M,9'9O؝ U~kms}bcr[3Tr=-sQvؙq4ʯpnΡ?I@9脐p\i<'@( H 1T@@6eA/ R/1uZ3Y<bLgR2'|'xߖu!-L( &gvM2(eMUQaXJi}LIrWA#vV ɤHp׉bſ'> Z@ :)x;_% Lˢ-W['9 ;s=7+Gu7}nDn)瘢@5njA(}3ZzsϔbG F2uUN205u):}< p6bz=Pl_L|𩧞zg~Gy䇋4IU,b?VI;ꆸ Z$аW&jLxRB[>FaQ<K"li@ &- HJh8 kͪXl}?k< w[ZcVD3~OI┶> YvL5J(?lʚsC4S@F,uFS'WZ׿z­4v8i$Lt ekJÖzүڻ~hnFeK&h%oYAqd'z~0Xލ@Iia$ ktǡ֡w)P*!gBp̮v8/̥\#4̶6x fzl$!ʔiT(`UH!k⬜jջUzo{#=oרPoxgpmmRVK,B15p-C?YGhkģw{&wyo=ȠDa6u<}߱31'eHDBLkqmN7*U)\*}^Qਐ%;EGa']琭gͮ_v\"kh_>˹K"[FïSZNlM4_ wFns|Ơg9Ä7 4'gC|I~n\GykCN??u[檩k-]Z/#]I|fX3vcyjEw?8 x/kw8_-[٩gxG֕g?X9PpRJ>tCGv}0]J6w u!ܟS'$-lV31/ٰegtN'M3K-K궍J65$ Nj/.q9Ys`~+<7l]dcpDArAS*O7 t-nX e#bKPFcB# ?fB5ү:'M8\`;q:;\`.8-\.Udʠ 'ffg &L=IvHƓ=r2Fx'8o2jmg$&8/PSndg_줛o&o eD]]{nS:BH7jR3F.=E@\k뵗[B,)Ev .$@6LjۃRekG?Nejwzh!+ΥLLg8I%} g򊷜!0+lO(A/r)0gS\Җޭ1[gA]!V9Ϳcp Kx C3?j h홪F%yAGӒ6=JsζĶ X /L AꗒOXr+KJduq(iO -d4m1]Pwt^rJD'x_W͈e" eW'7(V_@0Ԇo"rʼn"B! b?\s@ص)Zx)"xI př޴IF: 0ú]p81^JwqcqL@*mqщwt heDŽ Jk;a`#g{YG3В5qo~os`'[߆*w9x2Istuk<,Vܐ|gYwG4(O'x]pAՑZtm>j7=Ia>yrg{f "F8_]Dۄ+La44sT}I$v?|Uϴ5&I< Ϗ.y;~Df^Y 1>My>9:,`1v"#8$+mӵ`ˣEpIՁ.ɮF&SK,`'RB/Z0(}dh2J%%dfx22's a&ELdgŦ)Q٠`=; DX,d͹6dT畆NTWv."ps=<z̴+mVuJ8STo 9+RƿٻƾC\&9mZ'j 2B@ٔ2hf!:qg%2{f~:( z'w(;Vtv; B¸dڜݮY;{Ae!LfIuhy:uCa796 ZcAk4,zv JH?ԪmM0sH@DCTO~'FO)]_ӊlW}k_Wbk6 c.ă "nvJ&ad^i,̎Q#Lq9r{l[-17I]j2xc/׽}&@~E"ȳy~UjyrX:IsļE*Аp`lS%s RTVc;jgC_ZvTWc|^S#ɴrMbLUkWLנI3$ٙW2ΠXF>SOaE=XIIY3Aj"h[ gzV%/6M菴dT0|_&amW땯|eE 6ߜw^_}{/WBDqDq]EFIZiEEb,y99%!WrI7 L]O37~aUP$ҨA_IxCq]ɺԯ'&}i`8OeUҜ'[ٶ$/:HC|55F۰y:$Fh:rkL MlyBbJ |I^_ pNo_alP9 ^Ag`FĀ7jr-ܒ3uI\zn_*5 86F.QAS(uUu->.TesjVezEvgvW:iΖ#α9۲*)* 9b'D.R!g8G+ip[# P 0"# L,K8)5C'uлiT$Y$V3 }k?v/)7& ӯ9#S$Pb' 0!@5aEMM d圤'B_Éx;NpRK|Z䦧 Gt,կ~uLmcQ-t;1y 2 A`}q")y>7L/\VLr . m;ߟ ?)bc e}։ivEL;yȭ-6``[;9$j|ɦ>}yr#ces6mvzy-67M64;;C&@ɢN$t~kPӊi^(7aӕֆF+G1JS70`i$ q 9o|c$l0)?nOӇfjG4mP9zIQ8n+Bhq/qfc׎8[FAUm*+HuD?s/L ςޒY M 1ߩ2Z":koaY"jw5߿Z{Vï8Q)^vDZq0P/׊]AzI<;歷ޚpy着c#xKࠗҁ6d'1?Vh?ό@x LFGzl_ע hWjQt +XeB:t7﻽mz=7^$Ig\2Ers`Wz(+{L nf8cqC!f*d\ƫ4co]\&ʂG2JY:k_{7)j<>t@o.TMeW! Tid I ks>M6 HJ?]&eT_+lf/;Xi~Y=,cnɺ$`lAK+jnH?!S/!͐K7l bFM0YuYn P*)2hFW"9 2q+P[;qrT~'~╯|K_~rG΃scJ{.Rl^`L!@;N|w}%|y Lt}rMQ/nnyfqrkͼ ,17#ߺ, t8՟kְ`9P9MEeƣ _WtM/~_Wo=7Hz1$1쫦= H&9 Υe98)%'46"924XSγZ$Y.~yV\~]Xe3hY5HCmިcF.k/&O=ԗ{,+ӻtϦ(Mz[΄rKo*A [8Z VZg#XaZ*A c&%u+H{70@(`a-0UAᇱ@H2<=Wfmh)h-1լHD(ؐhh! V;@NW֥a<@1vf0 [&Σ>|ݡy=C"!TA%!7BR;Y*"4dx#o-:gt-$Y&6:H y(6cB|.iZ3% {o 2Tz7cgں(pxМ%͉v m~$6OA4=s}*vެ>"Ćw_{7Kᶽf}v ^"q 0nB߁  *^s`6sSgD,6$cQ_-y|@Nu} -E,B͖ SoUJk|Xf763K_Z:vӔȟOmy>-X7;|?JZ2 ߦ;VZx{ӳSI_궂\e2-a8/&)@%ZSrN(5eƻ;@Ѡq @2#B|' FKN3M k)$^¹Ե!VXAȻ-OT48@"4B~;} 9e,w"D7Mlj\5~g>|*띘O~2!Cm,68x4 _OAQU A9m\aa^Su;ޫnuz޴QcWnҚUF"M܁ޥ7&Y6=mi@ӔݮǼDӲfhytj?_9t}uAIz᤿ol?g{^:*#%V|z_l[&B58UAB6L&әR&?N)s XD *` ힰ fH 9}RӋ[# Q]dA2XQ'͡2{z[י*ss>N`9A*s@:}yh:^ `fo!N/2*NS70?Ư%Dѣ,k{ᾘ m7(~t_!Y+YG3&*Bv̇jz;`v6{~NcR [ڻKt4lhU !ڭrd[7I>ӫ@`RuGۋF;%zÑsf(`NB?|VI7T +fУ F6`5^ j\_= j(MvmH(ԙjm:))g[yF "{F0; %ɀmoIT֗I^)h4p@ocy*9X$^-ǯ+g"B/ >h}_.}}go}~gDk:JdGZ`@j80hk镍.fۋS9ߔdU<±Y!ǧD`"W3=r43h!@g #îE@>:1}lw[E+n&XC͊1]_/{r3ؼDhy)K0& S'?vedRQnIA:mƚO&w׳Άf  ^h:qg IS_swTNTl딹h%H3q6- Soе┟dckaj8OȮbEJ/9jUYryָ2/%ё@g,A\ƽ<`!ؠe"ꌦ:5JI7ڴ5doA$@ _CUdgS nE/zQ 򗿼ݠ,^5gqUCwLN/{D*=bfzB}J}9[Q{ga'#-&-a%yH5vtlChR+y=)G?^Z|gS੧jh xC5lEIj&+ ϙ+b7\žQ cs]'YZ,i4gXN(чPBy$s$-tIPdַUzk^iUnkK>Bղ@.'+l$II$\!(}O@Gx|"L䳃nCO6tgF :A)*f 1ZAhTnF 2/⠹ ڬ7js [`n.]{;CxoQ^VuA+.Dޘgc18Iڈ. ,OW\m\: A8o9!h{^;)_7 9y> 3z63]>fFҢ<ဪPs$ev>7k }ũfe>P6ZEʄm2Bi +W,>vRL/zԮ XJ)?F_.cۑ/mn찞C$+aO~mٿdwp)X@~IZw3GX2슳/u87O#oL #}lݓ,U_brf"גLH(ܙĪĔ!(΍ \B{YrrWq71 ~n_kG]U8b!fbI}ɜo2D8Vplh6n  lz6pL&cUTrDkQ*L,߻tP:\bXykf|RMWXc2]}㬕aGgiGm,4 uU[y{CHI$?^_pkֹ͐h?>a}3Yuԋ1Xq\ 8i߯ei/bG,{$"|NS65?Y#k/K7ž mr7|mQ#y\δj-tz"}d?ɟ?soԨqpK_L&뮻rl{;u'0ysV\ܓKk61X2Y/S8N2M{Y^S:b~~O0>T-,ğ$g@z+qrS[9ȞV6-B\' .\!G/'%'!p|xCgߚ5:8ϺIE Z1Jc Ғ5 B,K)T" ,O 6\jv|]@U.IhBE;M$ iހ)f}F9}B~٣rvΌժ+`iNSjJ%XK bbbkfgD$gIVy<;``$"ΨW)ƭ;]l*#mOr B'a\_*0l'VYz7bVcpM]O8uXܺb~(GH=ns(|c[WZ'9bz9FriM DW3/7l)ŅOy q?5EV_R0'bRT~-XCwӤUun~rS/}zָ^-GeFȞ1j^o.Z @񗺜ſRc~=#@חT.i'aࢇ@NP /m\A`X SBɟX 630[+hB3 BdhZV-ýg jAV+%onz kH+~:D M~w@lg&"zpE$8; _!S¶Q|G'3e/|6{7'"C{:B"+K8G5k\sN6iD]P_zPO4JU9gDl)BlQӁQe5FkV33I?6o<_LGpZUmPvÀKRb{:ndE'R~HGt2^坫4L<|ҞS[VuEK5%(vcOoz*/kC} _?p)C׺|3>`5K@EP"X,&(:.亚;=T(YZ DuVRkӔd~~75^e!}s]_50X 5Z)Wprq3|FT>4!M^j5K7/HB)hV:7ʷWgKD&\V!ؙ{GQ+Znw3|6Aեh"dPW1`pg<īe=~~ nݧß048l}n{t2+-I=!~g?'o}GTSGlrIŶe;Cκ@C GƘ &R@?%|ꩧ/).} K_d1qQ1 dwW8)}rD cxcz"p<9wض6U\j©)(H<ԅkho_cS\cDnRlITsv\ESɋ-D- (Qh6-lK_'"nhTWE)z!•J,n-oy v,bl^|;'}MέSh2M¹n: Q✍ܜ'`kd١;<_Wҁt)>z(c k\=k=ոsv:=p!ًbaYn°8ZܟzAb$4|cX|,R"nC()v%4g[p\3g+쿹2A}_ =HGL aX^#ou{ݨ{2<%ȮQv[Ɛ鎞+Ae MYX<lh]N ާ~ _WW D[]{nJduyU!8Da`"6 2]VH Lc]#{F(lw}G5 :Ds5+Y=?,2];#:wHj}Ԟyp7Z_%")и;x뭷 \ߟy·׿Ot HSԷgBd#%ʥ nMTfΗ#ӼG DdžY!4m)-mwv$#2 c d!t^\z[BF,djX7bE-в¼M+0 ,|JqɧP`B[p`tҨœkxiݩv_gm&Bg~q%;e\*>br__ll"mw`sdҟT.Rx_W"m "ե"<j*,xa(9Kc"!ꇥ[5!9D;tiV6,E~QƱ1},ImL' @/2ꌀZzv g{Tl`y ][N֫^D{GII׍Mn;D]؉OuܕC조H'$.([/3 lav/'N(58K uP:,LNwN7/ /E/wʔff>0Eϲ4,򰮉Kpf2qqG,="CK+c@Tw8`u00v@ym(D2 {_t8c%zGK%#yKJU|!?ӂMD^:!OsK5+|_H&W5 mc=1>BkJ{{üơ 2} -3Qt[e ;4S}OOfG/t-Q4݁KpFg!)G8sʳz\vEOsjZ~Dd,Y= i?˾M-,z pwĎlVS!at׭z'~ N~aj g*h$õ`A9?g70"t͕副D:T㙴R. : !C ˻¡5i/hU 魞,GA _%-U vo馛~zK^n5m.@ 6/Bok& Ћ7ǵRA5vdP^ŠR iԧ>gGh<)*hκ_(((X*oؾGb>5У Z `;a#W?d"E.[ǜpv&Y#!=O)@QL/ix*&= }<+nˠ`ҫ u'VI<ԋ@6}oWK_Ҏ9ә lv4$o$ ?&Ij"UzaO Y}YqyNs@=#% 00֯]_@B&Gv*z9 Dund˂WIk7.. ɱay WrV_$I7[R^aϒOʐ /x- %.s [ʦF%48Ud$u*뮻r}iSd] qA oeP;q` XCcI"v2'w_Uaoj?@ZYvbl FF*W,Pu6%j&c44]1/7N3^ \.-)Jv-@E8f5$ {}23-E*u9ZYqI%;9pJ1 6,bVaqzF{T$-/NhЄ ͆W%r+LFQ*tkZ;s5m8_K\f6jq=ƅ%T'PĮ%©rU(KKח$P.^E:Ht A)tMK8H]?V$ zh'jVxn \o#vlçjODN1wW9HQ7XuEwxGw|NOUF#:E P$v9=q)rWkܧgUY5qرS[sA!Aaf,O,%rW` t# gIiC CTlŚ$@z9P1.bT73hl8yN 3zc7籠ggOt'~ mm zhVN8k"%_ D?!#QXXI/// |gPsqI̵tBr&J;Xa?3ЋA3`@S(BfV}!N|-i!uG1(Q;sr ںgn&ʪ`g+T(B$2eR nr$(hӷ~p92+9+xFo% 0r|}e'kr68Gs\qi*,r2wϖFH1]~1j3"(ʩր~ t@ l@1NrrA \J)φA@V{R3Ik=3YĖaфE: \ًy>k0ZI=v DFh%`4JbegiHU`LX kp | nPB<\n]HLPj7Vwu گZHE Ɔr^ SL ~1EȺk&0/3ك7Әάeq=L@dCaj٫ɜ1t|Yq̗%/[-#T %b1my b礞xٞR%7/ _B[A˙ *$Sʣ(^ʚpAйc HZQ!w՚NM_׼5v[$ҐPo u L+0Ёo*PB`F?ݑ <klM_k3-pgZV[sp͕ٙ$dJݛp牱e@A葑gQj} -[r`=+ 0p#~O_W_릛njzPCeڐ&s{}\It=Qs].\5m$%8[gy&o}k_?Z6Vw.ھޠMZ(x'eiL{}tœfIRU;O䁽f6 „'(4~rrB/@>\ q8`j I|>~~K_j5m~bk߫#ۤ?ö ٖ3#K d9 e a>+%)p9BԬ }c 'Zmg5ח$uJF$ o~s_r7g~gwh[\ R 5;;-$l%)x-c8Әp9A߂B"G{ᇓLߟcYzDBVswePrOeu*A鴚;zkJ3 nsV7Kˆ%'8uHKބbJE_lKOI7]J-T+ѳZN:EZ'裉`fLubC%Ixl>gSrc4ǩ%K?}v|z'|2yhᚊJXswE#O[Pٛ\]N Bdc&nJRmX4S*ngpC9_?óRD6$)>sh}&SܱR@^dx,3}+?zyn=Z)%bwh2-tIYi8-xE`KxlzTu]y-kJs|''IFf"":o/P$M,Nj ݧ=EoH~ J&A3?-GsQ+;YFޭQeznt&r bBԮ9 Ek|23 eӊ37>Bh>>ʒ%"]~vPm:A&׳>h|駻O8$ʷz;@/)J#kzlu6r=:}KbzK&6 e/P{wȝH s28qHPt#LSOT"] vkj!B;w?oI'B UV$% %&\~WS,ԜDFfVљW͊7Eɫ 9HZ55b'mO`e/NW\zxn 8bjjڍ<a>OC 7sdǙ!7}MW/}K&^%fA 'v޿MPHAս/kh_| môw dmS,1j$M{?7Jn lBG X?i&gJ:~M:Ҵ4L_MHS(aeiؑl&_ym85ɴdA[wP{B*R"XRg+CnL@J4.yHVNվR愧WϏGt,q;s iRV!GceXLlƏ__tZn؈PR-2H<|l\Z) den$\O2Y󒖢hm@h*sBW.4^Yo3WĽsn<9 j;c~[ݜ˭g;KE)UdJv$q̠9⽦jr~WC氵k* `:Caj2WӺH2j9!Vݧ1qn2֍b!rV zfDXl3i|z00'W"JiNo~=Z.ࢋqI{D}X }߷J ҹ'a=$>jl7e7¾jKڛ'LXdtsB3>"9h^fef}*+Հ_򒗼E/+t~5{|ዦo[_ V.=;yM+V*ȴu Un~'2|3v2֖AF=`cL]ֿ~k 3v^Ǣv`VgdksO7sv51jm^'fs24GAgAo3x]. ETt ڒj_Z%Ku^œ~s8* /KYӖktaCM>OҎnTɅDɤ_I\:r䳒~t~Ǘ+ &c=ٛGgjV{hS ,XvUE@j}-/5?@f)_,8( R٦ eLV英g4=p 4[bT %HKV-_똿ⶲMpnIv*t֧$0$N9BgG k޴"<Ea؃9? 50=g߃Q+-DjڋZѾȓ\AU'+I)Cڒk6l5TmU+$6|^_GȠOLwc;$xR\08U׽ *TQ{ 쭊hBv:iU]PԊ6ռ&}0\]Z]TH& ;)ou5vi˸})'<θ^ԻG?Qن0f,ǺWYq_3g{QK@2ucbO>3π>>vL5>IGk֐6QVx4E iEwKY7[dD 86Wv(`\zfK_R4GGeCMZģ4x~[V89FS'5֨O숤ڵNv䡇z N5֡1tȠ4ԘPé$A-\eHmR_|咮FxioVL~3{tdCn}W S˫4#O?}D,f@BFcw OX󙄩=K&2y>NNlɭF”Q(諓fE`V@͊~u>>Vc~֪74.y}ߛ$َOd& 4ӜuEr64 7: :ZGۄ`5|XcBmLCdیlRP=/rBw*\GH x]Jb q P~0c\g\ELID5^O=TBپ$YW^y1$mNı}YwF]]&B67@߬h5p7@儥O"ENϟy ΁Ć$jI~lGSP[Tb,lpqi{6"v\;ۗU5 1l6;ds ?яf?2}i+W˚\0FEl "BHwۘv d@D0N޳6VDlDI{k?jr7qf}nmAI_~ٛ[ꞓ+ j/{s+WzA`3M vv"Yz]yN,z;5 p()WL~Iڬ2 yji'@NʛKǬD[+߯_ Uؔ_*P-PL"-flLۓ)VWc;4 >4S*AӄpN7&]{j*X3?(B:gCT[I;2X- ~<O15a> FXi: 8`4[:{ׯ~_z$Ijqڋ1wWN/(lM;p O6,P'Hǘd߾oah솓g v߫ISkTyJڸ7聢ʇ֭ħ)TSII]';C4E|%o1AZ^?){o~ֳUMzUuRG@>Am0HOD2޼wN-PF97 B۳źbSʖk"*! A?!$oZOy g9'ma&5ټv{u -KKvE ')ȗQJAm,l;~QJ<+![ۚ$7 `$v]i5:ypK Sؼa[.h xZΖ1۟)LIBQ7EXpXP@u Ssi}F_crllz9ֈ[20z D&DžRp"?~10IDATQ]HNle%=MGq&ǛxF.wjTrGC[eo a?125@Dԍ 2c5Sv(;ЃS=Y=+^\ھ1,fkĨiIJ4S)m0D'i%2')٢]UCmo쐀=yyPNa)bH?Ed#IfGMWKˆΦ)_{sFg 6[KGs=}tΝ,]d׵j=w;KףwF0c@ b4HȉBuFV Iwa.-Xn$hdnr3k[qvP{C(!:::ZH*Ope.cMo] ۰knv K53}Gæ,rr?Ǖ_.e<*!,}nb x 9"6f eݧF ٛ@]Ξ0dNnRP4C;ׁHm8^XsK&ℤa ChS[\OadHH?pR L@1pJ`ZhGE#6v57){3yk:9ad8 GzTNWXvz:tB~t@paώܣz39mp2/ﰃB;6eH acֶd U8!MvdP/2&L;v֌D|]xLOKκʯk?9:<6\2H\T@}0 µ:Pɼ:Kp8egv2/CQV:b=':<^=iҥ՛ᇑX_RKYNG}SeCz4Hv$^U^{NA囦g, p[Ȯ:\|:ivETW \cEa+bI.YDKׯ~юx57{ώ]3255K8^+۫xDM-9w{F"i XPU f%L殿hɎf'Hg];Tҍ'R\<7&lTգkWABM4 D믰7&NC JQ9 It~FרsQ~Vhaa/;e-r.wߘzcsqcsHGc vGY@d8a[$! 4z`CN]&Y%0X;OvlY7c0byEӁ"q)(Z ʅGwQ18dK &%ècդʩgʉCfndOS-x&sk\|5Psz/="y6jЀ r:!pD܋v]q@O5xv:K  cH0t^1t=&BEWcޯV ID _/![ǐiձ)윈+PEGd0>:)\+6?^5 }]*諄Ż'~Uһ,|t&W*$Ӯ="jQWtб^#H#$ $-k)5LL>t /)[٤k +)h'|G|zD$M0۽{޽t 4df"&v _im~57xGbmx/&ߩeֽ)lq6gI?O}ӟn #ƟMZQ72OuUҪ\w`|CtPS IͶFMwHXOl }a,h$ ɛ^vJӸhO{uqJ4:m5v(wKie1g₎g gb,Bu*HiHBgxOaLo_.= З aSւhyMDLn1}ׯxdOmZC?O r. F'Ov $d EbT-'Vꐈ,\oӐ'_??'թ3U% {4N.e{"XS^w0`]'!I|@a= Y%AN4KfBPdjWjRi]ȖX'lp9ophhmVSrAO$)|ҦsSE?.mI2k6 M<0sȀ/ѓIvǝ&=zVZŗڋ̱T(njJ#6vWسѕ@;K ɒwH [q֜QX<8xTXM';*йJ*OV5``ӓ Aow FOT vQS0B .-Q,*z$9^uF0*ܹ{lG—b&L]>DVyx^EHe(1tF٦̳`.=vH<-I֓ޟ֤OGР8]6McVWa0`Wu9x m%=ifT≾@wno p RvE6>EKs;^~[W5N 'n3ӋG|S,xl̖k1Mty7T\c IV+P7ΖnQdB!v%RQ2U@G ֿmVݒ0E6ra$ vNC 'nBYv`D{?׆>S{J #7sGAi&-&XzxŇL~VeL\>+,'"r0]Uʷ Vs$t7}+@g4ɷ.K?Fsv vJig=uLF7?t= qRZxrmM5-[ȊSse7ItZ'<̿ ,5b(.Ͷ:MdDT WЖȳe?r'vkdr:BÃ8BqmI]K14`hgs.$A1C X؞HHDVMT;PsYm$C|F".:[K!(6>u C_Ǹ)&"/Mcp7k"D=vo,,7"5hƣ.gh32ꮳxHu34t-dǵ(F}ΥĈ?* (Ϝ 9[A[N.oE+mu_>= /P*3:xzl6xlNiܚyٵ!Y};3cP]E2kO/9~NB4CmU_hgMm L^5=^P BMЂ ٶvX0`2IISep `3Z3j,EĚ{)hT,jQBk"š]SC~'8ZCg3`o@78 N"^oEkhܾ}^{WV.!%{]'IBy޲(B#]95d*пVtΝfSZOQ)+GSZ#:d4G$|$ߩ\*e>`*Ъa&ZdCrg ؘGN(gqwU;%$ tVګg30DbboRřY~xщ,Pj Ӌ NFܶK-2"*9J[d Ƿj̯Jr[oo&ίvm'ôsi&Xx2X۸2,)?2Fo.| w/^^z)@0p]kuf1NƖ%lƽf#&#jd`JyH &k @z%_KxŮK TlǽzPb6T|jkٽxobFxfu)`'+k(Bl*$ΰ6a׎W|plRuA 3ə|˂<<(Q`Z}Mtk|7:R q:Oo2Ve:k%y>i~Ow94t-ٷN#KƘB 9a[EE{*{E^h<iejYp|{'!_"1M䉥/fK/8*+H򥢚C +1vQa!b/qx ^QV90RDk]edYԓ#_7IK|S=X,G֒ Ti^ ֳW.PqCNFii"e+:uga>6 U;iCS”_7$9!t?+qb}afF:EmM G}IENDB`PK !.tv88word/media/image8.pngPNG  IHDR?1IDATxڜinUJ'iONCC(BH#jTĢ^)SGQA5 p$9{7XW>׻?#>#_O?/Iqq Ǿ۾_#?#????S?uʯ/>YY=?_kݭ[տaOwݺ? a|Wug}3_|~7~76?_K?ܟ /=G4>?ݿ/=s.W_%_}W}~/?~}Q[o5SO?'?>>Mfo))}}+/W>OЭ>ח~?6QM7j}7iW_Rދ7}hL+n]{^ ^.K#nn]<>Ї˿A6J}7|C꥚F|u뻾wo++fՐۍI>n]?_=9:%Fkaa|4MMel.zpTY(k盲>=oMSs:ުMp\b7l]&ߛV;E1C]z\vf96d-Z?~A)4W9鍺[Oi̭_JfMz iHYMQm{ͦ|%lTIj$=[[/e$"r}cq=؝[nGPޑ}aPz/\}54ϘM~sϿbk~}73+>uC L'MhxFifaMrꝜ|]oMWn[Wjt[~/Q#I8fiatgSmG3K6ľ߭3BMM34)O>6j?c??vg>Uo5+V@3Qn]&.%.WT{\&P>r5uKhrU6T 4-1j-dw~"?glO$얭8"O}l>^?%@J'LLXE9d vIpѽwQv9o 46}҇υݤ\#?G4= %nHre8-b$;R]/K%??g=.W&ݠU緮a-/vrnZDHwXkXvmwlѕ_eMea~???[xGHFB#Нa,gcOK3k|xcnhOl 7-C˖MI{{+v7Ÿ\G@wHyV3]46ش4g5!br9=h'v^}m{WcsR hZLcB}}g^Uk[Xn@ o]~;љFҜ4|>rKW'.C=OwzJM*7E_} cS֫lSģg&<''?l0V2_wf6rM/69g$7I]%Mh/CZs.Ws k',S ==A7,+YԓĨδ?=ޣY>uk.W `@UMU?S^O^\ݹ5lk az5~y5L)&Шz$#dƿpRQIL2Ԕu J? M@ ,h8SYnު e}2ELڟ\B3Ỿ&O}S|}&9Иyzg_>r~g~&o⧎+ Nf5J.qW톢[mz^۶fzvl)z3n4,PoS´i|oEg6hzn*;nFkīf>D6dc?Ӟf8ӁfKiZL\+O\Z˴_> _@t*kfW\&椯47*QKUG7^PB|r6IϤO6 LUOd ,"YoOtϤ17 FDմ7uM'>\<p@Fo 1'<>ryM6$ys~~__HIRv՞з!$S ovne&= jLc?ӄ(@ý+^׾FASfhi(geѳ7ΝGulmbKވ3 A?3] ndž/W3eoʚYgEiYBt7-aI@__.#NSf55y9?яNλߛt)nBpB!EFޤR[-[_zժsa|d$T\Zn;M5K =%qyFe0: `_m&-I[TM~66l? ?Xs|ޞҘeL2lA$Y\Pn&s: 6*%@쬵H2rMXV,cnEOszҟگ^׿Je/K&=^Ha5!ۍYf ڛZt^S;@B6MtLJ/[B`PFS~{R&_$rlN+Кu|6.;@CMC&*!s i:}-לH-[nm܂3NPzdž$dD Qk?=ƭn&G;-1T [S R{^p.ml< ,e=kI9e6Z5aT9M O{gw\SAFt< L{޺Xl@bBl <:i'@W/|aEd2_Mvk~/3hdKn`-؎Y ʂٽF_ Oz|Bj ,AVRtt$AKMP9ʹLjH^{J'[޳@f9)Qr[ַ[kVKmm1g_u="!/)Cl2(-jڋ%m©)Iݺ&pcKηj{3񌞘\6 [Nb-gݔ0hɳ~;c˵X{kM?\/G17AbḪ'H]+Wmx/%% gߒ;;#IH/nk^3aC ^4!('},5͡ST=7#[*\r`M QH53VILMF[֦u]nXнWjzIyC{뵜 ;;Y JRq2MhbcZ&wkm[;wݪ)N[s]qlLr\gg?]*vpRB9l[$,ˍv'Mci`-A# :/;43 |2WH_l+AoZD 6y[ D 2̿׭А@3֢$/iHVE޴y;x#iV%U w!X 2SqI=A5@%̶YtgfH% Dkٺ-OJBrb[&Xmbx5HC0L"K-jvCq>$(-9k`*mA5{lmЍ?Ԕ6ߦT/&5T5N1'qGHb4n+cUi)[Ww=qK IlCnP MV%U]>%l4iNJv ]f7j{Y^$ ,H?! ifg;D#k L bh͒Ζ?75KRFj=k:{ݺc|2ĦR+_֭Zުw=mmצo-+)JtOݬ 6Yf"3w7Zjp$^i{/۶??41m3 vg!&!܃|Bvd hlXwg'%dEv'k'8evlBho\=WJ;i&>aBֳ`:Zsb+%=zsqj$@d]{ rqJ\SF1Xҁdw CaNF;r D/;fiXor!l%VR;s=wyg'SػIO^4!!MŜYǙK\/\ -4ݿ7۝fO8IOzRoʙL%3,OӘe~h6P]{{Pz-B҉$_9y5CeMNoCnS::cJۇ_.B W.YWyuI@}B§𱽫1qַ ~yùɽnTBȚ9-IO%4K>/@$['<  G+.6&AѮ 5vVWP5j?@Jd5 >F&%lJ2LW =-jmXJ_\ 3.W/8;$QU'E/i'-4tcۺ i63oL=kVHbB~h&xEŸ΅ 1kD0 )@ːsSl2mu,ʔ8 'LKfA{dO@5qOBO_O{Q7tB$wկ~{޷qSp ).5\X2)mgG`Mڹt7iDxzߝI@$ :pi de#@.hgEvֱ LC# \}&jcqN[S"76tKrH5(7| MV%I@dޖ',v==J>y&14ǀӁ.YA0Mq4*XECN:vHy IYIo/W.k^N>X ow3*g*B~Hxlrm!d7ly#i+h{"arE'; Bf ǵ"@+K6ljRuP `فE"9Iwn<gvixV?z^>/MKߒjt̏b0"oƅ,%]ve`H(gYIzzv',CoyCG6Iksqmn!fQIBغ_JFXtNox0>UBO7tw|3$ͳ m3,= (%/3A%IZũx#voIWmi|&@ 6DgN4\cm(*G'WӫyU*m"|ǔuɽoFzar\,0٫ki׿>/{dNOQ W 8 sa %_~:<JZ> }KF,}|˷|7{77O G@+ _Id_ɫ4]^ P?`d`jAlO3pOm\N2#e^6(|I"ҀF#SA[rΚ ~&@^0 ԀT]-ygl8dF-kXt9aBq7ch;d[֫:{f )TS*}&_ xhWPQHx*,͉cueA3 x򓟜g{~7MH' OkJ@h eg&9d`n2L-}$y&6NV_"jCSbeCR %585ĩ/h}F "Wi6b%Ia %`vݭ)J9e7DJ:ϚQEgOgcmjy]*H}0t]>L )@v__\Lr(@_> B' Ȓ߯8wy'kD83*&ܩOLe)@?}[U^P'AZbofUM/) YT1hcz} :eLvԠyc[)4^ ,Oϕ9]._rټvy<.JOn"m͎@/?伷oBjh+N o,٩?W.l4d \nʝ_=}|; xB/ 줝S-U'AAƃ2}k6G\JP,9hJ[E:ϔF$C.\49iљ'KuᚶwkG*_LɃ"F-YIQ7i.D!,ZդˆԬ.1@ n\IvN):=<ɺn_vH`XC6}B.|³g.:x3ǝשEUF=L(B2_..;G$}&eHpl8P$xr<9iN8NHLz vx ݎ4&@CEF &]NjV#ov(&}?qg;S:233V5Fؒa4k=E|%wiPAas[ʻ㮯2Da]b#ӊH*g$Pu5 \piv˖MO\5}y\ S8q2ڛPh90 ۣ+2|dHBR]Z+QS}`Xbo'ZCUQHS(-?Ǫ61|Z]04,V'|,e;js{`g=?EIS/ANzU}p&K.5W*N6tFr?h|, ?Z4p>P VԀ.&h*A+ wJ9Ws' i'<^J} ^K97f[Q|ZixOF2"qfC%jP O%I)jvȋI౏}BKϒwfdc61O] dq_-)ՋY-^/6!~|papI#'\776*5H}Ytn0g5JDOq{)RDOcITi`92: dAEMę^qjzUlCU3K=N:+l  jh:>Maz|PQ%5)yp(}:~O%ҴVcZUFOL @>ׄ&G渗ӾUы)@պR(d=B)nT(A -ƺ V`DIIk $Gx*^ԑ`kV\l6Q O/B9q><_a8?J͏B{wfU:@1}w!Tvd߆EW|VM ؀d@FB:qzET+ e(WD ,Q$`y_.4dSjaf4$Ofz9@& `9'yTmQ(ڶYNJ|wbЉM4!C;+qI>`(@>ջvσ"TЛJq;l {D$g5Έ (42c$JoPO"tV)բ8, 7%@دQHpXqCoJE׼`oAŭ&rؓJ䔝#>nF)6ogH^ӭ Xb&(PrdN,yFsj7HLЩ#{˕=OoV@4PV~ r3C6z̅rVzActD)ɟ.O xYԑ(/.dS6mX-O+[% D܅I` HRx”L _.$g𽭀k-;!l'줊 G#6:`W*u~4JтKɡGϒT^9{Q/_vܕ}פ'Y } eZ=j$?/5A)|`Z_{_՞a@hU=Eбg5I1,b=׸vg;L@QW7LscC@|r6-xH-H:GlJ^< ?'gj߯f X10$j]IP#2y('vA`gTNO v$a|{SDM6kEZ($<=|;=B}wqκ[ˤS>@c\UK 09Lr;'cՉ@&a'b(wèU?׊߲ap<}te0:wf5P!g7kS~_̨ʞ&4ImZ2(`S`cZS ` ѝDžU ?m 2wh?&I2d X 1PԊts Zn {J|Q~ӗKDm+V Ddg@F?vDޝ.cl'f $i7p.xG痫 UVB%x-UeB;@vK|w1uOLW^½\ ՚Apsщi+9G4Eʍ@jgkfm68HVD6(@fd/Μbx0{ `u7|n ٣\@O~oW`6ȓ27,pctD^3fkܰR0k&-I*K7TGdILC3iQ 9}w;NgoƐ+(x{PZ$CY7Q,bˎ9fJs[8~FJy.@oJ@QYQޮEV:pYuB+  / F-ݱ93Gm5E-oКFM"KaƬQ2o2)C~ mQ4A(u'53{@W\nvJO3o]>ʪL,c!낁e-"i;KA*qbۭ^sYv95IŒ;,Sz1}4&uJp6Q’;\ :+ՆISԪJDT[2a HT9~u43x\gU"uWDt@>#\kؠPXQeRn'ݘQFF3ɖ4&ݸ^ S25δ *!uI <ϿrmXK>^7 t ˊ=|? :Vh훒\nB| [\%$w.3кs|Xl05/pQ6^ AM#P ~:"h"5tY×Krt`$ϻ\YFe-B+4)C`Mq#Q@>Jm(3~a/}qɚx`95&V( N]BĘB_<ʙDah3W\,M&ϓ5JG&aН|\%QWwе]dz&oӸ}+BRV*}XA9A9{M7gkkTӺl(Ӓ4 {pMHךp)8S߭ǒTZS%vV< fdY_\9i.ZJULz2l2 /eNJ}t8 Ϧg,;'FLv,I`׶zX p A36P\ 6fFHemUTET~}Vz&}oJ]':40=s`GG:&oue[U_˯5~9ٛPe'uUByAS/^5"kh9.gG#p U~5&d8;ZOZގt}sPΩA S[`qx ArVcm6K~PB\J *_ղx㇚vTݺdٕK?P<B+`N:`^;oD_ _Ru mS7&6\T\"CQ"(K9wZ`Sl|BoLGˠB@ %ɇ/0ߏCmPWhٲ vL\m5BzA=L$e3`mӅ(l3z~l<Įn +J4?u`AiaE7`oky+#\7YroS_w5cwjI&jC9R+!fem@)(dN}h#SˬA^v3g ԗY54I._%;sfSf_#joKyOy0~k[hI7M: N+4 :2DM@_R-69b#`Yk< }Ŋ"۹(t֑a-GEؗ@u7$;\@y:8,%15gy  O8D}H4ɇ8y:""!R %VEch@ (=0ȇ:/*{ _9H,R DXNb[Y'o0v:(] v0`O9iOPk'eg u& hoAnpe`_:˻ej\O0`JxfH}n/26js$OFچaK,V K~k:v2ݦZJX_UpS*B^sUM_~ݚiZ3EسT/.8{UpV?5Y蓌i2h[lj_ּNvTV{,g:4θ%ZdQ`iVc5ׅxV*\n vzas5䍚x=:e&/ | Rr4^T= ?ch|`;K3AS'xYԎ_coV*+0ђh ^lP'c:#0*}V1QB.,Go :&EnYKMBal8BYGاN{z.@͡ﻦΨ WEyDW'L@Kh8Q\3upڋee3<1aP0x%glG|CB 59dlѨ[N0Ph*<+B_dEܸ^cSŢ-el .p((h)@bL>HT:/MWH(5@E;~"GGHDMֵ#a;uLhr7 +\39вl$%^{/C\8|L}NZC܎<'t +oo⃒HBlƣB9l->OpŦ+센xsevsP k"Nrz[Nō?gum:9K >.uV30Ex [!J8w9Y{6 /g]gҐ􄗡v#U XRqpkMDVj5hU2#_?HO(_ AώC@Gj (N0⳸oY`=3c]¡XA)LN4 $evE9-zҢn.зƠ,2INŪߵpii~r>1yL:'(Iw~8qԄL ~>lZ׬Aԁ:rGe?a "ȂX#P_U37;L}Ij҄"("kH=.'x͘u{ ?xp5S9o'+ڔ6t0d8N:~Yr JlQ oqn*()5/s QPٟ?|}ou DAkesuDUz<𲗽 vc%$ZaDIߠ#GA}btJbk`!`:!rۛu+ (ȌoY5ZdFsJ|ŭ xD}Z9BJ%@?(6 0֧ amЪѺ{@#>pfA{=la?jze]j.#/x14W0I+$aeZp|*m"B@&ag~}s~W5 dreH-1WPS)@ufF2tF}fesN5j]V4d`=B.Ik! i8߭J7?NN#jXGUA;%"dM*(t0aYc8Qe4S6zֳ`Ň&PeWLc-fGMk2Jeа.pUʖ'UVr,M\RNA׾k蕍ZuQ׀pNo , TIC>'~̐s`Ƥ?D!x}}m iI<`,B!Supgg0ZX;:j‰ifyw\-Asu Ѿ@_M{OSͬs&C`ZV4o8,3́ԣ;_+Lge[O0:Cp2]N6r}|>׿u{]>b#F=R` :nL`( i>ȏQIEʹeEcu[We8m-fRP!`4[9ό҅Jaĉ1?s{A6=o!D8{Ec-%j5y{@`â@u Mw'ן,!ZзuR٪)~f2v K^Ww}IRD"ky7DwV6 #: @\X%J& T*J 4BozR{pe#! LUödZRu zڔ['`Lt*>z39}q#W}2YMӀWg'K],:gRs1s|geX EHP Ju|0g@ΝRHr}ַs _{o8EMnހ<$ŮWa c5g%5=:#. NzET>!c.$܉x>hXT-fDA" -\3?,H.Zo`3+hl*,12e=֬ݾ (Sw^hB_[4&t,8:zk;](w$_`[d̳>E9{(|λ(^DSM 98)Jz$CNcV=3O~ۿۣN84aSvm*B^ܮ+VgiY:(MqwdOR;D% xP"A}%%2LBc]P/фaQ$`632uF3F8Ύz,C6[ha¸"PDc;I v҆.2צ%wQW!^ I+5@!^|6ZL%Cbu9609-Dv@ GCAF~tI87޺x -*Җ$((#ػYB E!hҫѪZX$~RTX*iB VwR?)N>@<(Y$U6P*0me'MM/50( ҟt*0<0hǥsOroofo&a V޵CTpHuSӴ_yi-LO.b\ nLM30'9 qi&xZ!iTBv'NZG2Ο۹wLr"^82Fv9:38H&v59s 8[-O~"ӡz=hAӁd6o+QȚ7ʅ=zZ:>6nУl0.撥i$@':Q3ֲ%S~~˕܉qx46E<ШK[-CĮyz+_?6u\7Ϩ'eFdg|˷|֙8?uLM):+\Ɠy%$7}Z0aPt P-" sDY;w[[/97Ơ '   eǘ9)'9ԼE/ rrz7zܿ[Uw᪉mjvZК pݸuu8!tHؾnzZPIB/)T/voϮu7䍒I&}>ka hu3cq>:DeDN?u 􌄩wH 36)EKg[4L_>Q5ݑ!-ɷx\uUqv,ӈW(ȕ,2~G+/~39EYgM)}஻jwͱL'[u~ID£adC{{_9G8O5#yI%ɵ] T/"|˵>X`*C}\EHɱe2{x:4$eKM:e2;P|-ҨyuH)Gpy!B1]j"5_;s+`p>\a1 B}9UFy@qt@W[7 0xcG<"hb{;76f30 MT4Z[IیXn8O.<gFB'muF`R2&IЅiDn>|#n}Igܜ d BɰZgw+sH h\)ptwW?U q?౏}S#H\haW^@񙹽"Ž'\ T2԰>'FṼϩ?ݺ*xL(9eˈXe%FlP+xٗI\k|k"]U;@A PUςIb>*hZ&zVv XG?㘉W}N^APyNY!lYZsC*zC=N-۽ޛ;)"hZ6V5.$UY#ԐUiJ-3㙹bs&Xb-ƨ^dġl&5tдvs?"DA֯6&;ҁNR`g;`^q );}W.N6:(Yzq1b*hDz7@x8? f#`ص)Ɗ/vͅq)k8MVӎepbܜYO2GjlKyde0"{l#;K_ Wjѳs3~՘C_90Օ;>zem'e*h[&rKl[ޢex=[ô`2Gng^;s}cP>M`m .)yv“`Q{x9}ev 3Z Q<)E=^ aГh.?@թ%Q:w +YUۦI?Oq1%i:[@>U_xܺkx'P6ҡ5#74XeI|37mb$ YVEcWw:vPu D.f&%:Ǝg}נf r-Λmxޥ&ѰHU^kӚFW;qY=_03[q^`AVRICkt+(jޱ{T Ff&8s gllYÉPG8]I%B۞LMq5=(d7649vQ '‡o]x@zM7t0$͔^\=9MXf09*[J[:F$.t‰=3c$]8kqQfI SGKVll3Շ$Q fDG?:SEs'"zs({ܴ ȊlHoY52n(]Sm AI[v2C% ?^;=)Vh[VELPQ6'hA^SZ7Lg~&sKKw ^켿c3o:=ۘʚ;C Y0N dgR{|Aj\Y8Y+PCy0}d60zg}UqBS5_ Y$#YT_-rӲrxaГ#@ӾRNj}Dsm &m.V{WdFM 8{n%)R(.MnH:$?s?@OTI00!4z[/"6%c?9Aj$ԁ.;Z9\7KL]%ꗤPpoԻ࢔oTh~f`4@m'^.qAE2{;ol% q ҭ'[*OO ãvAi5CҽPgo zy>I\rCyv6 ׬%(v1roذ3+A^q f3BًI4~㙋ۜ -5Oa\7:L~/{R6о72w,ꈵHFqvpYUtrM,`o';s. {$_*=q|ܳLq7 p lc8.Y.a3,EF;ND^HFI4|,?{APK& L$( y_d-9Y/Ϙ63M]г2)@jyسb_X~ggm/+9m!Фm´ kZ`Nu”AO"*MNA9< @SԄެSc:Zoדf, \&,3FKRƐu;I}O5EBԃN;.K;n[g=Y~g;Ԧj%OۿF`z0$+k2PMI;t0StpP`5s6Y jNtJtg:e ғ֥1M~:r$U;ia9r qh!jo!U|j z: ғBvod"t DWK } kO"sߥcWL"0!N~p|f'xooz%($W'L*1Ņؐz4;fj/v _j-jGB#g(1aZ:Kqׇv=6;aE<3e3i܋d%1t[lsSV~ҝi+SlFr3铓Qp Rh8#׾kC*d C;Yg%(^`M]U0/ReVIrƠ4}Q˒ 5]@|hvT ح\-Ao*5/,K%! KoMdw$XI )4JjhTk-kHqH!5Iu dvFǵRjVBWO~E] " zd1G 8jnc5H[9vl'g Pwۑ Z{ (s:r-? =M7g,_:[v1[m|91pn_qvwpv{T8ϠPHc83$E8u]qRJ 'jV!P'gQSт{te$*V"3G\jOhZf[ளWT%]kNB|ԭ IUFMu+I-|$est[L]sD@Д2\$(ko->/#Rfu%`c:\? US*{b)`T 0|IZxme0HSN;S8eGϨpD٤ਦ$6?U,!Y.-ޜ.V>VFv$)3ƱG &mLF:  ̭_t #@b W[v\1d~hš+7v:[fCwi'ykw]̆4 -UqB'`^ VN:h זaȏ|$PL"X)@+bn%gOߒW9nɳ>A$Hso]df'Sw^H"tl}Hm]X٧h& a< =qҎ0?PCk\B*EͲ#XG&bг=Oӓ~t 7'MZQHt,nͅb#6[ֵ\K9Pp 8' `'S>%,J-2v oohR S0:柣oӼg洚u5a1x,+™L ƹ A +9g%ΑΪ#ԛc +V,-"Y}q}pXPڗ@+{8u]:8cxV_2*C,(B+j%ևCø'/CKKi#0H%bp!~d@r/ݺteī~k: -`mh2LcltįI5eW)dN{YjK7.ξmAg|FMX)ڲ֋ڱ:8HR@Z^u9K#A8pJRQճVǁ.J~4E@\ȿltIv@ڑ7)fJB Mt+u a2f.DC_xB.2AI3i9FRWV]Oޯٿ;Gq~ZDKfAqN,VLNOYBB&;M%LNCzOgETEh-"w謍@#'XhzJ" %1,rffN]|ȭK>0 چ!0OI|܀\,B?C_q?NR!l IJ˜R%5+K_XЦ#%ZX>]1vL_=~_W_4>2MUoTP栀=KgVMHBG>}0+{ UȺso/k ҺULR2o],#P81qD+Wi\yNV F˜ᔤ3lO8YN| ˤ4?x7q| a~0>t hH1ꢤNjEHnTrbP.ܮR2YA|y2e/ 䤖T WR%eqkZ11LnUޛC?8ߤOQ"Q(xw6yN+xԅ^`>**?LF)'ݿ_npO F0/ PPQn>nB:a:K:ⳣt\J,DO쳬2Z{VZ غ]"uߘy>3}Lj:7,L.+^񊗿I}ݗC۱rxqd(4Y[kz[]~4n1(e01!h՘:DP׬R@h@Y^CWu V4(cOw ӭt8Wa>d'ߙd7LQv;%\F V!|{Jj<> rI'$XuPW9%n,>1' =_F_F 4Mi6:Amҧ\?_È:-gyϛJqbGӁCq:$p_$p "K@Dۍx†Za9apbȜm'i*.=8ubP =.mMàӤf_w1[G^TqܛI^/K֞}?k*y>=ܓ_*:2Z`"!kLII봂w}q9̝`~z EK$/ٮCBR'p6*<<:-&˨3%D-zߏۙ\l ^u53CDUtbKb!+4kIP (aj/t`1T\nfN{o$'&gkD˖N} 70é?Pd=ԧ !Տj >MbqG=QR;bmPek`e3^ NZ5\mR*"im m 5vbDoe:=,%K3Un׵nM )(x'=}l=w2h2=Oq1ɶe߀=W& e9(ψ<̨F͚-eO^%~F9쮻zC&Ts@7.rgk Glr8_?6%ᱍ+?hó0b-`R*Q,4p,w?w8-q/ߤv-PG{m)oEv19.wg5JYe65Tκ!S8=r-U*뜠jak1keqFd^ίAnhsC'f'q߫Vg#S]^PEmk\͜NgVETw%綂$L v$:<^_1tFKHl:SP\^P k,nlظQ5N!VY51[hSc5'OX(A֤4 7'?UF ,)/4J2GW"!+<'c@=2{eDQZ# FHFr7kv˳<"?oo"(_zIxA6~!nѭc ζ@IlC]{Ph7X (@+x&vِ#dwt[A;~Iߎl5?fϽalb]"FިdS;c zy Nбc CSpIX2ZgH;"n1+L5*vvi^f5LëmDJ)g&mC)6#!غ\pN~HeҨZuM'g\nÌ}`=9ԗf"QԬ4ZHWÚ\5;I 'c%S#Oo8h kh:dusޭ%Ӟ%4-sD1@J58Ez*>+N3"J nb*te|T-H}uhcGTh-f"Pr‰+VkTD/47͞LB(-ORG 0F&[lʔo$5rzeBsF:L_bHJ[P%l|O~rnOʽK!hUk񣗫_#VB/_zw9jn 6$Ԏ7TH9pĮpH' !D(9AJ -BQPJo2g\'lݴM{5ϧ;xny~^׽ֵQ`T^>B5__/O'%b=@D#-xdni7b 0LLA2Z)_l6}\9T,Y\`^jgOi\@d_0*~YM}ztٷu 1pJ75^=!ae{t'm{b;׌}^Dm{}qVo~w~׻}שF)ю}cY $P&osZ2}ٱԶ-5SyF'9@$psѵU:2j{e{$LD](У;̀i0樢"w{8X[}@!ݏruPN̻$- >XgRXyNkXt.(UH>]NSԧ?駟~:]";+imK׀u#pz\g l`5Jܽq<~~ǀ<55||>e{6$w-r9FĀV2n'a3-Yy -9P4m6̧^l Q,P/JcJYbMyY)Ns֟:"|Nl[bt3@C T^$uϙg?/XP[m93#ȳ rO93<_v~{][z),+]tu3nڭ>d6bfFޯ}k,XySIp;>߃Yl$7/ <=N3=izE=N]kNpuRIg?~ue{FR diR#2 %,:Wc!OBvHdGZ%<"Qx q6vyŬ%]GDuϿnGl7;ՠ( ͙xIXtPtSU L7Pz")LpA~{L A ~`P)BJ9YPO/ق!~_Nkߍn^{rBM'~իͩ;> qҖ!6 'wN)K<Ji³~9POX/)RI#; jWA 7jHɋpCgd[hwU?*MQHȃV9u ^Y'3w.:;۪;-,\~_:>@l1%(UW~w瀙KV" ?s^6EQ u}Gj)]刉ln까-ʫ@ 4I`S1& T'dbTok`Ak C30K ߉>B*j rQ#lYPkl}R:"WU?V ݧ "7Fo-P(%M6/i*D;y^eGW|j[ ʘE\T:.Y)Ŋww:J]]j#,-[t1J9'aK)lc7ft1~fȂ\ZZO:׳ھQG/KB>VP"8AkBR $ ~@XOp-=X>*kq S eΗBIKΤN(5+:OJqnhb~66=Λ@ri2tr=:T/ ~8\ ֑rHE'ZXPG+Z.ĸ~||~_o}YTY㷩[9.(rԧUXQ_*'V۱uIEBt,PN@RTP.Aee/2j/VyE11<}Jp'JgyI/;yّS2?*MM+ Tq9ޚ ]]7a*VIt 򃑿&NzBy5i"[S/%Sk'btI=oѧ gu9:8#MAeΠPy;//dĐ&p $;P?ɣȕ#p#G'!ICo3ҕՍsA &M>`{>d^Gˢ@ep,ZDi iOimI3`؟\}3pP])i0rBE%)k§P_9yBvA@ഊ O=)~}"=K8p?ڵboo+#p2X*gK٣S1@NȹD#b[IetLLg7w2P""*5X蟢Sa+'&zbmgđ(O8MoIh~+vh[s + aqI8n`',AOt7nX-P^(j^ Wx$'[o8 %QB_pלÿ{\9RulK0Y'誗tj^RpAGMA:Nm^Z5ZCSJڋ6|[vɱnO؟>pp'L!_1t#Z%<Ս8UJ)} 2rL'+| s \"Px*&;q`[4N%&E)uN}C龄_Ct9y%"q=Vݢ".ؔ~ԉ5c%r1Y}-yL}2^{0`ɱX4yw8-˿)5$jN`"w0hD) Cpx '䫲$?d:_ӆ,#N\Z;] 0p6FeTD1aaUurk/ٔ\* kz2]VjO Meg -q~S6=CHi%t c,Q?ހ.pN&S0'fnj'*Io$qhoBeSlBNM'+ֹ"t98I.ةy9g:-z8NqԵr %$u_k*&\ע ]- [`U|e5\ZP| dG⍬='> rO?t?m6Pm,H Z?OW31\ e9k-؜u7.-,[g F׊Q |=? SiXSYT; #P}M 1%ƳUb)Uĝ_F vWEOI-!ؖ|#M9Wvm㫫7L5d_> gWZ ;Ѓ"3YT^PdurK}R"UDq6/Rlˆ?g6h8C/2Qp m12&]H Z't-2MІ2t0!jlTȩH@c_s鑚DX55Z [҆Gݓo MmeO_g_K\a8ygP1w{@ Pf 1a|R:Ne?0v6f'gJwT< O~'"㼱6Mk>>z:a[{4 UO~)8Uk 5R,N@*Q40qo}yOɌFkvh{ D'|&뗸$|*`S׉e/D܊j59і PSo:zu)MmdDߓ۾0Won'!^`wQf<Kkl:cl}0؉p iqhV;5tj #?Žf&Z\!mWgol,:5a)*| fVjah699Fkq|(7=C64U2|tL=[ VR~Dpe'У$'Ҿ5 Ns>`ADb*8+Ω <n-MEP =#¬WM!g.%N煏UAqUy1{QJ%j` sh+ t{w@8uK~B2n,!xm2sAWDIE1mNMl t >ONe>"Ш@^\0s!H{ fTqBtf!Ao)H0@1 UЛS턤ѕ RoTѲ+>{E4X1,[b_^zDjz]"!%NsaPM0057 aq p?ַ dwX{ -Xw<|;4}7rl?KmsѡͲ!:*^~%h5[q&pDi o>@K1I:@j;j@Z.36@ڊ0D)[Nj*)}qћ:ؠ9>)SD t',G[V-+x@ fK@yd>H? Z67/WdIn4 |V(^U,7l:Ky}+uL|^mX Ep)vXٟ`ڣ<e6j(BVQ #U^)}}5yQaC7׬I6#a님9"NVZ]StWl9+S'~m! Q1NH)ج_I=#o!@R k S8,٪?&0!x;%o:l8v^ַMozӾ"W 4Πd77[Td,wo\~9NB&N,guaϦuY2D6 %~V:(\Z NVv6tZ8KxQ,|HPkn<r8xnrr?jZS<"4Rgh7]z9 V ;6[t{bJ RFTԖskԖh3^{maFv !Fq~39{s9j'a;ϕc*_/_Y}J\d\&oSQA\=uV]֡1S$M xymUj>ȫ!vu}*}PwV΁Je*Iy4z'/))?6y oco34G9 ' ߊܨJh*׍*kY{< x!M9=DPUR~ْMRڷPΎ=ZI(>X8|2_!)BRKCfE6"B$ F M+r~6d3$~  N5o#ބD*2JzxDsR?uޔ/]o~bm3z^}S" _7:Cfm3?o{\ZcuSmsMAt!ʒbn> &i{ݞ#ݴY3{Mկ!L@2;,dю?]a]8ob>O,ܚc**HLXxgF-5a@鯅]}k'9Z¨}wWzp{~OrL ][#6[g3~߿_􁶂5^!sD[oYeU'`[ʱpJB>{}"y D1I^C3u\bP7IBo \g &u q+lt?.6XX,K6_}jekLWcMVf^B+|cX8q!6UdP#ܥks^BFs¨)n9oxc':i%^|-ڬF^<gTs󐎎paWZ9@ Y; @CO†@,+ʲ$?̾zNGRm%fo/=fom(I2 xE-N1X3 Fb%юK EI)),G`9҈A޽]y kN@(ԡDX;[xX8Y 273MޯFhuo;mߏ?XEj3(2Z0ŚTlB\֙Y(xJ~ZuC>[RD\ /ҴR p\[W][HfzjtDyϹYEӋw^cb`,1:v V%gZ0^̬1^B-[e228P>Tą  ,PMQpB|'de%Dш]M|*t_47ЦhA(/_/ \]Wj4䪎Oڏ 1^xZ:j@(&LZ4sAQWN&|$ zO ) .'j.w |S &mimآbV;Oغ_ vzg*3m?C?7o}BM&TxĦNza%UX^ qui{t\PD40bqiY4p5V 1۝Q{"ŁRPeBKA7z Zs.W{ gפ--"`+՝tjr:u8@#b'b^"-;aKtVFcT;u@)*.}SXFew>s_[}g7F5PtgHR%&K^VrX֧gݱ4y5@Uokr:j#6+wb-c=,&tD^ v)/jƶ- BB`kRaC!$jԩ<li:xl>H2N9g)95DHr?C&UCe7o^wN;؁NZs <06\LUAAWZiGWy9}6Ndx,; zR؂N!%F mAer( ;.*:HX^"X9=`^p\T5F#3fc$ &zl=?)7 1P{(u f)vm]d9z' hp1B|r|;7:wb&}'DXdT|j(ƿrTKb3"*pT0. ;-1~P`z&lX I`koo R:ft?3PVe`4!gRNUޛH12>g z:P[jX+9ؘy 7!7'2_<.k<Ɋ/>>~'N Qd;_K;'kӳvs)SsI~v3`y"]l ldo>ǘ/;"\pz!q~.1uva3+SQ{9?я~Cz׻޵(h//nef+4I"agV(IXjFMqPPgd5qo1o1@8mN`:gZ.duӕE9${zӖw[fD+ޞgnmk"|OJF`rlUnڬ̪)w ؑz ̓;f&"L1jS@v7܌߅bРgwO8{' sMXh!j{."m H&|J.Ӓ"2B}VC6+g֢ R?Z$qy%\Ν P!㺴])m b,BhN2L7BmξbeHc-1 ;h`1 tz Mꐢ %Yy/% ә̸$!ED8V=YWaM[J yf]8.`ٙjGˌ>cU_ 1j vZCnX߮W!576Z),`fe~jBA~@LN;ZD/KL;'c='r`c JZ~Y SstQ!Guj#BtВkm׎'~'ھׁ&`ɑN4G>79 h"V&-bP'c17H9p7]#H@֓ڧ!<{%muE/2 D0?GMUJdԄF9|EEOE:4h#M6caqHGhsvOWnĪ_D"蘊Y4u8)4)+Sv3(#zBf+[e{ 7e(Y0|;EΧ$[×vϞ%ڍKSZRZ3'BgO&/)o!'/ɠ6Ў$@Ur վTc"<=Ǔ)$(E:uW{ғ-^O+ChM y@n(?u`%mog.JۦcHw^1;ޱ~'ggm5ZmD>Q'NHnrdr*[x&cvE|*(&0'ךmz_؜c6tDեD 'nq1}-3N_ k+[ubO\H™4'KΈg|Tfߏ}L@d^aRoktcLwV#ow'9vm53|J⩁wQ΅vy;>ADuΪWW86mo]!G~8,⣇U]I#_}ܔ u@ɜ%eODj Vg--QɞܭF遊,wOqM@sw'⋳ nl0w)}jЃh0[gYC!H=R_`I4O#%LUg-3Fg"uQzm*_uNr O<9{I)ڂ+k>YAퟺ_HU =7VR{TMKJHۀJTXTI!gAFpn_i\u9pko/YzX#V~mBdpԡOغX;,?Oa|_onꫯ.(>]BY_2K+ӹ;WrM eIE [P)ejBJa]"ηBmohZCMx.uwtGI޻]gebx~*42ś#K`⪓ȍLH3}j ] h!+㈕e2"xI¸d"&d9<)B6΢$x:Ja*B~vHi7-oR=@7*OMgM=lfw9l{i'xx~N@dw 挚l9ǓHۆoYҢf1hܹis] J `ҙrٖ>}R8'H8W"2Z; ]3R!`lޚeNl)(sK97tK7e3e;fa;ш('gF)؁kb:+m᎓s+a; ١3>|JqU݈ڼDFמ3.*ҿ[Tsڹﶰbq,?i!1pl̬B'09i

b'(S($D DklE5jy& H!F$*|*B`j!7M*JFzS4Y- ss?mȃقi?ɵNBSC:nTXrUr,A gǍҗ` 0]-{&>B#MM`=ah6lt{x=ma}'KųC*83a|(DXWBiy7l "rFۡ A 0[AiŚ8u.E4Oj[ɭ)r'3/kJ");|Q[@7[(73hUBԊ38¢X5d"z[?g-n|33yzR7@([$LoM@ G Na ӓ.%ՙ+<\Tu'&@!K_#A\XI-Q'i. YQumeh*ggо *nMdX1ص`ihM'8LvͬmvYͅ8rc R0Z4.ʭD<>Ilї^`]D3">f1:ѣ1{Otز.p? >]ΑD"T[!f32 ~Š]X7ڟKDbe_]-gBq0J#H=~r) a*KVT$/E|77ئЂjFjoQ]A] ߶y9so׾Fp1z.|x'¶F^24\@ӽ8Q]Q41IK ʐSBDa6 (=-_iCP>z`!J X?0fAs JŦ d#ߑ~N {y'>KG"<"& mtv٠)?/@rm }]L- 6nI좜9oF Thֿv;;}jh{vhYg@|#UAeCN<گ|/ݳq& :BN8a>m&j2V,n%^=wo3^d6U獦MHa"epԚe6H !܏lxlV.ɘo@ͳ֛W4bۋѢIJH@f%Ϝʝ1]p$e;88;N A?إ`YiMzڼ엻ϭxCե}na0H׽l3(pI$לa7F6wvU*Gnkh֠3Lڂ!^ꜧIqީSP۩rQ.>z Cm6.;mVAm+JD0zʱ,טW1t,4:՟Zn!~iYAZ[ބמYAo]O'f|@nzᢴ45`:ߓ>~(f^Iqgpfjo.Qb- yׂn h8hr6'8P?kCH,:u/ht1%N9}ט㼟fYUoTWnR>=qכd s"?d]8S;ѡ*aYEIl J`4* :*yT;Gث~$ЇҢv/KeuF/ ]#Q\i hFv< ;ewlW/<ʶ (-im{KZ u'B T,=Eub2u7etѬXf5%I6*$i<=ulB0>w>^Eohhn(iUS_D_z1FEň;TٍWcB%رRѥ//U_Mi,D'^B .I眪y:aD!xSĊamvqq{4ع~{ lԦҖdU#tSr٤Ȼ`Koe& :J^4N}3 ] 9Q:Ad7 PSZ7%Uɑ~uGM}O0sqNn3\FQ3_%e@ U 4ʛu0٣fYjjإzk~qCVVU㧁j윻[ "{Bw|h3Z|& BD+Q?Fm~Ww"r{=/| P|m̩& - seg8_ΑP'9W#\xu&r֟懒pYjϨL3btB uat:O`jلtkp?Ϛ€dXB;@@Fw(T;IX$kƖ4̷y!ESڀ. :cB!텸AAF#j*s2-0"F>YVtpд,^?HLe{*L`WxsB)9?zO(OoB=mmbMSE or85rHeD;>\"l > 4DXJ{S5 M9/} 6jbX!WuYFF6>!Aׇ׺%d? Ppۅ`u*ژ'?s.mܒ+cC['(-w3V2Pă',CמB"(C [(b_\@hnv&҃iViVB;o3 $]SqE;R1c2:z>/+VIԎ9<+l}Hw%x~`R^D#c~#`QE'x'3 ͓S`mK` &Z,1&L^a>P6Zև. ĩ #c,2)v.6Yvy%tU+fBE<.aIlecZ.^.5Eꬌ-{B'CDٳ`"pWUJvֹ,Avw9]'[nGVm;حL% #$e}̺NH* 2 a ec'evgݝ!/ 1={NvI׳Y) bpFo%q,c{t쓂rS'IAm~UzIbucd@lf!ǂi7 V l882~dGa*\Ϫe^l\'|27~77e-tFk/aVLғ2!N]ݣ}t ~.b$jҙ-4ãZ(ܤv[kkݫP~~}ӟFS']O '/b U5 ߯V8.DW XWX:u? 5RvQ>VN?Hw~;r>1ǐE&#RĬAdÃ[B%|DiHDHB#.2q3?Æ2vTjgW0f6IS7Np"tZR{ 4x}ssȋLXx);BKՀ_@lQpIt=8*4]qi4X(J/!s}W zI :(f oA]ˇK0zqڸ(z.3X6 v` 4qgsIb =4N,юKp ?aCyK9J37D5 l8J@_xᅹ_{Yǥs[ Br,W"(kDƗ8T=.7j[I50{D:j#^K܊).D[.)&5r}Mo;K$U٘Fvrj^0ܠ5o}q'w27;iY'3ik^,']F!X엺J6Pk񞵉P [P@@8f0>`)Ŷ-KyNpEC]I$d!φ/*Si\n"s"OC>#Ii|t#WG?G o&/ !zSyQU_ X]CR p@ W)$qSIXq7v -/B`"̷9mY 4=zbr')TaO jn[)uͳ6]pbm<j7BgSc=|2oDqZ S*d%ֆ+[~ܵy6} a$V *M;h-@ikoAVxWMS]qM| z6봞q>4Y?H6j)UG<{isuZ HFey]Iyzj<6l2D]jvR!$*2Gdr ]/IQ󍞭|8}BcaROy 7nK*ܨGlN7nf֧ry}B DhfyeeDVKǀ_"*2lKIjwzSR67]X7+ISWcJKՆpoh N 鰿}lDtZ9 0VJ#~c*I7*@a(I|Gj$,Fb^]i:JYDiT/Iȭ6sXĿXhn Y)u^O$g{/n6$0c\q~&pi:e5LSFJ%~`8,lAb0@[NHHEqZ1eDJV XzSi=_GʒD{SUt \\MSE 35[b!{fet[3)eh3W:@<ۂPۋ0Q %Z탳D]ԗ>/ƮvQXv П]yڋs*|.S[MPX|tH0jDкh.ؙe"J NY&@TNqc1q|hkZ$n^ P߂I.1@')IzjF)4g{b}F{M>&L_\dx0| %gbcѡU D>^LGPD`Y m2Rڧ aG1U̧^srkCϖ/g.XRҹ\ub_g HXQQVQ=۠%+vȫJ@:ɅOi`lў*)}28d64NFڅ9$FEAN8kX E> #oUivl[ҠJA0* !X15&YKT{dS:hqG9T1gngٲlHT-I0֥/}[aY{i9GBƬ: ֡+Б!1;C[cUFg1O^j$C;`T5rDl q2a%ogunӺx&( dR㩈 0kw傧l!#Yxj"\dTN6,SRrmz>$kaO:͐n u~+ÜU|@.90C,Q$X%av*I Ur6[$ g&?biYAy6*z^WQҸ}žM®C=ԇpH繿z!iհ@4󁳧4jpRT?DA[j{@-l v/5/jֳWxŗ 4˃)+_TS@*К^G{Y7Wy:I.$jg,8ЇMy쭒h >F=\CoZJ:YOh"- u#oؠiaSCRR ]q^MjRiLmڗ{ⰸOUP>/ Ve8䁌OZ௱ D%G}cd.țlDHq٨&<c$ ;Zxmّꊅs_գ\VRK!6z6LS:!kHGٓ}v hP.AN{ ڨD5"]]+g+:5[|X j 0m*kX.A"j>_%ENXb|_4+V!ֳY}"<#KQ$B, L]:cD&s5>?9t]:u:\|@y$6@d=#x6d;Å=r\F/j坈3`ɗH.џ}ё[fc|P%=6+U1yt/byN#s&/Ը8tƢu"O[8<&zdX݃O'rvPLL~<v/ej4P|W,̊@- 0z ?U%M L{Ca!1Q@ G,}!DbMx阳oUBJ〒Th,__^TM^`՗( "Fpi9 >˳\ZK/ƙ.}ƎY91!Zm5.6vS>?Pġ t@]sk_ݣT5{_}LJQ/@+Mw_!,{(iՌ%=&s[f[knߪU#3tϠgX:g_x©_W_|q^1_U77!ϥK#)B>3@|ʍx9J`Vn*Sit_9N=6&rk[,Z) E6킍LFQ(@.sd}ԟS h@ . V"س}~~ZDd]a߭=}!"tVo]ImOYx}b18 KK3E[ؓ!׿o~;i8C0iBF+eQc^D&RۚHAm)|cIiеv9:Q= YL{F^c>C΅#vn`m/M-3}[7o~[H}D\>c-A$سi A ACSjw)2֍;ysoxPvp_aPpʻ闙$s &wq Lĉkͽ˯7>~xQʎS-o B.B)d%˧z :HݪF-ٷ #V(¬lhޖ*V#upA5pֹZ>3;!tCe,z>S:}v#?#z߸?e{Ʒ߿cҔês}&G wvh;fJfCPn$;Pv ^T=}mR;;k''7q,o:3AtcRUvF.]ٽ}`NoT,ӘUDG Jh l|[a+.<:BQ 6IqV}-̪slV2n^S[P.//K~ymhcIT6&@ԙX2GjU~؞~}zC{svlN+EWXBi wڸ,B:$F##kTѵaKfҜdfvdweEĈ6)ZJUUy͓Y2M2$Q'ĝ\G \4G7iFF_^az~ ScFnzk<:'I beUf-3Sjsaoɧ_ϖPo;Vܧ7Dn[sUflc>KVCnPt $yj^sj{<0+$igstl:8kH a -)W:h^Q:TSa8y;V!{ѯr ߪ;Ǹ=T;X2Uy׭D%Ӈ&0W)wNJB"~i edUbDl*k_ޚ?A7Qؔ&;|ou.{\z1$ˆTrBp,$RX74$%$_ TJl ް+l&4;{ݖ==9@>;'7)hG:0G\# 40]|%vmmQt7@E^VUapQ&?g)QL}GV@ⲵ'|SI`A'iP|,}U:7&@:q2~IҀGK{lX,d%Dm3S3 D$7!_|q-V}n&(v=S۰S@&lxɶt3+STCYfX м IzRrFx/HGVoi"OtIKO #g15=V'j 'SzuƌLX,M '`%-0/!W]idS dvYk;\OպER!?dV{[y-]alSr'4f4>g g҆_vn|Nw!cf<ۭ~m|% *1MMPS"]&kɅ[roQv.| 6p=͖uѺRL0:j`5sKWՌJJ=e!5龜Psy  nJI`tžr 4o- n꜔'gI _$" RRJ\l&?ξu;RnXf3%*ַ^ym5l6Z.G9l4i@jnI'(Q%r:Mϲ|B35"|b"ZUuꑖM``*A(yvC<8ZW ئ.MO֓d_ChS=:)KOZ}Z^c9\?vYdErK":uuzM?tv?*t(Dz;3o_W{$f^ t*Yph*0gQuU&ߴ?s20 q=<]GN_>0OX\[= ܬڴK꽒o L%NVA> 'yY$: J'ghZU>0;^L ~b!u9 ;%2ڒs{¤zK<.u0 6(TRl_[+__/WY!zԁǢ9Ӡ|FKG(Oa[ XS~*Eg_nm#SQq=QsUx._*)Bc2SʄU w >m,3K0ҭ_r6zk7Sb9CeՈOF!yVRKTa؁)Cu lF>nEM~ X= 쭤JX 2d]N ک\(^8~ COꩧErOJ,7Zπڕ?nS Z:_9АseFc}BiF|&Wzn<q Oc\R[ҵ:-7V- 'w׿>hЂ-{| 1f3|[QRxJ,ySoӸa18}π:S.g#3І=A^T)$v/3p$3HV#'tgfݾn} <ō8~' \ "&T'lћkΣ_ב$*bPu@)eK()w& ͞H[Խw?ϼsܯ^{^/+Cg xym]_Ug܁uS׫HE{nOi Uv'\ʇ*4ZMgqj,x4^5P !Xq AZlLHr>&&>򈔗txo/ xW~wF3Zgg[gH0;* 9{/R |`EYbd<ݒ^~}k7f_?o8UH@xIkK0Ȇs'X3AM/&x1# .9="o!F~~ hdW M,EOiīrWZ=sE ifYӽ `cF_h}:l:fwpP@P jvof@g6Vɽ~<'1 }D!pru&_|ye~Hh=!'}(4P%l Ŀ|`k΅C D<]Z$Yu;#6^-b{fr p0ՂSӳC-k+ twlϙn7Nw5Gtѣֈ D5#޽m7mͥF|`׶/}K[6̈$͙!X$Fb֥!绪ciDḟO7@c]QN`羡S(3[Z$'o#Ζ*5D }:Hak'ז[@b}'c@5V}}'Y( xpc$4>YKmcG>RykfȍH;D(N}hςԧl'zxNϨȩww^+ SUysէ),Pr4I:U3"*bFg傊WּT/r DdN<X0x َbTtj:} vSKZ E6or,Чíxk1 Zc{-bb8E>lFz6'pb!~z|x7xC F*ih@ݧׅ*Ж)ڍ=h4Dd~c~%@u-5~i Di`9z nCbf7 J$'DMX:Wo`nMa7 NUϴ&t| fyҷOP7S efo%e. N:- "ۢY^!#T _akh+RH:O۬$l:9>R> Io$ ]A£{AsVx.c7=+W B IUۇ&]+u鼔N&ᄕSg8)>@r0 JQTP+P{FTC:XgBVZ$9tGg`ӝy7HU=灭 iQhĶnE\1OP& At&!b.S6fJ۽Ny@SU\]̊Ng9hhF67@>dMkaܼw486IUkJT\{'liLOdщH0Ŕ^gD.[V_D`%\=EAChP;ByϤ7q7RId vz ceXCYm'G'h& `:%ZgPe*)rJӠ=쀎*p\2mz*Qy҆&1#EF}ZU3Z{kJ+m] ?Զcj0PM͍+W 6ـ≂nx,fu`8JED-FҲjq()"1CjMOu nlg'4!jK^^"Y80m?*9@+D8dg$>Rgih4b;Oyꝧ Jk毓Z,M~ ċ:FKͪ$+QߧD=4IrW `}zhjyp9Uۄ$n9%p`Z{[%yh!U ,p!72bE8T *o#WI+1͐\B9H?.lԃ?px"vrZIbua1D@d?vB'xӭAes FPӓ/R'tn4嫩X,de 3SҁS'}du#iKx9-k('4`k;*%s. $- ==[ްHM!JRN./͂%.'ݩյ^&܏G{1jy_~t W,+ Xf'd -@(hVY T 6Iy?}0bgu; NJPhd-v^ҁUU lo-HL%LS/CC U4q8ylZMz5mkBF|FA=Qiq9 E)ƅ*K,tuSOz`jj|8pp\ͦŏ}cjsB\|#dytTG0wVj^#oGrd5kT1҇@؜{CY{Q<8fC E]R[.E:.X$I>я"QU} "S2?;0ҵGqGN/i{U4{IHa!ӑMe #;[g 0&+݇?y'U$ >-.z-ty&-{itl5e4d'(wSXiE4+>g8;[7s=>6b sE!>\=;kkg}3<贈XCM;}z$ o AzjEY!C?>*qGV/xm}ꛩ<}6QJ5*j8NMXG5yOhެg'OU?ד I ,f }ϝp?s)|dGz+#h#]$5lTga= f!C:H'rؑ1mfcy8Q!F;fL3q B<PwLD\o#<Sgm"7A". iJtW{YXyqls"q{#HB+HlrK'r" żk9hkCbTҢv=ìm5_WG3mnTl )Gx}ltaD#ruTR+C5& A%{LԉDH5l|?NYa`Ї;{`l Jl?Pcl0TWₙǞhܧd =$XEIhW,&N$֖2s})_?>\&䠫TBup&=o?&Rv PSuwіђ(FJ\ T</Nr yϠc9}$(.`52crW%]{AaQRz@aQNN:Zr %Xbi֐3ff|Ѷq~7 ́ !>&6PZ Ë|$ \14۝y׭{M\v] _!dJite.!srMչWʄH@ow܆JT^5U*Q]T-;|)1 Mi.BNn[g/W=ExL~Rrir_}:!};n670ro{5oU2[ GoAnlGi( N Bp+}9 ,fظ7{/QhH[0YV`❚ep @i#]!`ںl=&X {^5TjD&8%/Z@O@lS-<φSTZG##:O:."(I#@U  AcqvݯқР(Cn ftϕQx<kЀ(A&R@Fk,=2xlH`]if '=!0]UefS;JoƮj)B|(aZOom[Ԙץ9zBעD억f7m|cck.,l]FuFPǓaHLa?"Ha_|Cvw5VB*rUS@XvMùz;j,"/|]CfBU4IPI Ne [R|$ ǿgQ) >zEWi7-ݮtڇ+5%q,N]€Blmtr`'b.g(̇[kyRsLUKBOP\bX'iu_ ײI?rʹ=dM*vL.T&8,2b% yG(3_mّ_r5<ǍFonq!DÍ W6~<^GD& ;DZkn;[bPzzW"1w@TF-Ί9| Jc B#kSUOՌ3s?,?eӂ&], H@옂oN>+dk1B~w(iySܶ1DJ%S6&EoXLT;Fj7"(bBiHQP%F61dVY'?Mgk* KB(NY0! t0bцʔo\>ɴ^c^8}!%{a9 P P:XA bzg`@fÓQy 蕐e.hr#KHuIENDB`PK!vCa :word/settings.xml[[o#~/`yq^NЗ`,mu%0f[d{Xl`y!yxn6w_ s ;?뷋a_zS]va_}jO?.avWC ~K0n/7qw6nZݮ֫å`̜?u3\?۫..68쇻inr5ݭN-Ư$M#^dnmFéwm6{9sonEߓ6듀ꋎ~+jǒYZݎxilW?o]WtH-9 W~\mȧ;j[wbx{?C)k]^;msOOwz)Y4ÇC=)rN/[Lx4Z8O-?S(ɈO-13z> G1m!|ce?q\}iEX/?OЍ_䣦w?: eJ5Lg2&"D84k.`0ǑB@QJ9h+G,R@İ9D,ɥ?C 1>AEuXeKildSe2va^q {ba #)Wq"mQ6_l\$ 6@DwX %P*k\qoĆmʍK`ύcOs{JF7kM> ѦBJĺeosh\Ef)xaﭢ&lj]L5*8yhhAr jG(Y# Ş( VgJ 7al0NA T3aޒHhh'# 3^DЖa%3 h|)V4)D*۰iC@dp9pY硵%%_Tr+LTbD l\VGl)1Kए N- K kj,3l@F[Duq*Uf 򩪱(#ȑd1 gY,% TZ ڊ)3ħL$D(7jn|\&YܒR #KIm*oJZ0D 0*9òiU0S %-gA<Wcټ{U`Ec5 aFU pUAXhý%% hg1B ò%[qlLE!*"$"HecTiF+;?%Rp.vpQy̕]3hu)d9?f(DTRԵg3Hx)*'j x7+FzQBjh9oEg9joa`<DO`R{簵 k'01wAq) #Y0.xMClTJ5ZU,p8S\Vh@3MgۄmTKh]A `Pł`3 D;\;c x'$y+`; !`VehcY,lI4PB"8 rCdmh}lq>Ɯ"r8' (L¼*JeXԂS8  QVh(%@-c!D&H>47-% aȊq%H*H ۴,Ƣĺ.]43([5+ ^ %^$ B,1?sЦI)-48hk" $MlȊ6t%LCoj:) CUJ9S'>cĪ WɫwJ-yZ #ZcF" 9E1SMiÈe(ɢ$E6vRa=ΖJsHfbf棙\3)Be)dRgw4"d^WSY݈l7TёʶuRji:f'S5`+8*8|?*nCa96Q7!! 9[NA\ FVNp,Av.\`8fZ51WT)\9|pcI~aVxGPE`ފ3C½I]=xwWRhє߰Z3|]*8++*gJߑ!DլP`-6D.XQd!XKiPĈIx,ZJ﮴j-QHHƻyo T&+^9rUęoאj% [L U- hMj99:ROxwJj8נ>#R4<&iyLZ5`-4fZ$-9F;2#כlsl^y]o܎oj{oa?FnoOo9|n>]w?=5ԏ?ݏe2 IksNVͩն?|=ny7WCg?Oa]z?9_wK{~}^?L|n6_n|{^xlm"5/W~Zn/܎ðOޝݧ=,,tD4>g_-V76/8j?naq5#:zљŋgX1-+\(cąҾ^DUo.(rO{ PK!/word/styles.xml]w6~si!Ml'N2iOĝٝ$>c,'t0L/\ɦ$}߽WB?~F!/FFѧK3?^艤߾|fOI N_mC^wtG&[?í|Y 0{:F&B70 W4oI rD.-=dKh@46x[?K1چABSɾ;#[ġ#6Np`zs_E9yKlCNWd,eM"gI,_iwy96^_i8ʯ?.W/^sdfyG?M&řkD\94WZ#?9deĿJw#^B^Hn\ 4 -ONg=gTVĿ%! =o#W- >m_$!Mrc˓dk+?5ğR+OtOOt}5 ;fgg"}XU΋K%tb7nB &DVo U*:~N"QsUt\qoYQWሰڅcF48_B\c48;FdO ގ=Fv v#nwv;zvka乛A{ֻ;f2biѭ3L_nx'^:Z` #R> MVOnn"d⭿݉Ic̆8/~u!WNuLY6LH0<Խ?./n47|̇f:[."?MC-TkrG`4oe9sx,|ތ^˞o̻}(WUQg"aPxEWYmP0lڿ0ZLVgIX笻d5K28yCeyB 7U\uâ}뒸`:vfJ9UI)gN@гf6SPƞ1Bc^#?n y-02Pzaš zh!Vj"XI `쥆PRC(;Zj"`VR{!Nj8aX!V^je-5h!Vj"XI `쥆PRC(;Av"`X!^je-5jg5Q +q0 n@V ₳R"[RJ[fK e*4eKhfhF@i kB+l-餶wT3Vj\d-J˖ZeKfqْNj\>8eKR㲥VqْYj\-eK:F{qRԸl,5.[I˖tR%Ըl(5.[j-J˖R%ԸlI'5.[I˖R㲥VqRԆlͿ8{dцx[f]~҆f-ǃi$39yhOfKqA s@As@~ d$dSK77֏W8x8Z)ʷ8)4;okA*uG~x}+?%Li@l^9^V/Y< Z{7R%TRQM&QF_vaj|btgj?g4ryPNʐj7тT &c-aQ\<5,IV@zMC/^v'wᖤ{}[?W()\a7Oepa+:ƫ"C1@q3rR"}2k 3My[@wfU3rU|r7;c36yYLM "73 i 2 %b`1r|ƐD?n:i+˷7X^pLY bɽzn2)gX+y S*f?i: ^ &wt h  84r1e~|POQqmbq94ÙѤs"Avxj){F1z8S/oQ]`&۸ϧNjـ咏olm/szCůW`DTDKȖ7*נmzǓi:zeMI~=kע33723ocX0s9,29{ g50=,qj .pk&Ccqˢ%K$ՍL6\aɚ$[?V*Yn/4P0r}REbAF>R類 Ӣj66rY=ǧ#9\eGbeߢj7:R!tzϋCf\-H S*&GFF +4O3_.&Slپ&27h\ y"5ĺl(n;5Sigz3BAux%$<*^-2;LeUWU9pݕU:2Cy/쾻Lw/JPK!dfMword/numbering.xml\nFwO1Y$RmW6U1ۣloz^]+ta0ĎDZqN>8L޽ $ Hѯ5^WKRϽ ph^QF򡺍\eI$v\oD֢ͅbڹH,#ZP'j[h & ؔ!w(?u_UCwhkvͱEl@ƺq`|RpϏ[Ե0Ō:.T)< =wnM \lf<7/O#;5t{XbVNryii|Zy1/qDY@=(=v[+74x$%~\|E FƋ #¬cp;0]c'\)70xxz4M8#n'6ց;5L& 22>G4,g ia~.}E>8ly ceƪ`Nm#z{4E!t ںS4M~lԅ9\xAbp[wrG2lQ1wjjZhvو=LFM1 -k } VbusP3Ϗ7[pf|Uۚo2@F;3@4q)EA RC3hNFš{g[sGш3|gw2LeJt4,e ?=Ԋ.f8*Y6[Lhv.˴Ecܙ.(ER4K,EͯqR4K.hnq#Jh,͉>МɔhZ_v)DtM$X._c,wh+O2?fµJԡg&X7Q-GWh aȻMH1 wIߚr&w4]s$kuY;Pi5eM2kGCVGDRb @V5^R<.CV5M2xX+6j6k֛dHYbͰ͚&R<ޖX3 FjI%,]#5|'<5~'`0~^j[Hs]}Q+kB͵;!Oh'^r> YnxQ4rD32{YSE9eqȽicӌ#׾ei{`h7MxhഌN3?TPK!t?9z(customXml/_rels/item1.xml.rels (ϱ0 hoPK)t;JGILcXji߾+t(QE]1hjP >N~j.G{J D60o,W0H9X)ctl'_uݓ|P=;6w#w Ev d*yB1ߪ kPK!bU(customXml/itemProps1.xml $( Ok0 ~{M)Ac]]GI lgl}9w=!fd&+ [*j<%|#Y` jA@/ rUfm^>gIޔ$Er*٩)b57008j@#&qؑ32DzN]Im4jxfF<[D/媯i^Wj7PK!\(customXml/item1.xml $( I /-JN-VNIM.IM .IUq pԋQR %bJ 9yVIJ%%Vzy@ (]??--39%?475DL?)3)'3?( jUч{Ǝ PK!|qdocProps/core.xml (|KK1a~&I_0MJX(ZQ܅ N$̴3Z\s?NNRLLfhFPFXz^%!r#yi ۛB\X o $Ʉ\1r؀!Wk_c'_2":jk*N}Lck֟>,gS2ywSW^X_dPK!}_\C>word/fontTable.xmlܗo0?D87*(-a XwiMڥ Rlh!4 y?y`E v]:b@~<4\G%p$8iWDoMZr`>W-QĭRI#°10 prXbX~;`1NhF4*ܙDE! ȑƌ/IjDcM6Q9RgY=)x!F)]lEF {h!P-&Xz7B~a%3Τ1.\DXs8jG *O/ FX*UȆChtFHL` l\!DǪ{=F[@;N՜EґSifFg~ ܳddKJsJ&9,@/BT6MTQ#ScuQp?ʇ*H :p0km39n: !GZMdGWRƊ t-ƔB%%рc8AA%ZgV.Lx}o@/q,֦C c"jC@Ygʓ?XO9/h,rQOdooL98_i>PK!SdocProps/app.xml (Sn0 ?7rMEE`a[mϚL;dIT׏YwO#GV%8/ޤY&n6cj&>p]qe4l}DXpAOBMz -3,kƵ<`bZ ҂$ϲk]AueGt`\wI+#>T,1ZBk~?լ2dDiiWlXs x6dqgy;.N-EQP2A蝵J pxS䡗DJ-rd8iJI\ !sqQc*ǜWA+x4ye؅u"xm'ǷI;$!چRcއӶi,qCp'/'!v>krբYoMk>Z@%;/־գ-.ۄ/fz6oT< T瞏uOóf,ï_327PK-!Wٓ[Content_Types].xmlPK-!N _rels/.relsPK-!4 IDCword/_rels/document.xml.relsPK-!&u wword/document.xmlPK- !xoword/media/image27.pngPK- !g:word/media/image18.pngPK- !Wword/media/image17.pngPK- !qk==Eword/media/image16.pngPK- !a8::word/media/image15.pngPK- !R$word/media/image14.pngPK- !u)qqword/media/image19.pngPK- !DD1word/media/image20.jpgPK- !hށ88Hword/media/image21.jpgPK- ! JV2f%f%m\word/media/image26.pngPK- !1>_..word/media/image25.pngPK- !W/eeword/media/image24.pngPK- !Jword/media/image23.jpgPK- !aword/media/image22.jpgPK- !?)2)2rword/media/image28.jpgPK- !@9; ; $word/media/image13.pngPK- !A4 word/media/image11.pngPK- !]ffword/media/image3.jpgPK- !SԒ@@D word/media/image2.pngPK- !/44n word/media/image1.pngPK-!0C) word/theme/theme1.xmlPK- !ܥ  word/media/image12.pngPK- !Y word/media/image4.jpegPK- !j=d,-,- word/media/image6.pngPK- !Y3`EE word/media/image10.pngPK- !=`_@_@ word/media/image5.pngPK- !XDS# word/media/image9.pngPK- !ri3word/media/image7.pngPK- !.tv88?word/media/image8.pngPK-!vCa :word/settings.xmlPK-!/:#word/styles.xmlPK-!dfM4word/numbering.xmlPK-!t?9z(:customXml/_rels/item1.xml.relsPK-!bU<customXml/itemProps1.xmlPK-!\>customXml/item1.xmlPK-!|q>docProps/core.xmlPK-!}_\C>Aword/fontTable.xmlPK-!Eword/webSettings.xmlPK-!SGFdocProps/app.xmlPK++< yIanbox-0.0~git20191115/external/glm/doc/glm.pdf000066400000000000000000047741471356361734700206750ustar00rootroot00000000000000%PDF-1.5 % 1 0 obj <>>> endobj 2 0 obj <> endobj 3 0 obj <>/Font<>/XObject<>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/Annots[ 11 0 R] /MediaBox[ 0 0 595.32 841.92] /Contents 4 0 R/Group<>/Tabs/S/StructParents 0>> endobj 4 0 obj <> stream xW]O1|?B-"*Zڇ !$4qW.!/H8̮3^7q|<\ yr"N&b|qk,XH H+6?* q~=WBTn!Oe1B1O~$mK3Oe!%(_ײ8!]!$hʀ DDt1B4DE 4s*L"ZG#1rdŨd(UbA $J i,mEF[׳GU{BBTc(T@wsD5mg): .Aa5ߤ/D2ҕCKwG<::VDP]joCk~~GZJUT/Sv4j_١5S:S[ky2zM&)lpGz2Io;H )hzi^6HvLoj}xǗOŜz j`舝:0Ҁ*->? endstream endobj 5 0 obj <> endobj 6 0 obj <> endobj 7 0 obj <> endobj 8 0 obj <> endobj 9 0 obj <> endobj 10 0 obj <> endobj 11 0 obj <>/F 4/A<>/StructParent 6>> endobj 12 0 obj <> stream xw|X[[Q^.[m}Z->֚ ao{aC aLwr繾 Iu>?}:3 B!B!B!B!B!B!B!B!B!B!B!B!B!B!B!B!B!B!B!B!B!B,&@]ql/7P:Ǿy3aؓ0NjMK)먃oG;O[^a]dY>b_ԗ2YSxر}PJ! @S=jKQyTeNaҋ~=M6D #~tܑ#=MFJU+G3}BHУ{bu dn\(] ~F#:ǁe;yB9Nc5v=5q;9{qp:1ժB/\ߕ}r^9E!j9S#Wk3e)@٬DĎ7}#P{Ba5E؝%c̳uºub5N>1!tjIpycrP{xA ʭrAu&`ET olMZ AQwEKٌqVԕrRL:ѱ9Qv+Ǧ\+$ɛU̖I1aƠ[xbf"=)򞐢*"Lz0]b ~v` ^{*rb{cKO/e4-O`~< kQysaB<ĉU{0?wx)JB;5.rWI6B&UG%iO#(M115Wq' ǀ[6E}]t8I҄__d vi. IruBCiMp5>Rs$.|3%ܨ+!W7I؋$EVoK6Km.sk$W 'ȥfr»"0!HSSѽwE]` ! －IܨrUfE\Ƃ(taB`fw 5I,ey,n<ߧ*~q!ːŨo פQ]؂ua?6*oBRPţY؁߇cc_Fn[Okm,9-/SX%$^w<"BCKI'OVDwd$=]j/F_ރm2>'KCŠ=ѴSS"fX/Th b\BT+ʨs*+xRڼ`Lut;٘.RQSV(BDoeOS< ;OY}[:K}/Œ07 0 Wz]9`G".#翛 }~` A\=1`TS:u!Ttx-*0TST W%I7o~]1YJ`sf[W漋sRu"D=?5MqkWaٿPSț„667J漃XQ1퉴,sO6*gލBiH}w+y1k*yґ濧i-[FH˱y+"M~i/:Z:nVsImMFIVBImu»by\7ʾҺfI݂6:q"Lb$4թU"W7Cb H)\'5J _JX *T$Bta,FPc[Y«\'igă(ʯ8cX!a+/K1Ϣ0S.SԕI_!rAxEǠ_BXMv ˄6qdvGcrY%D}A9 PM( J$8 )ra/Nqu@H+c,( 2ݜ, _T5 {"~տ3Zuz,b/VD^i}$'!h;@g)*auE.a<4Tb{뽶k%SBPSlCMuXбw?a3U8RDRԅtZ}$# Յ2'\zʸU8gVIYv/' 1 )nڵvey;( La4|UuFg S_FX׶~{$̣[[T]ޘQXEdc?ߢ3}4 qW7&kc;Oy okQ#7{߉UxzܘXj7ܠ:$wW[T&Xk+~_־o{мuU$^j=]i &XGx7b E[J"dsiÒOhj6 U#M-F2Chb Xۏ魬6f8[D_}Q=ogXJJ/O|ڠzChWs}}=gɣQkrfj hD'5l[ q`k9I7!{),B40Zٚ™J}3TG@5ugTN9ttHgա%L&oL~t$݀+T8yh5}[aF;Ruh i T Lڦ,nSYnRZA%u䎖Z 'X@${7,hw䜕0HC^9YQ3^[*U0ײXܶ\?**!mAJy!jwO Bߌqxҭ&^uD i_߂;F9_dTn[Ј}n迶"TޏY³X$ZK؝'}Ѩ#B6|XɿwhĐ;[FAXcAT܀?Qo^NWh'YS"ĉ*;'.QKъ&WKBBUBS$$ǮP9ZiFvձ$_Bl8 oU_Ax迄ICF?޿"!f@%6~d,-̹J{ժI @;[9TW q_B졮cSbU·PMu 1/!6aU_XЩQ: ]-p(72'*rIFb5&<Ȝrٙ/!ɋx\y֧T?B,KKFD҄/!o72)S:#J迄XG*TogNӴUGb|aP%ěrS^^5U\fM\0j]ԗ_+ `lTRbkBE. 2dOǖd 4Z)Ȟpt#pgZdMAY^xQ^ŕb/FXpgjվC?ܕI4 3xS~kU4C;cؽ:J.vm Cz Rnȇ114T/6ij [}8,V9b#ZM}q!BK@x7 ~_cּ&y{zŎq?mB v>} TGES,ǥ>6KS4M4;xMf6]_!K*F g+D02~:NӶTa#9Kd=EEGe7 [.޹,+/ž@EQ>҈@uhFm f ѽ79:"nZfUG1-DP_(e@Nd#VRnV,wdW?\Iש#4yԕzIˠY-oS ^}mS'v%,8B$9q1$f<;& ڦN)D JxUu$ffM꫚:K3_gʷANT|n2TXZ]kksyoklf(a] U49TxwT:]1?FMdq5 ˩ߑTJkV[R0r.CX6 Ulv_;ZDN$ݤpF?# YJ윂X}OK<Ҡ!+߳ƫG2k20}xU@&;/2wnE]wVX[!/#~̣GCb'Ȯ\ΜG};1BZD_9QOq!X cdwSogNԘgPhSx/!{C5@ q=0^P<*U1/!'@X`{C5YI>@ 5gF\z\b"_B,P %u52vE |.hE^Tǒ8R` @tQ[#|ghևUh'd HѺ_9|Eۛ@:N[$)-xd#hju?SHG5qLF$ޠ޿\ȖT' >)BBCfQ5W]4}=hmX-9˱迍>ITcH3D(/9=d$15iZꈒ`,{ZWl<p`bk]ŪB_}7QhgG7ь u;c0!D0U]ˤ- $i|%4>"J}fЦ)*d BEKM≽U2iY++sA]RR\nR3؝:$ ѷN~*yHв5dB;c4_6 |혠:c"7/_c\"NZ$ݨqQM.ڄP>+BdM|*]??#R#~c{U8ۀx>`œ36cpmp\U0 ]D?\Y%5cvJݖXfr[xH.AtF4 =KkʻWj5CΜpқG]=h]P[1vYa~Jq}")|ܪɱ b'vVe 낵 >л[S %f4e *;~ݪ#FHClthц[S$Jh4{rG㈹}9Q+\JN~΅(P׈wP*=Oa&f0 yH\J}ݑ5W8FqX> ޓ*3_?W/K 7<1ZiG2s"{(8 >8gB_uo *m{N2JM1F<>ՠ۰s\)CƹΘ2[)ʔGwP VuKP+voa4GpKlH޵tq~`ӄ_H}U#N ;'2H6sޖ}O g.7#wYQxw|D2RWG!OfME}%w;!kѲ5Hh[CY'q*H_ ATO  ?̄li8usrrg6ʩKI/P:GeDŽ Zl7iy)ayCKVs_GֶZA(Q,sQ%`M?Gb 31k~CNYrhSyS- sPS|;?Ѧ^Ax;0PVHs)/!{:U7B_#J˧*XƋh4/KRaIQ0nJX)WqRVeuKҴ{6[m L 9\7vMaMrMF7TWvNĺQZ[FsuJlnq m{72vrtmKs\'@qrYj#/4.{wj%>׊&B?1].7&u*ihVO--hbۤC{T_'[P^`OFn)('qm5AmG_dS̡B߿ "6"[MJmYٍkc iO'QըkHW+"}<$WR'{W<+ 7&=j_$ne./^ʊwQqmor zX-g?^ɺ 'veÜuzf%ǥo//Ur? MC K'3?:{~Xb⸛ߪ_^U#3[ pn"YWT7ucL_g+ Y1΁6U,%`] endstream endobj 13 0 obj <> stream JFIF``:ExifMM*QQQC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222PP" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?Ox IO;I|tȯ>>8m-d1}j/V;| wRYGWcG%ce 1|mD^9\d@'O󯖜.q׮xSVZUlbԥXR&Co]F=Hn$pqk-BΒLk*UKd cƪ|5zpe ;NlE6ynnev0V<ڷ/;$._9'dz m-g+`w5Cjn>~/4eg` %yq]wim+rF9Zw6֒B[̥$CY q-#̶r71|Hc%ՙz7kPb4k?ּ%S;G^S8|c8 c>U} qVH㜚t#~Z$XSsom>r;4BҖTsP\I%>P'URL\Ə/|gB8v' oy8yÏ _\jG1[cf 5ti= ycNH[=Cיox~-I_,>/Font<>/XObject<>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 15 0 R/Group<>/Tabs/S/StructParents 1>> endobj 15 0 obj <> stream xYmoH)O*to~YV" ߑs@29ʿߪnc4Ì]]/OU?Uno. 28Lt؜`qz҉N̸ tAu Y,TixrzIp #`pz5>G4QGב gQ:y .6 /Wް|G<6s[xSw]>y JRL-oQ`ӓă1@X7 vP>%N%xS@,.ѭWܕ#- ^1Hm hIof,۲WpY+d2='!Rٙ-#T<*Wx.<ƂjrW˔%(c:_X|A,kbeRv|Ʉemߗ9bdi~)B'Ϗѧb~VKo4[a1$6D2r sVҽ޿ Mj xT,9.v*&\{dϬM5OfX:i)lrD{HEk r -iT>IF&.2XҒ+ h6 mѲGO%.XG~Yjy.FI[ł uPIh]rdGtx.uiUEM "GeRR6H+)-ūizbQD,Nڲͽ67w;,fnPip/H2\Ơ,NIrrg.5*y|A䅲-ǃ$ +Qo9vߓI#9s2QGy[2)a 4j%bx8J1XӍQy H[ 72\~m.[/Ջn Ȯ(}Cb혼KRޖ}qݖcɝ.M43w ⢚|j5niK|8k" 9u\V<"(C[XW@s˶C:rJYgKMsTEKn|5J(0li͖vV5C]ch21흇;JPČIVI)/뜚uS\C+KC'.5JѷrfPD߬4_i o=ؐ&Qz8Xyٟ8ݲsδ+VOD  ͵G ^fZM`L:)h,ݐ2[p]Yw 9s^· wk;j'%ykة:Bf üµ;-x =3dG 2S&򶹃e["f"uvfksw3/??Ex7 .Ww% kbz=ht6 d֎F9<,nHUH6ƽ ~N XcgH oMoONJ)Z O| ; lXv$L=T=("4nHXPT)`EOFtIA;a蛎Ͼ6E0 >s7ߑ8.X^ xtfw1 P\}Gxx[''/`7 d؇+*#pvn4%tXm2Sg#cv@8Ї)i¤֎ƆޟhĦ-;Xe=w@fyےDFpߙ'62Bm=bhsٽi ؘ鼭G;0^FjyMA)m?H7!NTJL<KҶ ^D$o:n ~[#T3Wb{"u~q"8(/Dq@y>\Ag#> stream JFIF XICC_PROFILE HLinomntrRGB XYZ  1acspMSFTIEC sRGB-HP cprtP3desclwtptbkptrXYZgXYZ,bXYZ@dmndTpdmddvuedLview$lumimeas $tech0 rTRC< gTRC< bTRC< textCopyright (c) 1998 Hewlett-Packard CompanydescsRGB IEC61966-2.1sRGB IEC61966-2.1XYZ QXYZ XYZ o8XYZ bXYZ $descIEC http://www.iec.chIEC http://www.iec.chdesc.IEC 61966-2.1 Default RGB colour space - sRGB.IEC 61966-2.1 Default RGB colour space - sRGBdesc,Reference Viewing Condition in IEC61966-2.1,Reference Viewing Condition in IEC61966-2.1view_. \XYZ L VPWmeassig CRT curv #(-27;@EJOTY^chmrw| %+28>ELRY`gnu| &/8AKT]gqz !-8COZfr~ -;HUcq~ +:IXgw'7HYj{+=Oat 2FZn  % : O d y  ' = T j " 9 Q i  * C \ u & @ Z t .Id %A^z &Ca~1Om&Ed#Cc'Ij4Vx&IlAe@e Ek*Qw;c*R{Gp@j>i  A l !!H!u!!!"'"U"""# #8#f###$$M$|$$% %8%h%%%&'&W&&&''I'z''( (?(q(())8)k))**5*h**++6+i++,,9,n,,- -A-v--..L.../$/Z///050l0011J1112*2c223 3F3334+4e4455M555676r667$7`7788P8899B999:6:t::;-;k;;<' >`>>?!?a??@#@d@@A)AjAAB0BrBBC:C}CDDGDDEEUEEF"FgFFG5G{GHHKHHIIcIIJ7J}JK KSKKL*LrLMMJMMN%NnNOOIOOP'PqPQQPQQR1R|RSS_SSTBTTU(UuUVV\VVWDWWX/X}XYYiYZZVZZ[E[[\5\\]']x]^^l^__a_``W``aOaabIbbcCccd@dde=eef=ffg=ggh?hhiCiijHjjkOkklWlmm`mnnknooxop+ppq:qqrKrss]sttptu(uuv>vvwVwxxnxy*yyzFz{{c{|!||}A}~~b~#G k͂0WGrׇ;iΉ3dʋ0cʍ1fΏ6n֑?zM _ɖ4 uL$h՛BdҞ@iءG&vVǥ8nRĩ7u\ЭD-u`ֲK³8%yhYѹJº;.! zpg_XQKFAǿ=ȼ:ɹ8ʷ6˶5̵5͵6ζ7ϸ9к<Ѿ?DINU\dlvۀ܊ݖޢ)߯6DScs 2F[p(@Xr4Pm8Ww)KmExifMM* z(12iCanonCanon EOS 450DAdobe Photoshop Lightroom2011:06:22 23:20:02 "'02210 DL T\d  l6363ܠt|@2011:06:21 19:13:502011:06:21 19:13:50 $UU5GBhttp://ns.adobe.com/xap/1.0/ 239 85/1 85/1 0/0 0/0 0 EF85mm f/1.2L II USM 0/1 1.0.9 1430307632 2011-06-21T19:13:50 2011-06-22T23:20:02 Adobe Photoshop Lightroom 2011-06-21T19:13:50 C    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?w5h!RGNDl ltryzVtiqV"NկjBTsH29Iez-dV\u9"湙vIꜗ ,UZӥrٹzo*K;FދP6Z.Xic>h?*\njEl7<(' ޙ83ڠW#hPTRH+\ӯ"U9EsՅR71掫ӕ*׋ӹԅ8 m828SE8`8Sf4 4fњquI7W87 -F[NUKẈ̠W-o-U]2ԄŪ3KC@%0ө 4O&iayiQ.&3RJM-%Ҹ 4N4Pi )@ 4 ;LC&h1 zMM&h٣"2)5&% )(0m0M44s@f4ffi斓4BJZiZ1@H))qJ)iQf """ N"PbRӀx&*lRd8*Ls@QM @JT*E zE1G"Ա-LZ+62t֠ZMC(jU55 4Xx5HPO斘ih44 \A5HCZM0ijijq5cHZf!婤E7Ӱf{@.EGX 3J[wR(j]h@Pfw0%F4nRnn?4f\G\IIIKMM0y, %)bii"")TN" JZ1Kb b )h3KLQHMSM)i5*!444 &j ښiT!))h !Sj EZZm0Q7ckZǵ:TVs*nE+mJžjkJLsd edyӕZ62ip8_ORgYЅvoZUp*mIڽ!0sG5J`)KCH{(湋wJ}V?)nkCø rqWa^YyʿA]e2ŨhvG}9k-qZihM*+npTJoRpگB أ1s$gqHsUx52jyٗUJFj8FT|@KtFI| {Zp^+_S#MRPW3)=X~ҊgEEKkE\qZ(DTp*c7IEh&&yKQ3&jh[Z'h`+ WEbMJqHlxj?0SY1qcd5NJڠnM|fxsV5Vܦ{T&+Doó?a=*qUJ3CP)}iq\"R~)1Hc 0Ԇi1HcFi5iF&i)) ZJJ3@ IFi(hQ@J IE!4mOh$3IIE4@4iyf4QLLњfhP3EF :\ihfޝ@L@Z`&(-.)Q~( #"b# K~)q@bd$Rb*)1Lp p p)H) SE=i" `Q"ԫҢZT1 x=i S0S xp4(@@3Fi4I&Zj2hfRY&+501Z^[ޚM01-IZ`KPyK $34FM74٤%%4LDh4;4i3@Cpzpjvd5;5\5H4g8i4h3Hi3NM&yRnI,ɤ34f~h4Ph e8cڒ@œ))j@(CE4M4iO4N##iL4ЙtZz"@4)Bi4f)*JCA4j44 @574@q3t[ c]O8z61sjN ̫nYe@8W |IY5d\/JunZqݞ +9+b[aJէC FU]j&o.*cGpVsaN߷ZqG'@kF* sU]I!8}5(:j*|ҲգjjkR5Fp s=70 d 8oIVk̞=J T_zA$ e,υjԏډGzrgBj>UWimqU4TTTTy'!j?,&z֠N!_J=*AL: eNjw}iջvMBZD=*QnqXA5dD1ID4Y͎Cx+&K"r{,. kA*Blu!e$nqW#B5 Pʞ]Uw5-EV s֭uTJPIҬvzqQMjeKj1*=+F+& W;J63 +ƛ^C< &ĤhQN\њ`4₇fI@4?4f֏Ɛ4is@ML&I@M!& 4JIm x8M(=i( IKEiO"Qv(1H: N `.9 JuhE%-)Pi)(i恎Wy#qZ0ɁIJq#u N#\c7t0:W5Ng]9Ijy#ϐy')Il1M 4ըSJps8!nq*u+(J4V~HҔݑ13MWNwi3I&MԄHM4bs!4IIFh IE4` mEQK,RRLR❊1LB Z1F(bQ@ӁKIL.iRLњniiњMԀPj Ԡ٥G7PL!48L 4I\t14њJ <((4jiɳFj0iwT.ii1`5?5jpjC& B ;u %.=hNrbMKe`ZM7u&jRiM4i4@M:hӚu4hp u4RӁRC$8pcNpbE%!75Bө)E-%Up4\JL@Ӎ4ƦsTfm>bPhP(E 8@f(4K3QFiXd4FiXCM'ni !jfiI &ԤIa4iZ&0 4b`M%%&i\HM!4;4f\▘ .M1Yj&X^;UsQJ(9jI4&ϽE7P;nuCur]nwQ\&uKuE7Qazf3EvsIM.y¸M;4sFhNBEbpPQFi(RQ(鴴:m.hQE%! %-4Li)D5K3Lc3IBiKI3Q4j i2\҃Q5#%57RmԹwR_u85KiZު`,oX.O}Eu)57P1&3@ Fi(4 3M&LMHwRnbRf4J;K@%-6) u8Sihj:pdK@Ĥ%D4UQIE1 Zm]4! 4)I5B@y`6()P; - )iE4S@44fMԬɦM&)4i S Q`Bi3@jԄDHh4L@M4 L@M74M2GhPS:b) Yliq7,OO8\L\RCoCA.*_8 OCQጜF3uu ȼW#LD5mB*RQٛIkJPԭ6jnC_A)}"9t}v?3Q\8++1Uv43Q3sEk`Z7ÎMcɭG*jV,@ krQ 5H5~ k T5&HXuHUZq5j=U[]FG],Je둀qX݈+EA6 SvRm-k 8OF]YV. HN{I߳cwf%gZghrV>\?teRWA < |޽55̂~#Xzdps[=I7t˶>Nkv|v 1tp›H<\Z녫]8 O2S9$Ub/L8&|£Rҳ'[E#Seg;44jH55))n*5 ŗHؤJRjC' T'MX4 mr*9<Ա ȮIIlGJhkiFkUKh=)գx5_Wt9lY[9cQ+4rU# FjթS*85Λ<م:N ))iqH Z(IK@-%ii@ 4O4Lim6@J@8ReL&iM&4sHM74f.xRҸR ZZJ))3Ii&ũI%F4h@}bC$(5iA\`H 8j0iAPiBx<@?4j0i٤Hib) x55 5#%hP1E(OHci1R*(Iy.)iqE@)SqR cPE?P2)1R@QO"@2) !A!iM0hLRi!5B4fBH[iJ 2 0KM0GzQ@ )SEiL+>QkXttNT& Zi@v $U{nkR @1NZREӔsx1W#4dW=5U%dP]=[+hʃE4ԯ1Ðuُ?F'ؗQ5-9JzKll [s_(Z]T&WWEPSk{hd$Q޵{,hpk5Ǔr!$5kƚZ1"$bzRKnby53^<۩.cOr8&"|Mȩc)ŨªGIuO\wv4͔:x=SZ桹>~zꄉG0#XYa?^`{H d˕DEF-Hу޶f'R{}{ u6x&+(2Iܰ&F٩X]ir6Guqۙvb~C6?MMzQ¾C~Grjk[ޔjW :ެVD3:dz;uJ,0h8Q>ZRi#qH'r,lWG"=h#ZKEy)ly)lR<zU:2CtfRW%ec;f@-&i3M&OZByH4f4vLRf4IJ(!i)h \SF) mbRS !SiN֞i!4i6IiE1LsK\Ԉ4KI҃M4 &SS%WSL OԂu-6*Xœ(*ZSC%)SO  p xiE%/A@-&)qE8 c-`7b)q@ .E ڤd[xM"c*v " a9Znʤ+L"+L"1L5)BIZJ IIE18SiA*1R-K 4LRCH))&)1N mHi "jCL4Іi4Q5R֨R%j3N4TITf4L#F)Ɣ  b1J6v("KJ(%pf}-2AGTL0}+M)NM.xR#3+楌ŀSZ؁-r$OZCVFTkƕ`GP憌fVGjqU56-VuZӜVeJo$ fZp[ Uo.64}6<։ϡv[m'kEJ7>knp)לVS$kzrz+U.;'ԗq=r5 p)u4@fx"/P ;NNXî_cd#Q#E\2?sƜ&{քSZǍzؘ cf)3{$nj2bhކ_zсXZҶEqUn#5q[fjC 3&\TijO$gM+欺nOS8S\ùInbڰM aUKak*K?H#P˧J\S E6+]x#TJ2AFͅvgC|5o'{Mh]q[q )6b\Sv/x:dUY+,D>6օ,HBV>X䊚(0+SќvY`qZ V'uVJHsD a7zt"ѴE׊kJ849uGgtABiHMpX4i3Eq4i3HMsIi4 搵ݩ3M- KL @--wIJ) ICi1M"ySHi"#Q`7S)KE%P%4Kj<Ӆ&jUZ5 5MfH)Sc xR -S QOZe<h 4 E&ihNQJZ)q@@PqI~(dRb!DiTS%{HH0  "Tl*$$Rb" "IM5HS&9H)K2Pj@}iFPbJ D 1Z`Kړ4M5%1l*V4&BaVc 00$ayLCiE C ()SQ@SȦ`64Ozc%D H:P4ENE@PJxAr1jdV{K Tll!+-o*Qw%+dO,@*CV`í hŰYݕ ] s\ӑV-J ;0£F:VU8ɫhiQZʹ^+n`f'գiۃ{ǭiܿj`dlӥlDF01ZmcR-)7 sM2DbxJPiFOJUB2ǎH7+ X֧TVGnڳJRz#ZT1Wa'[K vᄓ7LkH*mѨ\=zT(rUY Su>;eGF.X7\z-k9I38wcRZMcTqLJG-zvE :T- Vqڴ)2p3Z#]T ,r| ԃ*@U*ұeo#qLV⣒L Q^eCߚ3x5Ƴ *qATt)T,HfS> M}@qۭe>9)FNb<`Sla'=JXF+癋u)ùMjA'Ux4 th9(lpEEFvZiW dzިU{3 3 ThY:kTSZt]$ z$q9V\P:;(kzK޺Ck/wPYqPg'PjGI{քs W/muZq`uPV͓0Wk=F:GzEA$&suv5sumI9fPNv*j)g=Elw5Ny8XKVhtk+dU{ŘUg<֋DDc,ogIq5jݷV|撅w$ªN ]UȨq.瓊iI|UwḻLUJkGj~V$3IJA5 ( KIFiXRR)iXCS)sJH)E0uHQIE QH;bLTSqR3 ~)!)1MӈBQGzZ`%()R xORM֡z4SKOơ(4j!OZ2PiiH8m%0$ D 8`L 8p4N)! SHZp5j]%.j<)sHcN4HM&xiIBiiayLȦHZ`@E4UaO4Wpi)M6QHf\Ԕf@i40zpzz\,n5viIIM0bidiM44dTimir)-RJI d|T\҂l*ɐaMP4TO>xNJܞGQ @5 ZyhVrNLI:7^qQ9ܝW@IJDǃwj=xgM&!Q==Kpkvg3dɪqnj]j`oNL㩦I&;Ng[sXԲ! k?5VvT(hVֲ#lՀqO4vyM&◵m!Àks\~aq])t)#8QM9Ziqr:\{sqYsju{:q֩^]Rsګ:}3׭ |wD͒z)3kV :]ʿJ3:*E4tVCD[TfS&E:vJĊ &.j:-:xd'R:j8kEvF'[8k"M6s\ uşv{c2[n:V/4\WLT+$tKֺ|qX9\]2r(kiiXB))E+KH)iXBӅ4SXbRҰKV٢XZ)ؤ1>T#F*LRbL"+M+E1R+EM+R₽qILU\@8 L@j&LSIHi(iM4FM0yfis@ 3Inhf3@4Ki@!!8Bdb>Gw(Cf#Q `vSFe.E3T5j`Yj;:2%XQVOj Yfm6v/=HޱJQV`f` *RVFCdˑ֢oV\$Bdy5j杅M92KXQLELY'CBP5vBVk]fmNw:vӦ5VM0{UkRNs91]&*걕}nkɩꦈAv-ɨԂ7BZM&I+ 3UxCԯ [9{n]/<'1z)ׯB[D$TUQ>39T%5s|' -?h#*<ӅBi3ڌzZJZc G7{&iA8EL (54Sap<@ӃRhd )X 3In(+ ~h4њm-;w`.c=F^T\yzfL&SJ!=K;MtEJWBcqDt044q)=q[w=)!8r1mlvD icV\ (Ǖg檊=OC- qN(sW< rqU(EdZ`VZ>ZE+57(Rqֱ[q+$;S+P6A\R\d`; Y3$rfKsW"\wDf[;3ʎ#piZNzmUCĴvQ4sKL^ݕU&&0j6Jbn߲Hl+T(5r^!Zڲ!"t~zUFWQ@RJصR-K5NV6GsAڨEqXU5be՘ɪqVbkUzK-C; #RW2seRa2:4Uu79 kE"Uk~SRhUv0%o'&RP($(ݓF9UCVP:PvVD)9 |ILWt([ mRjH # S7`Ѳ7t_k+pvPwF[o1#cC\OK35&Ie.oA^i~h[ rq֊ɯ:E]?x ēF |# wiEELg9ר=*z⹞" vqb*Ǘ`S + NOoj˕BJTدU;UBe Þ{v:0NH[8AbWֶyUѭj. iOZn港efdtLb6elB7u+ulWN]49tV{]0Q]viSv]SV2|='x*Y)]*iE .}0isRI&334@"ʛZ-H!2Qv);'m<]wC/JDӗw"՜Su\[wNtҡU] F\&jiӶ*pJMϔcPx3Un*V[C z[mtGctlUKFo.Ps]p/mUJez&T[qȩ ҴSfcS:#+#D$ElYV=*a6+EmzRKkWJλADF=m&i9glڸ2uu$b3 =eֹ xeZ8#z ;H4X-$j1Q*$ʫ%[[x¨;vW[#jcy֔!G]Km;9QFrj@ҙ2J3wfD:$k*]_<&F1隤ļh£N7vr=ZmNO5.Y[hҲ.5[8svzi2x{uT$ 8 Zy{~V9ޮXwVڜn2mnU 5\ItQv.=:1Q\;緊"T:\VdYNxa]\7+"?Jd0aVҝ3L=yS<5]otc?t+UEג#;5is\$(<`҃Rf43Ni4y fiԱ*0i0%^ A `4NJ~)+61qK-K1I\Tʹ1HEMn*R)6GKGj)!P(Ը@&(;P 3S44Z(šiqMħ JL4>sFiHf@AQf4K3@7bޕ7Q`&NUѿޗ(PnX o`&/IϽ.j"`i x"&ihRRhNim4Ӹ.!RvR`4,*cQ1DH C3Fj;4fKLBE% IE0i3E!B4њ;4fLM7u&h%QL@ibiiUL4L5@4њ %0$p1WQ2*Z1.EvQmtDQm]de#dEHM)oS s9ZޜNj=u汥oorklƺH.]{E]\((*vc5^ԋiժ>Qʢ>S!YFpibڱV$ 寅i]W L3ֺm%bXߑ]Vtٜ5:dǂWʚ=^[U/j)'NY"i#\rΙV$gҫ\r9e&ӑKY;bXqZ5 :T۰*5I":朗J{X洦5YSVM,'ZżֺWݱJ w6iOVCdW8%&jԹ[Ƹ?-Zj[o+ll7`8AQ\?*q]JE ҪN7rӳ& s45#+J pM2qW_k]EE t ֝UcUnrocZjZYr\zU]wdˇHkfM4u~Ҵ$ך6Ud /IckzpMrT4+Jd=*"e2jb$ =3J 瑢'8Lg9.rp1LyvHj:E >b03LX$}MI6 RGn ە1m reC##j|MW6GDaG%sNPFWJГHW^+C:3KPppsJ|0 cQe{U4&Z67M +Ek$Ic۪^*[ cUF#]{R%tK{U*pA`F-3\tQ +Fc]hp]sMqFjI&isQ4&i٨J K@3Ku.jDH ;uB 8IPRRH 8FvPjʃ$9R̡JR$o1.Tjw)Du pEHáQ R x52)| g FU D*rSBc) $|:sT+3R'`O>qR?*PY06@jU,6Gz229X$VlrE<ķ[K$FMbEtʻ6.j\O2BvRR'l^-T +?>xAq\k~isQ.h 4YfG׭\9 ^'dwر[i<N:Vo'5,T%OS(M{Nk?㒺#+fjEsVW26RB\Ʌ5_ɖkI [̗Zwqun>?q[F 8I $/NՔIٔnY2^/c!O!!jIb+[ZZt5& 7QG*\Oh8VmkB7Ӓ^ 91M/[t:Tv}teg'Zହ%̎J_27wdg49pK*t~kԑph P֚0jY3P<~s1.(̸z dU> ZRq^v#Udpw\m4fcVJw~[i;@ȮZxi_StfPEh^A[:zF.~fJk1Qm4}"U˷OA]U n|c5f_PbZjqK6 =?f sy@ɬˢ:g޸܌7vfݞ^~5$3wXI"e;p1PM#>N:ד3"21pTdmZ t;mSOcY6ħ1|u$tG'Ita$=]*NoԒ= ΛP .ifiZAJQyݫB.b"sR7.J zHرsMArk6wlφPO&ps5JHfٲR+0'9J|0ui/ĥ.3NŢɄVrG ҦțlV GB{ gjv@Mm$s nvjE,$H2̃ȄBG!tSvf!BY5䏀zueydBp=:Jfh34fDӁPK3L&i@b% D 8RjU5 AQOx<@OaJ*HdG$* iԴ1f M\њLfpN"AKB7ATS5q'_aϘ+)Ҋ4O_N͓N.*ZtcQt*-МZ  u~VM5#@fҘiI@%iM4!q1Ma4Д'L"6* ڊZi5if4;4h`nLSO&h B aRUSTdӳPPf3%&hQ@)1#Ra%~) 1 4֤0LLaM5W$JJZJ`&i3A昇RRf4-;4E74JJSHiCM4LZi3E4)u% F)i)2T x;$r'Ȩ4lsEJ18)ڲ:6L$DjxW`R:T~6pEqZpi^MW1\9s+SRڡ.lw}:Fr[cS IQMsP tjRBZ%~Qp gz_gI4429W$69E"ךI*k]VKځjәwqboespʷ,y#< ͸SNqڴ"D 2P3uyEb–xXExljrwo' ׭GSΞč2$Vj"R6G&G"1!9⻯οbtvmui<``*ps[v:D)UvMhJXLNt:d'Y}X]OytޣQi0W=wW4;tycҟoz8b#w4Fb$eIw>jJRvKSŶ7Q,iF:tTێ[\`aڭ,njPjqm!IgJ dքݓ4[Q':EK:zʸDUx5:+ XP4nƯ 7ЃҨ$ ǐ1kw,1ЎUO!b85j=V0"{ڥ0Em5ӤFl}o.伹y p+<5pH^y^U&;4g3L̓4j i3Ku.ip54jQN& RU`jEj"5"PORUPjEj ?5j~ꆊ&(5]6>3PK sNEiF;`VޝdچՕ Co4$ƴч!TqV+ݥKTv ش^mlv;Q4#п`OJpOI9I *;WKeE9f8)E h kRvZQvICN$>Vzwֹa)j$V= P릅e2+ N(K?z;ӤfM!8#|vW۲3ddIgLTAT>Iv*f:20j1&h& BC4i:pGb4h&Z@.i7SKSsT斣FjIi4 y45C 4fӰ%&f@LRRp54jXԀRi҃HA4hi!q4LBS 8h$iRRRb"ԤTfiMP -4f JLf44)(f!C@P!sFi)h\iW:; Qq֪搱s&$Mꔠ9E4Ts짨vŻ{SR݂5"r@v9x+`KBb9YqX~uPꀟ9?Qs*t&jETs;j*GkTy&/ĤvvE9]u=XKaRh|Lw;JNƮF⫕rHjZcÚz3Bu;j9QkH5\h{G!Zv!iԜԇ 4&KBܲˏz۴7{ք 9s:sf\S5\b,-vR3O "o/+TX5|05KP\MwJt;JaJ x5 MV\s^%Ig'(ͣ󷎵Zt+*RVMnEZӬ٬*̻H9HY#WfJzg>aW[:m:5 tAT.jr۲zXfO˃PC ]Md湢ԽyLjw0F%;OcItFyzٶH zI0s[:{oMsWgSt+BnO\WIiָXiLL8>W<ffD{B)kBӮ5{0B]ƣ[P2Ԟ8BEx]GI"Cg4 `z' #p=kȒ%#7TEWOJK{X#\Zp#v< "VGJ +!)+)C0qz8T8{{TC@=@RuŤ`e&vgCT1+X>ed䝊GV%M pSsd9yJ%\~篕S]Ȳx^05jk<)\,ҖQr)Ȯr~.,*9=iY a_ҴY/cg(򒼚o 7v785ݞSHÎSSqX緥[IFxF?*dF,q1(iX`ǭ[ )n=QE]p{VƏop!LjlR=̩l\?19\q5z4ח\LZZW ISΓzWz\NRH<esZ&UkynN )E 4^>OP2%(5`FAzNC ?<4ԘPN84j NO SaU@X5Hr|Ԋjjxj hdQ*ݵ9;"lH! 9-*E +hƮ{t4=w;\$l05 9gS̡tgU*~͚/QsB2ڨ\w`WB [9O֡a^/$pQ֫Ovqj֨Ks4ҹȠ۹bK[Fn8sPTEJ\LުP:R-=kVRӾRqWE qO:tfXXJ6*qw5tŐPH9!Aҕ9Ǖz7Te7V)KFv&M4Ky4&i@c$L4n$.j0i٤QK"`4jZ0jx@ 4L"iT0 HE0("T =)&`)4f3Lf4gޘ i3I)RPIE!PE.2:Q O\܆eLTA8L07fi8UyR]Pa\P҈חFӶ( TqD~PjKP{UPhѡIk,}[Ը6BfXM;UJP=]EQVb1Sd-tʘRՈ/ 7&mܻޑj1Tg\kUQij ̹;sP-6iÌ據a:+֝JwW6&Es肮ޕJj^j剫Hkh`a=櫛[֐]nOZ"W5ap 5m5ֹUUsyx2hu3{W)o'li@bkj$V ݆%GN1۱[݉毪 "->IM]}1`=8Px'ZP whzSwFTe\@K1\4<+X59XD?ʽ?AywA5.FV:$f[5QY:}ܻWl=jtR0qQCH<o}VK]eF/567rz-Gl|EB-'tF3]&=o2u\95X܀ڰy+8(]XVuhLW9m0SV>g榄LJRޑp:;&5C;{ֽnzuzᔻ>H%nrwc9<H.ܣWSqלhc4tnYIa`gY>4jIojЖH< p8mBEm$=JI l;xU1AjZݺnCb3cj/ʲFЃ#"g +YrcPV۸7dM2K:e۞xWyG̫5som! /ɑ#P;B7#Gt<;؝9En֐bk裚G\d(5oh1frSSTYx= XszBM+|6 <@x";<8ַ 2pOqR[7eb"R5y8J4r3kOY@tcNԚ$KuybSs:˳8h CۦkCG1 8c 3 tdgs:f?ҡWvnی`<(a)wܕvjE8 VnQ{d=3Tl~º8Fŝa6̖VG {1~Obn&ISE9֫bdo/;ISEٴZIؕ>\dz$̹وZUDGe6i4ڤzg; MSt"̒d#~ p:.qdFIv5pg%} I5hUdfg5ŋ9V&25 cfkُ/ Єγ)b=?\OU+eBWh 5㑑ԫ))1% O PNj@5<p42u5 jxj8jJ' SGm(cft{v ®'9YB.Nȹ[ft(>ZuDU88X: (jqR,4 k"V;S!Uȧ(ZHF˒l#$QYπhH'9\ynFYNI2y&8= Vl)5;inVpZ-\tn\74i ;&+T$'r1]|>\gj07z;1Ԥ^j=NR23U9lLSxKjuT $)*bY}*[enfNZ[[Qg6(V}WĀ/ZZg5$tͤtT+]̀y~\w6sc5ם<ڳ+9V5Fnpް&B9^/fup$\FA?)z-lYOh?i谓UtWK L"zX4lsɞ-L*+9Aδ8sR5ɬ͠һe1,(Xf1U+;I<F$:K dmOߗj ǑjuZu1 9QRk#$֒hay<s& 6*BJkHPQP:jԹ;&nE>9Z4,=륺1 IyXGJRÚ7_*V=)%rq2I1V ⫵Q ~ZUSj;:|VfI9Psi"-iդ-aQkWFS@/`Whd8UoX_n~!u*3)9iF>SSCUe-w%^&T/)@庄w]/q#5 sq5J#^I \!hpWW{[ S k2:yu3o'1oFAu9GS2 GPI\nvs$W&{Y\|y?z=;Pyț,KS&JLUUDAcGƘU/44 2MɖZ\dP'Oֶv56xZP)ˀynykCVf܃޳&U)<гQݳI5A!l1BCHhѵJDYⵑx՗TD ҋMx^,#[Vw ZnțOt)G+hTg\('7Nۆu?z%9+BsX*Ith8-Z7\bH쭉sF^\dsU$ T.R\͸fp+,Q?a7I?ԏֽϙr} {Mطzx<{]N@*ԃ赿Or}'fykb/ o彰kIOL⒣*4 cbGYw7R3kT PFNA=9-QkkiU1e<޶eqjɸuE+##OXqw$"鏻}@A 3j!f1[K1W&HX9ŔW ]q#WTiqW޷|*Z`YJqՏ YY oew6>*pnV}ygoz5-09J팝֭ȮUF2* `]8JwAAF}8"f.2nȩ`t'TfdѼ{dӦ1_.>I'}5G/ozz1QQʼFUdeBF}ͤ1,9US ۡH|ۺk]9$l~umf+T[K/9]6Fm@P8~u29(H=Nꍕ\czW9$dM+>7^O(jn$@'Aj%֝0tڀ_% OO.VPrMQ֯"k6Ozʄgɜ^îmmrq 'JgN6&&luum tz} a_eNzw/63?*GL`tVS`:ZcE!rsϵaFY7;oY\qd'[ԑ_IsF@yh(]~n*Үgv*=4:-.8\[E0+*N Ҷ֜. ڣxqTsSe;Epr3jUgr]AAUtK\aٽ>sy4rnsUQ&Ea+iפ/M9h$dCi,Cc5-Elm'0g^`{՜S˻5HZn<QHⰩBI=7&de$VaTn15(1݊,f}%RNU;fXi^!H'5*%P дɵj(cVr4. ``{K=S 5rG !8*GJGq dZ[ ;o"X$~3t[[ OV T(^BsbUR8늠dqEVsTP6oJv~PhV$ 9'& &@bs9oAܣZiY"Itض݂p[F{V\QlT봲0?^k7$ik,GGqHQZۂzT\H>1D#28S+[CvW 7;r $Dg-69ל۸t[*2H=zԎ 7L @L~ަݕSqެŭM"F*y2][9[9\ V1ngYOFgk1#cB6}*dp<Կy^fu$AՔ$[Ocs[f@ ۆϙ͘ phΚPV,#y1̛{S$1:1BuvĔP0z$ - bTpv:+ip]yɺ,ɷy=+# XF7:Ou 2`0AI;yɌ Tг\c'iXڇa'_Br}U98[4&sŻ=I'e9< JM Bk .$pC|x VE̟21 }mȑ Ȩ`2G+hY2:{VޝdLT8 ;yS#kA=I%H=kfJRz}+)F<2B,;ZS 'MedyvS$;$Ս KDžn'ҭ[/V"07*i.Y'ޔQrݎT׽"4Vʯ,^[ 8\JDUgv>dӭVgJյ9c}.D :ڕ@1kdZ3;XlgVp))`zzy`YBᾉu IdJȼ-ҥULmXN?(YK#1$<.k:ը)Yc7nMҹ\#5{h&%:%Y.ڱGZOgۋp)r;1*Fa#R{Ulm35xqZ0C|S̋QL,H+c`Ē1Ԛ$QPyer1.wjxdʁ+Wf1 3ֶ!g jy(YvJ:\}Cj4#q8F$'qZJ7l2`ϝ?:z .KgQ'X۱8;@8bPllW<&y Nt? U_Cz7DFYy6 2 $wSF&{˙&Ēp}<ϣP6n /%y{]ΨFNCyQ۵tAV]FQ'l~ާWM:Z#ӏ;<SUi㎙^}\ιiXsBC͡r *X]rq+;)|՘*{Q3cz)AmQX=T;W"]}i[SQd6=1ҳ5$"nOLּq4 :Նc+*,dN)ϒWJ"Ǡ9j\1[zw9; fڵaD+FL$'օf2zWN)AI]v%9WGi?T yݵ$`6p1޷ue5]R Ecڪ`;tVG kCs Ld 6tek1Z.;4pzkB-m&4Erǽ^v]JD{^15EC5oN5NƜ9j7E+VZ&krt5քW"G[&y iT!r*6E \yY lW&,c4ؑ'qR>Üӊ] dt^;TٔќN,Ɲ X7 ɮ/,@3S9 ^^ BIr2BݻTOpy$j5'=RTւaj2yɩ\ʬǾXVUb9Vq]2sH4܅$ybvЕiUGRq^iSqp{l|k,Dն7g.c9-SV| w"=JrǛQ>[qUiT K<.19foUs}+o 8zi^0rՙ5nsHW#EXF3 XxLCRc3 َ5**5 i{eTsNG䴍@ WIMM8:͘6# wWC\c\XW\ .w4q,3M&iњfis@.j<҃@N(56\Ӂ•L ApjVlӷT9gV`iC67T[sEu.j,Ѻ<њu.hf7Q,!ČSIXB撓4PJ3L3Fhf(EP0 I@ ES(f) xn0MKF的Sa1QɓS{PPU]34=枠 I.Hf6H <p5, uGjl1ϭH{lӁ Skp_8`RSSk@dQBW#H+9;C2nj)+B*jU2ܸ+&98WQfzO:a5c 8l{ԾIr)n^zт (e NY3\JJnzFSXLk]-Wڋ};PF:+d1EjXj  ֔k:S>fué~KI~5 Z6MQ^EAfH1VwêKgP$P \kFN죉Q%5 &>jKh/ qTz[v"I_+gRvKUUdt]K Dǣ? ukW.n7#+u+ż\S[2l}j.C8=>xW]9٦3~npx`OOtQ4uzWn-nd_1SsU'0lĐj$/~pyſ .v "RC ] FvsޣLm *T.|ĻBꬒ W,QLēy Pu٪F'%?JS9gX{OZ}`!%]4ogF>#tЩs(BdQCl1J !9=G[AJ9t"u3e@}:ȝ]z4 H x>=kr9[K5/Fvč.胕1I8U°9?/_LF7v=:9^rM81?{Q,c@K9_%Yœqk7E[hH?3+6ᤑ$cǵw9rM{i #J J s :rzaR.Tլ_io.FoL,J}H,kw$; !vD$'CZ6YT+uAzM-cgp>j=+MWu I ޺[tGcFŘjXI =5,hBsy]^kHG ;Pe;9  T{VC@Kb9A㢵[7"9 ɐѳӅC 4%ftC:s&hR!{fGڤoMd'Nv=u9q\gi&~_E%R{|yOLS9gsD||+1]*۴RWi`z1)0ͤ++,,Bjg8*l3 tPQMjuZnUZbsbKIwpw#IGݞw-YTƽXIyxSoy%DuquiF;U]cUx\4W0&g`gN\6X5*RT0*XRCNSѻWW7`0*g&qZAZlrJښ)1P3 h~z"'nK#^*ZNEe;sDv j8&d $ yJTu9UΒQhz5is浣JecTˌ0{>y)ȫW7d.kMlC&jV2VeR(>h흌Czzw>5a2w=zYy[v'?$nFQ^4Sk/UDHEQWSz#!B[w`jӓVlq*pZ攟1 JMhW,sV`idTQc)w6}kȦӫ$I%F4š L=IPKkb3*౷@k[Pspx&eJWQ%ڎEl(Y0]1duIGZA8i[͞*&a- bYf D1j`i۪Ru|-!jLE0zLj7VQfs sհxۊ2*y%(qqe٭f,YJV<3Fiff;4f 44 3N8C$ D ?4<vj<(jvj isJI]4fI.iXDG3JK]\a2Lf3J3L.iZ)3IZ3IE4RRZZJZ(%-%bu&)%b LP<ZS|ʾC")wfjE23Rbg8 )oznkN{lH]O9)ƅ4f .qMJ?3_+9-KU Vs~ByzRDBc5i@U+5Iօ40qNy3Q4=(ngᡤAaU#֞7.i) V7h=i1{93z]ıgڝ7ufIfmb)_OgPs ?xWF\ ;W&{Y~I9˩-c9#֦0<cڑI&=DGYoY$k3C4m9 j9r>S0^})I)+2/Pߪ~P#;vm#Ye۟_@NAN{hA#Cd’R͸7FFVɟuwoZ}'5HHb{EIMA_Y6$p{qQN'lο%Fם訵Xb2im IH]$_S]F9N6B_OsP3+0!$q70W>wRNxSSWP988֙MgT,İsq܍U8Z΢DVz՝#à qU<&qhjH毋V>Hn`E-TSކVqXLg,}9^QJO62JG\t7d]Ph?f^}nmLKWG*dڷ k)3Vͼf*G"`pqVc FRï^+<J-ԹUuEH!َ* Z0Y.z.u */Vd/bDG&Vc^.Ld_bϊ$~.(5{pI\kW7PI5iK뒥E5dT m/$֬3u!J 㻭rԏ*G:Y?xs*J@&caG5a\ 5qX[)]B9v?*å5aJ-V^/o˒\đ\Gf(6Wy,Jɹ y-t9rxf;uq&< 9涭|#ij3;\sRV=ai%,3,!Xk2ejV\'%T XmB<{M*jN:~F7.DyU;$LT#h%| "0NUdlم\Z:ƙ&.vOVZX+v9(Ǚ%s{R,6Appz׋ܐްod?SYyqSc!&rıjHi%+ z;贵f܀) Mdz>}kjt{XQφZֲuE.NzՍ&SQ9lt2U串M֭+Z;T![bj ޢ2=j9lkM]%OZ?4czm"G;Knij@ZZAK@Z1H@:t u%%:)QKA)hQE J(C74sMMuYW UuԸ Ri0H~iCsPɩqc44(RЉ*i۸%4|\0)1(O)ةc !jB*6$RHH@HiiWW-EW*'^FñOY7Zb>[7S=jcI!qd&_ޠSKPr/LfGMdB: Mp+$tz. gEΦrˈ}Xp?Ociٔnkr;`VjOdhy ;@oAM@c^>0p=q;R3*oi\jx[C{tM@-@q&)ى*h/ Hު\ser#\k>tiˆvr;psZiVҶ?E$1bgtbv}k:w7:-˱ȷqQ~Zһ`D+vUygRik)Ù kOG\#TFĘ o}a }sի3&N:1N2Y{`7wyh+GLW<*Yw*ڌ*k=}Ԯ~g;3jI=9LF4ROs\>2MfjDAoJv<5f彸\La'=JfqH9לSUtUO/杧Z5s 6f!q蠰ݦړI\J}aX۵ $p{ַK;%1GZpQM9UrQ0f 珥H_ʈjVrX*R/u4av;`'TZa] m!d%,kܚ)`fr1ZNG'F?: a@W#y Hܫ0`11o#_[4XTcɭbiV|\=6R=8CɮgSեm?w^s&wq7ڮy>l؉IpO ^5іj݂OԛW-/N51sFѳkrW*0XٺC޹Nbocٿ0jeo/_JTGev@sHj',Db#7)jo)4$H!GsҴ@n =aQbkqң˶>izJnq$+!U_GެU-zX}[> >C}yݎ@OV)֒\+Y{GRN-'NQU*L]{`U'8[ES{y07W'x_O \;\ǡ٧E2˄Gqѥ3䲗eâֽaS!X> c ·-)Sq"tJ&DX`cV#=վdgsz5N&9CL}PxDxC\%C()fzVn o>&1ПZά.:]C/^KísH.Mk,%SFJFͿQry54}MG&#κtZ(Zl\%jx~tHO}d`3gO9 1?C#gC̃v p: 4bǀ+BpYS)KDnkVehD3(6kbvq/^2O*廰<+87osmd% \g+׍Cw:6DւjSMo uz]ƻi?Λ^LWK$5ISt9Nq|Ik-zbiik2sɬ.@eNMYڝW5!s9sԨ-4ϰRnic޼Uu% ;6jJT$*JÙLݚg$ӇcJ3kWWKi@rfـBըb< aғoJ-}+M7=Pm:uSW`9>C&Z*3n" 5~ m9D5qmng(^٧&gYd9;+9$$QbTlzUM2h֌U#j+\i#$VuŶxdT2CCWr;`\7Y76c+#^ٔ%H5Y9'L3N`c"gR] 2.6z*I~R*֐($g$jV*).GCPl%nO#{Mĩ+!s"@O8 (5Я#2c%1̀sZ3o.Cnz{VMUbhG ;,-ؓJ{nVxd>:fogGOȢr>G+bO$VR&rѸEy5i{FrS+pcqSv7W7 ɮWUQrCãzn>à $φ8N}J;ZKUs0=kw!A˱M+ڮuʎ4)S@v"5 >>f#a\wߜ8ut1rZ6TTKBa(]CC8 CtwOFYj*9Ĩ0%>xٚSjORw׍6I[e$cyG'"[tÝlߺ>x& 0YbE=G#RZ3%&ETP֯6G̙֤LJ!+ pDT6yf՘ؖW^Ƙpy<4&Z !y.9#j)8Za+8+WU?2˨b瓎H[FGʹ{8RQt[8rHX-`(9 {E-Sd]+-`!?1Uݽj'1w^[H'ފxRׅHh3rktI@}kR/`LoUu\QXG-iQv8dTf]M%  m9ҩ4J5!t*厗5;TxOb+JrbYcYoSWuK{XdZC+ gV;ƪU "*خu3TS<$q%5`*rgAKm׌iiҍRSZƤHvSE)fD(ԱY"[>w nyLQj5]khJǥwt{"Jn5lEUFII:0x>lfʰ).|,pkjz50ϗj\߾H܇d))LLC$K$&-WRsq(ݜY[Uc1Z\E͙b[.?JٶL]!PWPrw4l̰1m`qO'AV1^)PZnk]tTvJi!fV*?.zU*&e#;c)Vҵ`_(TXٽ1ڴv A5ʢ0)z{S3L|r)͌T*qH`PC4`ՙf@ԝdjAk ڞgCdJg9&I]A*c+)PMæp76E;UR[!s7\yrgQ\( њfis@QM;4=)sFj@}/zm-!QjXxN  Rh@P!)hE0 (KIE1 (i(1i`%SRR) +dʈIYs>MYLrKRf6Z'Bt$#Q)H5:FkXjC)IԃZPgVԒ&)NJmd xpjQQ&jaҡ JZJ :ъ(MI)R4I^D*}(/3g+FtNf'JQHh[bڔR9c9ºBGmFtʡ#kM7V,}z}PZ#dj>Q]XdthKym(t<YQc\gj~5BxqRڻE9_j溞$xzhK%iC>W'lGl;qĻж;#'b]. Kr3 jvhcr"Üpzfl96EbB$cqn힕1 Fb`894M9gg*qЎM#۳T:nL'>}) E3z沩QCsաr͹cX;ްnC$(޴oe$zuW;AnLTeM-y+Ie(W"Itn2bɃ2+8s5YY#O,< m7(U}+ݣͯZ`Ff[^AcjsM&SB<ҹ]'Oj/E>+m z+*RK"y!!/wxVF~U+W唬8'a9=u`g?:譼h-+Ak7_-7#q} xIZ,Cȏ19kS+i]]̘^gORԨaE:Jnrg }u|CZ_b+;IT}OJ ~G1QnkZ!Oyy= ^L>*@?c^izMKx4QO\&I!s=%Kw̬06N(B9_jsgj䵖rHc$|%WE^5ZslysJ~MlIcֵ5̌z tݑ4+sބ?v.砯P9k`Lya*֏A$}74Piь7Ѿ'$aRcTwjϽt\D |ASx4布VTq9$c^۴A]0ɟ~=b_;+cY^m5#J.!^YIk^Us)XW WDϘO`+Qu )²OFlӗzRI!U rWݬDzӳ‘h pJ:rJ[|*` 7/7~hC/ֺ#+f2Tn[;bw`20hp+A_vӷOjF_u'@!iؓp'8C"LqUoz;Kq9B/'/> ʰ>Ղ;LxoSޓ8Qs 7AZ|AvW#'A]+ A}"c1UqU͋=&lJ6D㱥MPMkP=ZsW;ȮޙSoQZphWG|}E5hkCZ3:Ggt/T<i:i5F4V2Hhjq4ιQWg3ha>jåa R>~$W3 y!FO$դ1 R)Z[75EaC`Vޔrd_C<}MHCW@Bi/0}*u:hWn?aeq,jUz֐ۦ>w$n\PGv[ys3ae\VmRbn?JjN{:U`w֓&JXk^VJbTfj߉qbٮD8}iWNR;KqI.\y:yY;I8kK7"f} cڤ1+jKuE*䊗Si"iɭ+oYb[+cUB-6tz+|"j|0zp&J8|{663O QZV5S%U6ý p>W回M֪,ifhI̕ZG摟ޡfh饪2ri@n$WZ{Jf4652IjsFHf4a9^ ͉Wcl gHȼ`\.AgSCs׊ʼn0S3R5 y jxqsJ 6Ұ.iKe.i\ӁNӁS&:N 8Tң"Աh̀@V`&)hR(Eb8SiE1 EP1 6i%PQKE)m;2[V05|JUKJUiq5Q~Y U<n@VdoSjKL$$rk,KR ޵h3֪֚nX͢B3IЄJZ@H(j H--F;9)qKJ+T t]jc-AҪނAPwk5ц~g>zN)STNL\qLe5`⥵r r{ 7dW7${8ڴaҪ#NQ;r>xzJ5ףO)3pEgڒyqZx9* ؏Z٫*6*n-ʚ 4`eѶ?CXWr5Z=ZTXY<tvuks2'Dl0rK$ƪ⹻]~;cY#@޺YZ wfS9q̱,J1*LRiⴄi17pu®3ݦ oUE0,`3]aUO~+ {6ƜdN{!ʍm*Y8K{=*&TBVM#%ǐР}%JzVlPjP̆c? ï*G#MR\?,OBb\?t񬻛üC!hGR)L皡-s5Oza|Vnm*[VF:\sJg?J[Ke.'y*)4ۧE垥G5 +1M4ˍyK&X$yx9-!;tj/.@zR;"'@p;UhxmVr&a[J2nP!sjմլx"0p})Qa!{w"H{$Wo-oEMckoh F5uOSpqh);~(>IE#Cx\HW G#򸻝Dyœr1gJbH da3T!K1) }眎1@9۽뚒 vbG%'dc6{]Z&R_xu&A` L>"Y[i|DOYFdpZyq$+ Ԧy8Mrhty~ђ0W-+Z7jǒ8GNf,# t ĭ)^}k&{eaҤU>ئeZ)Q= SVE`m%{#gZϗZVrrb%+m>v\Nk_9S%k KM9k2n/b**dž|1ur[z"HA#ݽ[T`qڻcYr)6W:Ex2z?svDTwbi<ûX(ֹ5$ܿ'G8⣒Y K1ןtg`*$Ȣ,9e&6&yi} 7 75=ixzsUAIXI[麮Au5Je<;Hަ8e9zucapk"khh'PkDk˩ 3ȜZdtQFk2fih٣4 34 %QOpwCZS֥0FPH)E4SfZ(h> IL`!LPh❊LS)h.((bPSF)5keA)Jڣ+*{R86 0j Pː+Juogv84JxdRw,)|ʬ5{#KW$դ6CܑRcRj2 5bUcJ E 04jjE5-(QnQ`% AKwmqY*օd OEaz\GH2xw)abCNRN0YɬdgxkQEV}1Ews]xYSF+:Sq[U?&Tnw)SiqaoF?Y2_F}jojW+6RrV'Rsg^#cv S[CIja}#{vGtwHí`e=HPT#'2z+]J%[tFGo|)W;tj :Ƒa>_jhɌ#QYj i7r:] wZ eһIBD|drj9eFp@ӌ`"gb͹ܜ] }f.u):Icv \Jl Gˌ=[*@E%|":ODiϫ2ڳ|g;zQ9re-/R8GGNi\ 3Ieg*n1,%lW9Su!W .Ф;ѷ!jl7qE`-ǘ\웖n'YfyJ23dՠN(MfK06xnn.\3}⶚4acY$T'+Gʼn]3k ?ޮ,nYӕ8J64ev7Z`iAvk fhA"x@8.zW ڬ%@=+5Y1Sava)Ůi_U}PfL{V}G*.f95[)fčsֻ/՞eʹ!ndՓ5nQMWyKⳕT;'rG&TF\sLf-1Sװ@Y['|ք1uE.RMYfb}tEjJVՅIFNs֦޲Voz&z# \G$6i2*OS>Sgm}ku(ֱ;6QO PxVZ5hJw`Zhؓ5Fn[ Ju'C3NFk.g57A)D<ʑlƼks]d)b ^ Ɣ9q;j7'nAJa8O_Z63 d `t\wcg; 4$iRwJKqV-n4!,`;Pal{TM#E5JIwqSH0MۭI y_1;VO R#Hk3R[ќndǭe0 SU䛱RIo~*U$iWmN Py ^# jX5I2uɫ?fY( uG*%;]XMYͯٮZ3+9sѮY oןwL'"5Gm ǭ 4YG(O5j=7@HJsI6zpWdOJoƹެ%팒O];SbkTQd1E~].>D_)m:B횚 䎧=kN_kIB.6G3=2=q4+2"-jlI@B+ӲEy5a:UqO,B[з~95=*?0,Щܣv&V_?j ,9^AkҶ-銨\lRG#>#99c=Te$O޵[츑]/ rߗZƾۏ\x Ê(hzP`~HqQ05H*c (QHh ~MWtOӖ2MTKL➢17]|G;SjQ҆g$UUi*䢩9lTEB\:Us4hN`7U~fY)Pi)]:$i|'9?aKTy>iXg'q%yެ#'clW;3#œV5ܧ{5grTEFǵp<ڳ+i^-\ܗ2$f}=ܻ"Vn{ Aut3ڷ*ʤ}úB2>.#M uK:]ab0+RMߡ_R UdUe c#jMr`o A;6`\iwu$m_ztDZ: 30Bv[M4m oy$LA}8Hw'G=+eChA4q5J$jBN9TDgT$@jV;" )A7wYI0e2ED ~\v?5DP0+SqWUTzҖǩf]0Ni3Q :OAJZ YsAU~JjŸxj*]zBr*pj6N$V#y#'y:b2|;eKM2HzvJ*Wm*v zg;k#U|:Ƭss튗Rot :y9EG.9 :t<NsP| `wgO}u"an.XzG͍q;Q^yjڍĚt;FKJJUdօiTxE05uc /zļf TNJ+S)ME9sLeL*bj . qr uCڴf< ^V&tdUg=+s~FW]楪ef?06[=_bA9UE$~Uu*2ΒIBu$V93ʕ8 htTB[ӘTDV.&M]da:px3Rǚn^M0d2WAhRA%VńUW2NjI9f:Q39r鞙8°u k1t+3 ?m5?P[x!ӓ13oZgo*W ys\ ܮ'{ɝkE[T[Y*W4ӵ̓++͑s[BIq$2AX{\aNyɮE"J;%h#I&=;WCghxY}ˇ9[a8\%;R5I1/ݩOq#>xXkx#!loǧykϡ*e<֞paYQnc]fi#noMt:t[qY56rXDphxvJMb[Jٵ'k9VͮS֦$Hh28W gV8MP_*f ~S֨WWQnR("gk&Q8qmi$TWk euȳNiwUurƧS$XLQ+SUb[$$Ozj&5"`Rsv*E9v|ª8欓*'6kK*c](fmRT^7X^[یdރrN.r˱\kWJnrgX*Oj 6BQAglGN^6V U"G5g{zV~ "jRmM\$ZU^"I/>qlq,<ň3]*6͔f&AXخE780%a)]|Mg.wU".ZF} K;3J"XqWbzTqԊ[fű# HtٚUiӊtRs޷ѣ6b\׊x| X WuOqzUńU`85̦a:`\tA1ZXtdb4;"ۃޟ$`ڨ=CЀ{VQnZvūn1ҫIkVi @VLI3՟5Kp{U9mxYʒg<&qXgnP{Ojɺ\uhU)Xpi¦-Ң+s= p p)R plH)*O 3OO  xx@R1hbĢъuO41S u 4JmAskChGZkDF1]V}?Jmv⤌h2prMڇϺFl䓜֮2[Aawu:DܙꉐҬ([fd”p6 YF TOF&2V̤v4C.zSAޞY!j>&) PfԱiIh,zWT\M;Ѱjf~ӣ5D5b#Z$F̀!5qO5橫 SG3 ɧ ln^@jgn^d<( Q2Nm&$}k^2} 3ֻmuqמˉvkGHخa*^t7gP>V;5؁tl&I GDP5wxz jbr7m_ O5sTj1#nUۗ`y$;ӧl-|ɔb]2تYeEPF uV Edj[?ZOšIbL;;-F;#(Кٜdڰ&-O<+6~ZܴڻB-cFK>GUS%#F`X&A۲mN_U1EAYrf.֕c^%ysIWbHZTTbbQ(48KOE*eE#sOdK%)<Jyդ1zH1T6:b#sM )-zTK5jsRe#SH ߈K|@ *,{|ج*6;]lU.!T*=n1V/fiڲػ6kZ1vOF_z >PLaЃ֕ơ#'/zP1o_nn5^GAyn8_}jSm܉K(I1CԦP*0Ck-%2yĪ8%O6r@Rzؙ+#1k"EHw1({sY#v5$Ƚ mSZfcs 8 TG*Z'@;fZRiZ`~SMk8#pw 3l Ne{zIK.Z|]\:IǭS|s֩=kr!2۾ic$kF3eܱmե>uB6Heϓ֙ ꊮ*^J"5fu%?kifIY$yf3D"E%A5她fDqڻpt*T# Ni͐V)1FK2T 7ܲea;~&s]5!=Nhѵ=~Z'W5uO.4mqfO\g::4t0ɑv7*m>#dv[[6g.4EqҚ,Jܶp~2Mpը۲5'x9 SB5 Uw&lZn@CxZa'֚=k[J[{BFc`ީh%XЌ&k4Aѱ)sʒ[;ԹQoh[hnaKG^k{e8?xW`Eڠ`]:Nv("āzUf$Չ1LUWݎ6F|(Ď:=EmH 6 VM!}zm*3֥sP1v3q?:#qX#Դ 5.^zSW*\m=Vݜ枯g}ʾZtʯn <۳Vʚq=rm#s ?Jt<=:W ں+T_8yOo rH.\ z{Uئǩ<^҆{%{9sT!T|QTw?^kZm2 +/%]ntJ5Hj(c1VǓloY6 =*Yn5 r"4΋2XW-jLg%[Lz5[l%yʑ]\+mW]KV7bG 3Pi,zg)lQk^Cw1+w4kvZYzob"aکxDuB;񅡌hF푁ZC;8HB<ρNr?#NY.yA"Lo>cOnk.=ҷ g'e>6gn.N@#^S9+q lcAYiEs-V )J8Q~Rc{mLػQeɀqMJI>1ZGTݿQW}ѭ ɑPڰO-bNJpV Ӌff[ E:qR?ZטœZ6Gc=UHeuj'+řȳ%ōc9EBT&jk=n ?(M ,u$֗لj>vInO/7ejnP~|gs7W1 n¹4a!wv2z6/zʎF2ߊҽ>i%dKob&k Z7D2\ڱẖLrOqCz>Xw2:=#Qy~ ;:LeU `ZBAW;RyRv3GXUI't;,$XsB|kYF0Ãl Mگ_ߠmݲ-YʝN6ӌ`sGXrrzvf>Gx>BKdNhkqq/I,ֳ= uJgW"B{Wzsjsܵ2ݳ] Yg.3 TT)tS2nTY>zך<f$KkVqWh"|qdȬk5Dwg+"W^kBu꣯56vkr@1X`b3G$ur1ֹe`j:֪v9j$׹\up Yz}j/w8;K Heb߽IFn/K(Z̝=껸5^MNb&qYj^W²RSVE(ӵ@x 14GG5#KOI}79껜ҩX^NWq)6mDi W^mF,VnۃZ6Ef܌ZaMhsǭa5{9i-q5M˫rNH1\p h LHc8S:G*  q Za b(OҜ"VA1ӥZ%a-Z0*CL%Ǩ.t+m\rOAEzNT Nk[6;ܡۼO{7 Qlk4*815QMӚI¹[9[y*',5-i jj7Zi|uɫ \b;-ҭAEFVb NIPd0JZ+NJ1lVQբ[f)T)i5bd;v<}*;[ug &j]9ץ$Dٜ9$,zU9n p8ZM0тHWS^3ژdE#`=Shxzz"#yۆssTN]S\Ȯ VD$LV?gVDkZվ"'aԨR$ucɬd!&fYڬāPv>V=M){C6 if8V8h>Q %9OQҪIKj-W+vƺc++6N-G%[VjޓֳumQ:܊HJORdt暺5Rirc5BYhqPL7VѴh1Llj=ԻUVh xIؾ@3nTGIlxe]KcETddN:U),oZ榍i(kYwO70*f.v;h2et{**Q*l[ݓN8O[]8< #@/C9=k+l[S{;:qfoe-Li4.۳Kx5r5g˩J^jUȧ,g uccŎ ݳU]^mzxI֦B PI*r73QqN ^YK/5f) q%ⱡ8"9bH[5^D-S[rݫg-U:WP`{.:V2*iL8YPqsc׊x*`S2^)˜)58VQO4jl¤SPO&~sJE%-"ii)i QNp8RNH"RS <R`' 3T*㩬:Ɏ,zS%fgV?57k*p4"6kxʃ޲/mbs&Z鶅U붹nn"FU{wzG`7_P m$̞Ml ?qJſ" I&?ƞ㊀*/rK7=j+.sZ~Z¢Ըp~ZM<(8zئ4%6$rGgb{gj&bM)֛Vnڳe8TIYזn~"x4*/SZu\-RC c?oi!$jֻZ2GJeIɥ kCmkEƉ~5t']vǡ[aY*)g[γ^0tpG{cc2/ һpۓ#*N n*g] >^95@sը2t(8$`[@M`]D#`9#Һۨ"`ud986Y!=6C[+cqSP]$nkCSv2YhRI2z J&QwaGձ]pLl6ENim{;FE'$uS7 g@x @"Tr}MY2ұQnG=8S_M.Vj_XpmN9 Չ +=ulHj""r%g/SX_9q#SHC#̏ɪ [ 凷Wўuf,C3c GoZ,,tȌ2p#IhSRAd|=iSќdԴ6eRWRkY 0H HN2W=JuT,x!s֮ 9UujUi\5ѧ2.cn2x* b8&j6VM%)jtr1~!"%+Y0/A5,g9bI5WWh*R UY1Nbb3W: Zu5Nh5b5CSuPb"JqIҞ02>*A/SN Z$Re2-P欻jԬ⠓NgcT%c5~aTriGA}ճŽm85܁~@x"L;nlfMOJV3ORNQMR'ӓV˹oO̺V=&޿pqp*դ",2P٬+hd1_068*njHUf=5U }K֔5=*V0{bp+ـk=aU*x5nqGua:5ڸ"5C&vS2;=**Ӛ%nz*植sM=jHȠLQGJ78 \0ՁȬiCʺ;5ۊp;qKf\J<5\z>3qeViK& S΃rd3j* n6GliApH+"%SS)ZGU6ZB mZǽA5ekVK4ZHF:TsEM.^f lEIFR68IQMT7K#RHYgcg-&_F|V%VA^)\6<֔1JniDu\%H:SGJ:T̛a`ڌ+X5ta5s*āY=B!*mzkR6cf--4Rx458V`j@sPRS`DT ӁQ04C:)¥pe-HRfi&M MAIE'7&FbO%`M̒mQ>j05̵E҉2)hCDB3p)IZ1G(r{5؃nBiYa͹ʪy?^`{dDsTVP%dL{ <[d'-+!]d2>qڪ2l%b}qZ wq>]$e,wHŸޕI_(~5H=Y$9A\>OGjJhI2ycҶl>f|~UwF̹2K }ٺx<< v;\ȶѥ Uެj)cd,)mb*su|(YiXϐ\rO4.C4 '12Ao=6-MErؐVꦅ  RB$p`tTG/XҳqQgFzK[ Q[BUHx4 ,槆t1uU1Y5ՁS`b|sSPsPIt; 6ރ#1ӄyP55$W9"q.[N#BLͽ8RB3$48]h(sW" Oc[v}rm<,9+WC'?!NdFSvjxbN8wJg#a{jd9PR,:˚*V^ƫymh|thLpz*i#UPs׎$!F~Zd𔉜 Ď@;BVQ1PZ1qOJڹdumi&B7Bp*˒dcؔHg{:ŷӈ\ y1ŦßS+`F67ZNxo9(R[DI^;hYx'nX {w ^"8aH8 U4 F*Up7!"RFF98=*'vPr2jܰ75 N~fRWZ?9UqZN:3^6IXK;7Xcć*~p=*1X^$ ck+1";Bq*#T]jq\ Ux&ƱzAYQe8lwHr LdRDǨzӚLRi?nK҈R*@kUd67w1 VW= j wi5A5~ U*T8.j%$Q%ѣVPI5z!X-&M*V=+dIy `tE!٢p<4)oV'T\8FpcըkAKZ.+-t"Hւ )mOf>J]R22c1rJ7`!.iYML5aUTdⱫQ-Q-u6w(,"6xqjKzҞ2V⃔%tue*Ypjf4AXT^=>-ZJA0RivvU3X\dXwЯmb氯/+ۄBjJtWmp*yAW qOzJF:M[5nUx$i緥]j@zc#qV 18A˝MHԬ_W+qZMF 6j/2g:||jAfm gYx8lgVR]HII1^i^ ͑My<` #ŽheRp{աn}!HuokgNKucjܲ+n1<kN=3SIC23륝m 0i6R.A)>ϠjT2H];[epqjVb!GAYW:.pvGEynOzMw[vXvwIR?yլ,no^kQ85:[\uZ͌ݘ#Xs`q5FF![q+;<:LG´e?~uWaKren*PMUFA\DEVO5m:uL̤sQPt3@1ҳQYެv8 S3Z /Z3U2Ɂֲƕ\ޫG3o5^i}--Q64KUo.qT\v c͓Vi56n] B\bZïzލiQz GE1WEoXwp^!vvK#&ŇVdUg%[]SSŻ{U֥VW93דfgJvX^p?*W)e5>ќOȭ7&93N}݆fcG$Cyӹf4L[vcҵ Ɵ9@;V$Ҵ"ڪ(;8SiVkT܋ vUCʹu;#J; r]ZW8P]٧ZM5Xji꒱OCZkJ ,5o7 鶇I gsKҴa޻i z$zɅА/-"Ēu۩HJλ~ aVVG-]q6sYycUY^EiݞmI] ;4J 0KM\ԢAɁSPOO@4}DP Mf.jl1LҰ\Sm04f4\iκ Gw,ŏSU_z9G1#IL2L.QľXz 8f/mrNjĮ._;ETĶ0Q@yDrWMYCp@I%X Fv=@|$j6ĽϽB5K}*no穦;PEa@\*TU od%Twq`=n%@5iyEv\ūvwQ uRIbݦ~j1,mЊM=8Jz:UyP7j&>v{yDZ%R|4X pnV>dFX VܥM(gFR ĸ=+4֣E[wH kMj3'Ee (9⦎W$zZT Vtߑ|SL8;-zhbOSUqɹvȯRx*ў",qJd|;Y7` v*q߽t:Ջq@\)֦2::@MEO=OVRd;;T0_Ҧ `i0z(q,( =y*s] e$W7ǕOb*'+uy/\c=*Զ"l7K|6)fOvku$V``+{ṼS44aL3c֓ڂ8e$9j̥''N$^#J R3I5H;M$'xz]DtvKDD\ilEXzkn@[e7 j̬ AZ#L[|?J+I桽@-V&WQ sVM 8IHa8RqM^UA+h(f+[zS>ώMc$DLqZ j皵=*#s?`t'`nJExyQ9-X-m^͹%kKVXYdkWr!C$m-+,鷑D)V#ennnx56jRн3S8M[V4OA);IR1Ny*ć͝ϭD*2 dӭߚ'r?]ew·zCq+ ǔJzU;o,_FG;/[c.'R $8.lRRMT3j^5e/8m75Ic -AiQ֥ok&kK HlBMG&00i&jiwS3E0$jHB*U`*XP}NvOZX:CVNڥHVcxk Vt ^h$p<cWDes6YGWdzϸ9rV2.&*j*WPh !pj@jXO RRH\3K\ԀњnhH&i3I@.y%&h& S[IڣhqVrksyFI[+\iO5X s{Gz17MQDǵ4:We^ef$kwP֡ɀ^SByMČXNJ:DwOSC!l=+yR_ kN*OZ[[$tU h2))U@*_)Ptꭐ!ww 1A$&cW=X5pycWcz`G*2t!U&qqֳ'΅L8P  \ejkIYěF ٢"9QQÓ+d$mĉҳ7-TqRGdJu tf0zT$@"3v =i<Eup3P>sj`sնnnpX.O=V(^\}"0޴D_Y[5QcgF*NxA1Z-Gi) ݀M1nj@9/Sm@MNA qNb֩c"g\`Hd/e~j9-/Jjd6J/:px5*DlWO1nBRqwFwX1Xw%Hzuq1H|r I;k&;# sRva=yXqk4ևv]ҙ!^8<Ӈ Q4FgG$֚%]E gUMp(U{yGFoO$s%n؛&&o,A''ޮ5ĻcPs85Zv:k"s┎6H}jO9̄]b =&;EpyU"./9pn^MUZz'Z[LMR_JS@Jɫceܷ5?JʛtSajEҲJ'y$*?25 &n j!'5F%Zhp8j&Tx N2iz` .OSQ'ʌJXNc_JI\@AS-4߹=j>Peu-vʄ(l7ӄwdUn>RqR,{摤95e5v C$ 4'c*Q^J D^HAk_Lh'MZ b=3^hdDw89/OҜ/j GLPjSFsE?c"#htFFw֭G?aG/ZY޴U =q֑#'֚'֏hKhuYxU>FYKTʡmyd9I%sM]PSBB6ET52&h_Nb4",u"S$uf8ں#[*}jӼjق+5b4 zT, A b+b.RaީLϊqIVdA&LsuU%[o@L`ޙjF1ܸgsM0[WlU'й=QȞɫh.֗PP$y/ܚw3Vd bzӄUM䐱i4ItIi [G樣R9F/N85zԨ֥ˋtC5iւHDX˥VqW"1Hqں/OnMpk<75sVX7HԜ.!ޭ&jUde20^欢lSyg9U6/"8];>75XyK M*9lQ#J'&YN{W?4ܚ\dei -*fcֵ\H7 bUj6}*C(MkCLg'UIc浴LҔu\媭֬Jxԓ lUjuaZR[Q֣I5JvqS&I NZ444iCKtdx !Ӛ #iC-*ExJعqp#^ W;ߚȒW\fpku5ڠdp*M,9"Ll䊂WqH/5vB) S!ɩ>ċU\P;q֩R+B"@*3ץJFM7,@͊㊧)4E#֩M6*Y[<7ZV@Z'TQ.* h8eF8*F)J1Ȫ# (i [=N[fҜ9yiBNwȶA50\ԪW7&*M5CCT-HXI#D,`:Thf4XjQxJu$2d504&*mTL!01WUYX ҚVVN*⦞LV\ָ*R:i꜒g1Q&Qu.;4f5њnh\3K@;4 nis@@Ǝ| rΝHJa>#(AȤK/LXU~1* p`SYaVYc4њ?4晚PhL.i\3J(NN MJ 85B ;Z&L,kG{ZE݌t֭ՑV*(1}ژHd8:f97qI"G@H%)']]k"iIstpȪV47 iCwa:T7* SҡdVJ$\֐;iQ i<fk,J**(^qNKc:PO745lTj;C4ݔnM0Zx2*Sєnn7\2:ٳpstP>|{u+^)*Şc_.u=RjfBgU=jG54Fǒ+*_~d*v*dH& b SIF;Yj5b1ũiURMIyh[Tfg5O -ۜbj>8TPlz{Z$td*d]9d*9rҺd+,#&yr@7cbQdԧN`*@Iɫ"012R' 9O4K,>XpUe"EԊ">e1 Zb/X#tJyvؙ ;FNݚqֱu)5/&/[2J lX1dl@6QQ -9UYItjap̼H:֐RLV,7ZgE'/C"\}Z`C-#sM $5 " niP*)VR@N9n*T5с&̊J)s])gy$v)hl[9D8!&Z#Hډ]-4ܓWog5&*ZW`+jjx6qZ]r*| .OSOCÖ_"7zUX_>m8 ֑h^3DBj`64lj68v8=95!&ŅI28YW8cP| HTجMZR1+*Xo)23rqU9]z|;yG*CmX8Ky1,t[q‹PMF58J8aSUq6' |`VM$ $U9zj̫ҳIJ֬BOGU.H[b4aGFҗ+6iiʼְ\U5b>*=mЋ@Mz`qI&.(Lw1R Te0SqY0lS3F[&sI! (*RM>if(-iRSHh֛Ԙ;*ըb&.hD*H*MZB7I#LJldUa]JCVjmGj0V"+0*3&g)s68_ ԙ=kKƜ֡i S م4RRԈZJ(aviPi 4{f4P H R恒gޗ5i€p5iݩKVLNJuE]Ԭ,j=gދ ~zMњ,!34&7Ty4X khNc+Q BzVyVSR\6tGsZzb#Ep޺-7G[IrV&Zr1ޣzp/wM1KlXh@[2YYĦGLrqe\&EqU8IK`+`=MI:1xw΋j֡gM,bHJoٌbմ\ɹMXk Շ]۶r~PpW73W~GMԘF?ክsLH4Z*Wn*8 vnz}xʮjD8nH Ij^6d<֐V`>\}kɁGs֋ečhO2pk H}iie)!X,Np1 lֱnCJ| VUh0 ei_ޣ8QJ&/qI,jSU'|XFZCQCW TRTm8YgOQT4yCv(: 5њ 8c98*6;՘4F(Zy`R0 tbqp< ʧZnqWSdSJ+Jb#%=Ҟjq>1ޜn 8H +00iia3jP !kFInTW.-.r61P-p)BXK$j(QZE5ciqR\˴qYU54Z"T'$֝c)5jZ4P氞egͪ;SKR,v!,&%$tqj,n.Dl$wV.\Ubj#u'2"iҺKAصkk*i\6*ְǕf0`.du[hvjV+*JEEh86n94* i$e"4Oj'4"HcBSUdRc) sZK: ꔗ~Jk]XSsqךw٧I!cQ [QEf 4RwC-t4;4%4fZp4N GNNJuF ;4晚3@fyRgޣ.hFE34f~hG\K44R*;1lA*?NEM *HJrV$,\\(_h>͌v7ֿi*OU{x|qW:D7^N;S6he-dqsSJ5h8zW9p5!Ȩ SKL&k(iWb &$/Քv-Jr?ձ[kUDk #+(JyrW|FCȲ!$'iLQw_aW*Qٌ>J^] IUiؿ*ϩndN:(Әf$ԓQ1Wf m\3]q%ޭ9!-xqQ5p9),JƫsI-$!\#2;N#g:z;q/1~÷URC)VTds]Z4#͈­A1?cil7< R K. 9^jw Q }ϝn><$9)SHipg@JVAⵦ(;s]tRBag V0Y"1PL٩sNWjbՊ[zS^aڠ''5qG&jN1ֳ{U#ZzR#5af:r)fz;&)^#tܩ5i&S޹8=jwOU'uwSf5+֪rjLR9ipjPTF(`<ӀH:ԋ҂17SWgJ LB|k4jÒ[DLb5qɨmSYTޤ+&R6M@\%9⢁OsjX8y/ҫ0 FIVtTUjEUxr1,"ݜU8GQ _p9SSi&{QJ6ka(5W32Uϳ0+sieQj=) : UNn;S\hC)CTdՄG4⠞piueEڸg3d%|ըleI+-$ջwH@=*3Zu!̔ #c0r+NFGK '^tl 2yLM$|9{ӏJoz+Mj#oSL@qzsI߳Sig<۸$W2H=9;h\\ӑ$* SҜI+ ,1nzR^܈< Uq)QWb(i7 ȱM,TTmvGޢq*pjYC8+H+!VՄsI'gjG@s[]0 kSxVf‹u5Y@9ZO5qY4HXRJ.rjЁ L)y0=j5ĵdl*jM*9G*VZD_=\¤/U1ɮ/h+ ]?V( SURy4L"5"Y#aP] JDTPTQ4 #E8i(( J\R@Ġ@04iwIIN <5ilI4]7&3M" JQLAE%&ZJ))QEQIK@-%-fK@.i4 4f3HsE; 4f4visM&h٢-.iRLX W(7$DRyn@LUڹ,yw'jl\K BmSDtIeJ=kX B/$"+Npp+zOA؎$#`f;SqG]Y+`CyvNp*ՠߏԭF¤*Ti2MM-6K!P-,~xvŴGcY[D~D,_HqH P*W=+e+In;Rn(*E^Vl:psW8AMkNjԁ1:qQƆVwL5o\Re8* JHkUI+2_z+|<݅+I֠{TD2ŢsTVPd=iRN*Л XV2!UqVrZA36Lʼnj*t ̙kIUzmJbRОF Ȩy&5=bl#YH4F+9H{R>*sSȬ#5iy|tI"(=)0X1@#&πHM#%Ԩ۩3&Ɯzb@vґIRi1N%! ELS)iөCi 8Mi :im E-6 )3EQE-()hN6:JJc3M4 4SsFivisM4hP!Դ_‹^oAr?jjK)Ir}G_ِ0c\i2 S\Tg\@X$~2V]涊\2n5VU)z~F+Anu՝MR~5qiUW\K0 N 95mo7FV7[p@p'Hl p7v vC R#]*[AM: mOQҲ-hd A"Q\"R#ڛ<[$#EmͥɰĊ)b<9 m\@R}NK)J UjT,TZ=,%nX3.*" JVR"V"+zU2 sҴ#q+fW0Ȫ-bbQKV!Z7ȩ R\3TSʭɫܵV5nxjI.wS+'4Ր 03qJځ uNɧZX O 5$DYXiE>TȨO`DwtXzUx+*{d.(ME pMDɖZ~^_F;l+8Ur+ Meȧ9S5,s2 (ūU'uĠAKT8Y6 f&lf4:8-Mm'$VQZdpYə> bXիɋj5dq-> C1ɭiI8$EO˗˜֭kN" V@T3QҦY*ENJIHqֳW"|+d5MKq\԰ qJw B©&ў2m#9XSZw館_(y<Ո>UY0қGX8r\b O$bzUb 3U)4`Z~Q HZ#sP5sU&횷,sU}n3aHȪ )Z_8֑Jj6l O1Z$iq.Ԯō&1֚VsVB[:8̊J;v(bLPqMOm%-%iH昆i0#"im;SM)vZLE-%m^%b\MsVܚ[*W4zfbkl&VbqQkqVS6)4{VoAȭ=@u'h$Z5p=E[K:$A\OJ:ݛM@LdcV8d}Po&qZ^%&ȧ@Z+JUΝLrq&ffx lZvf Ԫ;&״"'6KVe*l;5>2*^iDLO0*0) MGO1C#LVtd*Ыf?ToݓY8w'=MD)OET;j->*B* <9e5fHqU$mҸk>yDvBX#"$Qlֵ PWccW&f١Ϳj+c#ZrAlԐ'5ц,.qCcy)-)^iDXɓMQHĵqM] 1A9&@MdՀPV3ӑj&Ee)X ҎEe P3<҃IԪ lCfUq֙Ҕ{;p0)sLHNM*@UҜڂ"tؽ} BqU0 p|׈*y|TnQ ރW+ji뗙 yM?wP\E <ӁPqt\vРtck+UhDG!WsSCcEɥ!- c"DMʮsTCRod+B5ͿJi(6\gcfysQv+fnNyy[P+ %ʺqcN;R*y[ZknoO\O::+ZeagGXPcau/V1s)qkf*UZUaV͚Z"<|Σ5w =>v~HFuEE9&m"SiӦ2"2IR'"-ؕ^28w"ŋXKZ=ńyj+Pl5Ns_Yr;ƞS*eJ>*tZT_j-a)*u"k\N|U"sJ iH!"c#Zj-hmSVزgh~kGhQNP&sNqEIhⅷwJQڜ@8QRqn Y2sTvu*DeRN9#D͊rC%gj&4iIyRi{N1`8j5,rjajHEEH B50eNjRȢAnI/֠kڡ23曩q6]ޠ1u@R)5pwW )O&c[a ʁҦn*G1Hi4SIw(n)8bF; F>jb\=/q7kxr ;bqtN¿ ^E . 8-N~aYz%vo\d7"H~jeBKF<$1 JwcvO"5ww[9WLNs5LGp95r̍X}Fqx҅?zcI#W{p::@Nďi*nbk_:tfRŲydrJD%$yH X'"@V&9lP(L;Uuݳ=:09WЬH TdM;6"nSژd>5Tc*XF3AsոM QPOZTMcIN!5(~U5n->G+%ބ[l=/YWE<5V# a_5 (j)954"97]..̷ B0jtawsE ,aqMxԚ3QAkN=NF-T.H]8g->JAS#Zd*LSV>3M.MC,`SJ:ip BHUɤ|ƣw2իQ0iYYAaIiiБZkRl~.34zL,)TR)5( =Z4pֱxwTŴtժJ "tAjvc)j'sWXT. ~MJ+K.>]AFW1ŷtJMIccb`?pQL.IP,yircJBՈA֥)S*Ȑfj652 δf1iE޶PRb&+^Gj6@N;RnrkeɩO5]Sq3{ڕP0f1hf)ƌqV1E u8Si Kފ((JB)Px⛊ih"@cTSTL5&ӊlu6)VxqU t4*qTdZז2{VssNR Xp*PM6ޘ%PKIE:IK@ )i: ( Sn(:n(:3 ^h]֤_Q(9* \°VE<>8it6De%8\ \'jd*@XTԨ$x/:G2!ҫb1,FI'!9'j[[uc ޭWWDT-7*Y DiO4ƭPiN4Va+ CneaB8/#!r5O|>ª4#zcݴ,XW{<ު4;ד4˳ fGmp;ՍK=iv2p*kܸ&l5~@WU8XmS'YeMhohG$Ùv>XU*&nF2EC,zs:UvɢH++`j΅AWw@Mt@Ng&I5\Ydiӧ}HnlӄO+wsIQAN {ؑH-&hv4nJO)FsUUKUaq1N3*X3T ARoIX,T9S 6Df1lb$SqNAY!AS 6.UoN7KުVQX,ۿ4/SuP٩<*6erTK_^͂SbMv+s~U&##_6=kVHXNcrY|.E9)q2GfH1`*g=i$ ¡bML#$fT =jD=)sOZ h~FY-u.ŴZ&(b`"iܖK0*WP y{ի\qRu+1V"Bиڀj$SatOHP;sU/,"It#jFfJ(h@@ J)I4*C4Z]RSE-6@- (!1F)ih1F){ө\X\.O~) yN٭4ڥvG֩F0$R'ZɑRrhoH=Vi~cR63Ȥ3wwQXI=Nj}l&dn: hj& b6!G5VoK$)co0>)q/BъiDޢGnJiƨ5a pjǛQ[e58[*iz`S 'Nj$bsTRK9^r7sސ˚a`j6!gqA4V95&ycV AS[׿SV N;t^v*OsVgH#xc19gG̪=4]/`42#9{kd$jr14^miD7̨VhHMv堵)=0qPk^vʧmu•z֒-lmJwv0~Qle'gclRa%ӵ,Qh94L*9dʬ0:pVPu!y q"Бӊ ~yN`k:?6vT6/j#lb+|g$ָb-f.mԊmfAc<}KMӣ#H?!ǦiNT4)wa^֯''Vkv,}I^5ɈqSf {i\:iKdX&x !1YU;j68V0*Yv63iPN*!-֔4@lSIWk5HT<9CcP]0 8\޲)6OZ~4I\沯&,+={Mլl YMZN:7|քVVZ\t& l؍wwNX#TC4Zq ITfN3'K0#{O{.ye-`=:U&=n.7W/{n=(T155ܮxM7Jss1'$ka߭%ZQMSd*xMHSyEEJtVcC,CdqW=`CKF(R 3Iޖ KIKL8Sis[%tyd(JstO!Pe+;\Ou07l8ARyȅqM7 (5\#2PI5 dl` i2HeҔJ+{WS[4L1VTpnnF0GSD ˑ1{Ϻ&u>*SUU 3R6}"bLQwJ }=J2K?N2JYX2I}K3[Ǐ4DFY@=kmW=^}T͹h Ef/Z#$7;Ž0ki ȥI=@z VΗcW=-y@G;WHM)IT!iӊ@UO,GsQ–qRif“ō> Inw5i![bwX-l1[@P]-a%ԁPtVGcXWPOp]X ױM ,jv8ڴ繎KXGTRJU6czee-\)v|4ǒrI)LnuU\ʊl kFSdt#^Ikf23]6akPǒz%D܄2f YG8 fEMVEGҴpi‘f8WBlu &ZxULP LR*W&rj?'[&("F8HԳ e^ȫ ?yzMrc$M&`h^ 3vehЅ5 VBmޮVk֝K7&u[؛7^4A.Isp8oZ',ō4VS"ܷ2UZcchSӫJݩ(]JHPI1ޕlyq Ҙdɩ:5L$war!T_ŇT71_D-fC}PLN?t?]!1N5Liz] Zчs VA*:qF=ȫ3% 5x6w2.n#k>r8aid($ vV^ n4}ɻ<ڦ\wrFtϠ+2r0|9&)4d0>M.9ޤ\ba6@Wb]6qS9t@M7aMf*ť0DdfNŷEVSnӟ}΍糱Jt)e"\vZh,:CcH$kVet-Ԯ۷5ikNw6ԍꅩKijwcM'zBhr%$cZ-k=nzQRI!sړ*" w}kAՈUY~*W $C,UqLy[B,k4'3M cDLLVp*G+HBR|LVw0TĆe3=W(YArsSE8Dk!6]]&{w<^66E'4uL&J%{8\*!u3y]:dVq6ArmV a8qvƝ56Q魵eYTt4G5peԊ*LE)qN|1IiM6M E\ԨN$DIqrr dҕPeX4|㰤} ɖg+ǞՓB䕻 n.v#)릗' Uv 73 TD Yz;rY)IdI}+Kp[=i${KX: =>[Y/噏'4Ilriө PmJS-Ojvzzy^qQ&gʳSA? *s[jΨyVbN<;NS"ﺛCp<߮+"m5aPU1e޵0'_*VL*oݎTri73E0tdZ]uWҝFZ[NkF.(~׎-4czMU *³]En/Qq!=M =AU?Nj0;UK+9-JlƒLɃQ8SNI] b@*u)0pE)Oq6 RsȘC}iE_fЅ"w?(bFvJgs@袚3n g(U_d=oiQ ڃ&i1쳅E(4{]N!N#2"InXgnZ&ɫ*M4aR⨤']J공 %B[55L#gH2EdJlQ Wc.Z@]j>ҩ5 ,i*P$JȤNXS*SPl MIϷ>}y-ֳ֮,j c (i rKo5aa`@J"c0!SQ\!\'3Q]GFsřL=J(0rzN'nX <ɱ2M X6̚_!ށGSګY̬~^OkM&fGbUK,OZё7YV 2GYҕy3pqQrE@¬?ZD2R74Th UV"5B!W8;&ނUIޚdbriNiV p ZcKJ(!S@2(SNCtcnɫb ,j ԍLI$c4OӒ3O mK&duR[s{ړwsO̓$ 6IkTTZ5@4,'&wZ 6tsQ CxQO(;O]ƧeMԆrRa .[|ZjQZDobԄ*`Ux|$b@Y7+թc˜snP" SHt$JܭW=j DFK<K1hZ(!X]z_"]c{Ulci>TYC]m+(ק.k2Z{NGEY$sӜyTm܂w&?;Riz%֧2rYa'=^ !aaV-ms`+XEEk7|]2 ((03ڱ-r&>D-܊Xs6 w4Ig%qׅG ܧRKlKzOF=J{ Tӊ-:)sH8riTsPص %wn zM[ׄ.*Qq\ެ۰#mQJ(n.Zb2z mn< G7ZG? OUi,lK1nGEt={{Σ[R+V>d:˥d,fXqx&k,O| ⩷گ&p5ޢеow*9 0.A$LH ,$yoV$-Q{V'. ƒBo7nh6U! 'M$ld;FsM4dn1W5:\RnFNMNQH)0&"ސRԏ ֦ |rmҤMYĚi@V<499ٲ0) w4<ӶhUԇދԁMq7J!5Hh`U/~rqk3nv:(gO¡K@"vqhC_Vob 9+4)$m >Ԁ.iz{LNX'{$rڸ2)՘hU sJ-)ZFo%[S` Ij0jmF9;Ũj3IJȕFЃ֧BǓ֮5W*AI]Sԍ܊%i`jZ,RDL{P TOBcR3QIŃD87Oin2 Ky%Vq훌i؅rڐ)QsA"X 1S2M\zԊGZ!ޗ*V#R=T,ֱ^Žd`S?*)7 1Af^ .aA(#?V-7˚۔I35vP5Kn"ޏ+-׵Oo!7̏p>{}O˅AWRU,ѸPqP[IVkf.(' icPW5)b4CWsp Ms(XR=YTV ԋhɥ Oj ȍJn** +:^M^{MR+aVVd jr3MTR☇(ɫWrsW2b5qQ?:=÷EsOoOۤ֜ (m'$쎊*)Ey#jݑ;-'WTi%b1W [nGEsIs6STIEI+OfA)ҪH(h&0uPҡ1ZHh 9X7sw-̛rI͓Eڒ[Of+^#pW5mĶ>Y2y!еewּRwTV~,[&֪0.E BzAcڊ)=X=jZ(z(v2ģֳ%|餴E!C ŒA[W.G!Oz( lj^Z[J" n\Osy1'rǞIhq$(Oiiѵ8(]SUl'oz%yb}WTb#< U\ո.8(J"͑UX$QS6&ih-^Rhd}3JD66>Z(&S̔Zo|>QZw7ֺ\e#W?wvij}h,eۦ譴^=[ eO-!CбWmi;"QE5'R} !x&xV3^;Fa6E@].4AY3B(ԫ(nm'j`muN׾`cR4uK݆=qAss.RxQSvȴ豆:quTҜ=X]4Q]q(bޔx@0DOz($ny (L[YQEf`SEӥ-ފ*$#"R[̒jT4QTD4D$U4QSpeSs#jD_2P:ED_O* (ZO=ɢ2g1٪EҊ+I$FN0)GxcErhf'vU{ }h5RPg8N ޔQU?y݄߼i}|=z QEG"3 Rճ"sҊ)QmJȆWdl''gQQQEc;m:RFɢn&6yR.3J|QDzb5}S Eᰈ%|qQ+dEKajEFMW)(["Q@=hJ>+嗚d+8Ɍ(Ɍ˽bی{QEj&gWesSn4R=`&*ʘ5B큚(ٙq!gkV!_+:kKA4QZ NQBp¨QERhEe6E1Va&)ƸF(:C*M'8ɢhHpE xRb)(!Rb)bQL endstream endobj 17 0 obj <>/Font<>/XObject<>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 18 0 R/Group<>/Tabs/S/StructParents 2>> endobj 18 0 obj <> stream xYms8N5쭠X嗫"!#ٹ@B|=Hnku$cP!ꗧnruqㅿ]\{ù6n{nzqLHyi$XݺykkhᗣvmoxWnr=.#*"2+/N&a_<_{߻BeM%?rH_k4-*\Nr[J׮(ՓAO*H|g`m1o-YڔY[V3Qj{L&$Dwv;@ Q*n 2 jҙ (=MZ;XovV`'>\<IUzfV5fY_"-f ơ}ekAUKo%zAOhFSiu #Q4n"ZDLƉET{dXP Qɟj ҄u@O}UDuR=W+ ]o7ʥPul{6tSgro*FIF_&M#/?ciHgWbRϝ,R[lQ'٩mɔM7֓DZIP7֦-ʾiU7?Rz ?mG#gWMH8TjEHBygmQK*hG)l(qatN&F̨e_YV&H!p/&F g9` vfFp28㦠`"iXϮ[hvڔ^\G}Ύdb FԪr>)95[o$Ϧ9Y(MS[]mxHi Ї ;)m16cafwpb 3Bш:p/ږ\^ 񷊖lskN", e_&odao1lZق4MFN j|;ovdDF⎆>LYhE\3TL20wSb1Aʡr]1fmes}'čy X\|tπ ,#DjayN1c3{0$Afts2fg1-;GMSS#> stream JFIFHHExifMM*(1*2$;8JiZ0221 z245 CanonCanon EOS 5D Mark IIIAdobe Photoshop Lightroom 4.3 (Macintosh)2013:05:17 00:17:40Christophe Ricciowww.g-truc.netĈ"'20220230̐     0000$1 ,2:4Z5 l 2013:05:16 21:55:082013:05:16 21:55:08XB@fB@2W:02203100055622EF50mm f/1.4 USM000000000002203100055622EF50mm f/1.4 USM0000000000($HHJFIFC   %# , #&')*)-0-(0%()(C   (((((((((((((((((((((((((((((((((((((((((((((((((((" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?͊:tGZ+lqՄua$iNԈ2%"XET(V:p RVӄud%8%XGKՠ(<չ,uNX-3n2*\<7 i[˜TN64LPڜW\5TTHRT\BST<% =)\,WFʴ#ˢb<ڍ\,T)HRpP4\)L)E2%\d),Sd*%DEPUZҝP:UJҋt%hȕZD3J*VUeJLq:fK݇5w̎2ko&zR jJ+^+Ӯm'kьycj:jRe2-LMdޕŵ oM UCSE6R)\v@FH$担AZj w N]ddTl\,Sd* qXPUNIҠt*\eJ"VUZw"YdZ"Qqts ds\M|[LFM,ks]^ѣ*/P uIv=kS~L5`?9};Yzm#ӊqZc|n9s\յ sZ0\ޯOɵ8iV/9$s> c5v-BOS,u)7jji|YZ|w'(2Vo= Ͻ_g^I*{ws!mJ%ziF+;C=izf[VV{Uގq205UHg|*U85)s_2} jvkxT*X氭sQ;zֹ"Ɵbh,1ly#=kFsZBI3l V98#Q^n5NJzڂLیo[OuW8Ax859NPA1os2k_’A0ĜlT@ʧo]N"/A+s\Mңݞyj080 "{LW10^fWԬhp{\.!euo_.?nޛWRA'U8Ϩ5({+;3K{\䷻IM5.Tnur_:Yu;!>I᪌ՄfÝ|ژUdTpJMU?[/Ǡqԁ*wU8(Ovj#֪ɩUǾ}jڛg'ã]LAZ6YVxsDU銍}Z HO`ߩ0Q_,{7|gƭ F#Au\ϸ7=t𰌷ҕY4g_k<օ娩VVؓWSP:I15LrJ=Z\pӼ;]M$AOqܝ8P SǙNi j&m,Cx$v橫ڥF0eh` [P2+-ثCҭZύ֢HW,[[e8fKb%jJBB*ݛ*Zt(F:Iy1+¥FTy<Ծn"-S`4ᐫ޴' W?wsVn*Hnx {z$ҝ B 1g9feWQIMcVivJds> ؏g}X% ]4n >HbX ޺;/MEޫ&4>M7F#xx±NuiiVg_+${\GD6k&YAqkq#36p~Wq]sufң~koq{s<,* Ņ B>32¾UE5~aUHIAGZ0j U)^⥂My `OөBBO֝?rh.b:VcU-G#^O=V|⠚:zDȫR¼yDWuZ\}VP~\Y0~zN$@ɕu;PHqSíKDNDߊޜ 2=[$H@C:dMXeo1KʚG~Jc#*xnK#GXl \ :$cRZGJZۓ?](AtRPewqJ+аF8?^+nM#t >$ 9 =¹hc&\>;`vg:˕P#8E2=~ME:Q#/ ?y*΃ Kt \!ʃ;UTYpA<{W\3{Yv:!=Go ^->hY=^Ayd"2x;WOKq/&yUƵ{S1α#'̼uqqYcR~߈ 审R."+^AjI-a*d'V Tsjs+SpjlwUxT9fT2Rq8,a`#_Mi+$&GPr+Tܾ (m@kZ&J{ V͉ 9r?i1d| YsߏN*ԤP܀\'N Rf;~TTwHTqZq5IӚBďʠc_ڜsUJ k`. *2qYՈ."5NA 0eG'5)~LpA9SJH'r_S_4LMO&7z҉0:<Ϳ1QU$ި4jxeԸkCO^jޕ\FqjIo'cY_q5dv=RD#K ka%* #=jKK IcH 3TjfFV 5d}kaHr@)U=",u٨:m׵GOjfP$$sOTCΦ#Bzlڬ.3M>ϹW$֫[wJlXu,:_.UpFӂA[V\`՗$08UItLzҙx{ _jI &ィ_AMD qpv aJ2zWa9T%y*Vɥ+p$SS#U`iXE~jUTSN VICHrMTWsN/KE1lY@. iRF֧GC=*xUw( XuzhnH횄>j85M8ʂ*]ENFI#T[{cjng5ml jǗ'ښcmfpi"e<y~BJ>Wdq[QsP}@1z^`D\A.)T*2Tޚ$ Ӱ@)El!Ԡhi٨ԄH .ꎖ$5F)E 'GXI*R8h _zf#gjPN*ZX+.2sW!'k6hqG U'hf9Q`&/ynUCNxRjH4R-51pR._gW?zC2i[A'ziJluEJj1ӚFPiԔ "UV^j &Photoshop 3.08BIM8BIMhZ%G720130516<215508>20130516?215508PChristophe Ricciotwww.g-truc.net8BIM ^BAdobed            s!1AQa"q2B#R3b$r%C4Scs5D'6Tdt& EFVU(eufv7GWgw8HXhx)9IYiy*:JZjzm!1AQa"q2#BRbr3$4CS%cs5DT &6E'dtU7()󄔤euFVfvGWgw8HXhx9IYiy*:JZjz ?-,x Ŋ +X]c *X*GbXwbWzXޖ*ыZb*ŊhqJC4XCT*CIe!%I5D`B(yTqB&8B!# *⪫(TXUE^#W*.K~*OwVF[3q2ce: oq(&ߏY)/$p#hFqQE"6pZ)lmic66JciJBW ZVK֕|6T{kMm׫817ckHy%҃0)AғJ0қH1 $I6QfE)8m_󺜥za S;QdaY\o-pO})Wڏ_ m#|r88gYgm~䄘0^M0Lf7Z)3Fhci`QsqĝLTbG? M2"xQz%eW7F:df('W-iY- j0Ur֒JR \+mM-pȱfh} $eZ4F$^kũE$v#1g@kͅ^ZYJaz΃۪)D~Nw_ xT?H{ƞiRS@d1%d1~}i?*O⯄Ԥ՗ &x𖮮Hebq Q|r6 oW(U\RiJNqZDrǍ) oFl S@oG#T4Do86o1(u]" mP3DHXnoʇzS9n3 'o҃,)! ";W?@f1m MiX<]ir^+u֍>c/m]9-X`z䣑$k?́GQl{i]mо(NؒJAJȒBr6R-#mu211d= =2yZ'q+l1pImv I4?pTtFө j|iqz)n[G!IRsSn Iʌ iSEZkhiPY0Sk- *Ԁ9|mAP ׎*(&l*XWܨTa"b԰UQ]AQhVݸ6𔂋( 4Zm O‹E2%6夬>BF'Q0USքa3 Vb"9k0Lc։'~.AN09S joMwGoM3 0G'c=4n_wPjZt.ذP@4`\.( AFD[pc~"Ih5rF 3O2[BnrQ;9~MN:=vC'j1jHeesȐgod2Z +C^+[Cp(h~ڬk!: h[f>Y8 Cq0-Bh)C\d[ćþa* SQsU\4U8J feZKQ+VOጂVH[WֳȧV=pj5&24oVv5Ho6`w@[F̣vmȓC(5ki^vSM.ǐpS+Dׅ޵Rb= )٨j.p 6Gǂ4R(ǯjg7łd6Z} ZiV$z3g8DtG[5r]Z] !-6o]F ɭ.Gar=ntՁ쇫 eP>&ERhҿM0o?6u(8X,g}^XPZ~흺}+%PBдrIIBwM2$ZmNmIF $(CZ7B6Y*~ ]4-Va7ӱUf;%Z99Ƽc"c3/ʇlBYwlAUcT RS\n:/VW'#^Mi io/GJBЛX[%!|5g!MMJ#(:/p)O٩Ʀ2sre fV6d廓`~C5zymAD2*_] ) zk٣qdHw+y]OwuE&ӑ3ikcM5˝Az_P"j,}oL\?b?[ZApǻ~3yv*^v ŀC^Y؃֙`n)nUvXڮT-2{uJ_p|2i`pJ;崄)?~F*!6d~?Ki\ܩ*R1@#݄A3|/YGH\!W M  UxuR\qu JQ0r4YetU* #*~=497$**+wG eR'f>Jufc[G}߿l|}:CPU|$;&vd%ŴlfP~0;P~-DdEcO֣rӔU&(I-iQOdba-DR5CXM)C&!#lj< AOUg+-IWC&(}.!8}' UusimrK2 o8B18S2q,SkrU&+9"cӌ{[y^%fFHe4ӛry_]HdVҭhTS2SIJQP&2; {)|L@) *NJA(+,;v"Sy$凒6$,rj8ʤIQ rAPQýz*U$G݆Av%I mĸ)eڙF=ȘZ+B = K2`Zh=FBc4 %HTHc"w5~Sĉ]A)_6QG&]zAYA]0FXELRY`gnu| &/8AKT]gqz !-8COZfr~ -;HUcq~ +:IXgw'7HYj{+=Oat 2FZn  % : O d y  ' = T j " 9 Q i  * C \ u & @ Z t .Id %A^z &Ca~1Om&Ed#Cc'Ij4Vx&IlAe@e Ek*Qw;c*R{Gp@j>i  A l !!H!u!!!"'"U"""# #8#f###$$M$|$$% %8%h%%%&'&W&&&''I'z''( (?(q(())8)k))**5*h**++6+i++,,9,n,,- -A-v--..L.../$/Z///050l0011J1112*2c223 3F3334+4e4455M555676r667$7`7788P8899B999:6:t::;-;k;;<' >`>>?!?a??@#@d@@A)AjAAB0BrBBC:C}CDDGDDEEUEEF"FgFFG5G{GHHKHHIIcIIJ7J}JK KSKKL*LrLMMJMMN%NnNOOIOOP'PqPQQPQQR1R|RSS_SSTBTTU(UuUVV\VVWDWWX/X}XYYiYZZVZZ[E[[\5\\]']x]^^l^__a_``W``aOaabIbbcCccd@dde=eef=ffg=ggh?hhiCiijHjjkOkklWlmm`mnnknooxop+ppq:qqrKrss]sttptu(uuv>vvwVwxxnxy*yyzFz{{c{|!||}A}~~b~#G k͂0WGrׇ;iΉ3dʋ0cʍ1fΏ6n֑?zM _ɖ4 uL$h՛BdҞ@iءG&vVǥ8nRĩ7u\ЭD-u`ֲK³8%yhYѹJº;.! zpg_XQKFAǿ=ȼ:ɹ8ʷ6˶5̵5͵6ζ7ϸ9к<Ѿ?DINU\dlvۀ܊ݖޢ)߯6DScs 2F[p(@Xr4Pm8Ww)KmC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222 " }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ? ^)@ pN P( @SR@ P)@)q@S P)q@P(S P)S @)qJ( bn)qK\Pb 1K&)qK1@ \RRP&(.)q@ 1K\PqF)أ&(.(&(;b1OCqF)إ\SF(Qv(7b1@ bPbRP11F)qF(1Iv(7b1@ bPqF)أQ~(31If(?b1NRb1N&(Q7P1I~)1@QG1O!)1O&(v(0LSIf)3SȤ"1NS2)1RHEFE!!PdQq@␊y@HEHE4aSȤ"#"B(2)HE#"LR2)TSHȦRM"M""E #+L+SM"M"+M"RM"܈i))DRRL"ȊJԥiP""V+M" L@))P8 P8  )@ pJRJ.()@( pS P(b)q@ \RKLR (R \RLRb.)@-bPbSKn(;b\RP bPqK\Q@&(.)qL 1NSF(Q`7b\RR1O&(Qc1NSIn(;b1K1@ bPqF)أRb1@ &)7(4iR@ "E>a)RP1SiPO"i "y)y^V(2=Z-ejSUժUjSUCEj UCS#U&KE5*ST-RPrZ% D H 1XS0iHp u{ddj HM0hVQ9ֱFmVn޶J6՝դz22MjՄj362TV!ڵJUUUjh Uժ@ȱ84jġ!A J aӳQ5 4yw FiA,?4f3@ F (4 4j0iAN $ D <x4A)4@Mu4Sii)hh))i(() -%%!)M!4 &4@h74f3FhGPhӁ@4is@.iњIf4њnisL4fњ3EP (Z)(EPQEJCNJZ 6HhECHiM!SiM%!JJ CIJi JZJJ i4i)h4m4Ӎ%i)ԆMiCJi !q)i(B)ƐdRO"hE<@MHE{JXFMZFLMѪoYf7c#6$zYiIVtoҬ#ֱSUzZ&f\FLV ժUjRL᪸jxj.+SQqX5(j5L5Du CRp(jpj585 f5P\,H JCRQ Eb@iAp% D <Pj0i 8`;4is@L8SAu2(m:J(RRP0i iғM&iM4)4i &Bi & 3L?4L(4\ `4 4If4晚Phf4?4f\Fi4њ`4CE74f4f4fsFiMQM4f CA4 (4 M&HMIM!4)4h!4Ii4A4!i(M&h4aaM4MR)(i( i)i(4 4h i -6i0pRS)hSi)SȦx(4Q_>{SijE54iVQ14^F1gTdfѥդzG1k(hicֱF5LTQ=hfqZ UUjhrlX O USSN Nbj]jP\,N5@5 SSL JSTL5D\,L N Ebpjxj.% D 8ĠӁR@N <p4iAN 8x4T)N,-Pi)M%!C@M!4SI&M)4h A4i &M4)4 SKPQ 3@j4f0jTaCSXpjpjAb@iAR@f`44њ.K4!4 (43MsFi4visMfsFhsFi3Ivh74fM!4@h&MM!4I&Bi &MsHM!4I&Bh&4i3@&4fsA4\,.i3IL3M&hXvi Ӹ HMIpA4hIBh 4M0.; M74HM Bi3FhLњaaiBRZ)HiM%x-6WϞ)p4J &SRTJ25TVU.ը޳5hCFoV1dDiT%jfh՞VE#7jxj UM!᪨j5;5@,X EY O UCӃQp, USSY N USQqX585@bpjpj.,@+SQqX5<5@Pj ԀPj h@i@ D M7SX4nwQĻ T[ Qqؔ!j!j.ZFZZbBԅ2ԛ\9GuDZ4Qnu Pu;ۨPrlKh;ĻQfӸXKH)k=qii)hii(Q@h4҃L H H j N,TL5HEbHTժEz!Xs ŠO,XI-F\b}R,Uj_j@u^WAUz"K"Tԉq.Jpz|ظT z^+Ip5HU&&!@T5HNZ R+UejZbhR2w SUԪj,)TԠ04j iөӅJ(Hh3M4L4 &MDTMRD B e"65454-p KH隀 *)^p3PF[eu#*;TP#1{*ql-U9>rvmY2}pT™ QV6pk'6hf\*-CKx[r]$RE\+Y*)6S4I—AfU#pqzfisZ܋K4f&hL.iV\{Eě-Q;Ra7Te\v%FuXu-nb]nRnb]nwQ٣uCԮ%HZ-M-JbRzioz9JZZ-M-G0IKRKR>RRjij9ĥ"sũ T 'HZH^`9ziz!z9bMMs;U`gu QF9,LZZ/M/K,JZD^^0LZu@^^`9jBzBsѾI cu.ꭾ=W0YF}LuAIu.u&(Si㞠 u%( (MPMN85<5B585B jA@T585W0YKO,O7RXu(ju(j.' O USQpmZWj*Rd\Raꔄl=HR#EzZ+ԪIt5HԪIڵJUejhS+UUj2Z-#TUCT Tj5L2 jU5]MJRPRL AQN4LJ 8i4ڤ5ڡjZz2 TF#&/p{\X.}{Ty*UV-8XRkbe*-Z& lkmSp0s\Kr%mx*͜J"顜+`X7a.IC*~kt.y$)54XtfPZE QVsJ8ʏVTu](#=2WǤzGj.kaKEscIca)YN ї\yr{3ILӸ&iEa S SKQqyjB\,8400wRnRnq؜5nb}ԅԅXuԛ\v'HZ-H^X!j4'! >RbN^^/M/K9I Ozaa s'0K|%!ު)J|bђU _z9ţ'!i<9ſ3ޏ2J9'(z$Q.RKީJ9[Iު}ZI/O9K꿙M/K|zBs!z^d,*d;z<ʫ{|zj@\RbJx.%ꨒ2HR]T=8=R.%oU+oNӫ=ii)h (R Z3@4PQJ J585D 8@LOSP E۩CT ӃQp&iCTy A5Ej04Y O USU) Őj2Z-j5R.+TMZ T djSU&KEjZTiqFha2Z-TQFL͢5N#U5IaML VSRI85 55 4Ӂ@A4&a4 dZjDƤh#&B*Vm,6ֶFF xǒ߆da=NJ(\QZH1|JZɞboyyاB V= ; ecKF1{S409)T.TCA@xi:w;S3ɤ-J;;HO5 S*b mUƫf,"@YY~sZ3g# }Q5,4lAk#%%ty6vbHM!4iBL-A4h)jiji4Ԯ; ZZFZaũ TeK7qK,MzBԹbmsK%J!OzaȥɒdZi0KFOziު=Oz\-y-V=J\Q,}Oze=sY2{ XM2Q%4U|zi`-}_ze} ̾oT}]<֐e,8ER#eʷqR\ x[!gP%wtȩ%V,UKznX :TѐHPC9Ry*ʲV-%KLȈ;6 P$z 0IdjI&Wp;RQҒsNێAcq8P;[\*9c*qWTGRYZDWHԣV8AZ$FyiPm'Ϩ pƯXc5a6*)I8?yHY3?ZS{T;U'Hw\+' Tzd|`{55ԓвSSTsA)2zWzs ϭ˸j6f^4Zkh+,F@y2GAyR䃚-AS ޶Ǡ_d:gV*Qisق~Ulc!T F>cl\HkSxY%TRj dkI CUE-^+mj}oVf} Z`"-ȫS7=DH2_zJJ_ q3$eYNg`mB><@Z6|͗69]̺4cuԚR\mUd]O̢qv+;Y< p3zc9$MNoucG !1)XmvY;X Pf0yIY_m.K]9^hn-*E#`^s_QK.xkT}#j6W+C Xw] ȯ!A;I{aQ"+v=?JؘHg^.YñJNQSI96P F4j)-ei!4iI]W3ƢcOcP!,5 CY45Hc5DJQ3T6RffY-j#5DZ84FZZ RnHcPZ-I-Aj!j84!jaj`80!jBh-HZM!4Ri &`.i3Fi3LBsFh٣43Mfs@4~hMcFi4ѺL! SIM!4f 3MsA44њ`?4fLLњ4fa S3Iw OKP(RJ+PE;b(9 v)@qHEIi)@RJ(8 P)@q.)qH}(M8 @.)@+hӀ\@ E@)RJ E&)Rb@)@JP)RE;4<r GN0XUjqVQE"$[VtmVj23/UjVXɢ5NTѪej2!HTid585@ɱ0jT[wSXu,њ.+j Te$+7jЉ@SjaG+Ւ FLA m÷\itYIyne/I=I5[q")n Y3ʟj) fX+sy;}lS/{/~[]4^e=vQ"7v2=b")$d^KUq;n-̈0K"RV `OjQs43.oL3[B@Y[8 FHȪ 3,D~R>R+WH8 uΝ2xtM76?¾S^|W%i#ZDc ^b'2YU# _`[LT_6Ÿ c+٩՜($Q9<Ղj M{ڄ592=kjM} %E$x cQQl1ӘLj)!j45 C,5C,5T6RƢcOcPlhBԄHb4h!4搚i4IA4M74QLJhS4@&i3Hh0 fZ3EQ(4PsKH4f4SsI(4HM4LM04њL44&h04f3@&i3FhR@m(R R b(.)@4\ v)@⍴qK.aiiiQp#NV\b@)R #@3O<*@+(8 P)\Q.qKP9RRP(8R v)@@iإ@)1Rm+)qN\NqEzYFNvElUڨTحc"45f.N*o[FrF5NTdj23hR*hCE\5<5Z6' K NN.]7QqX2ԹbBni"ԜHs'\n=pk-Xl AL KӔ\ndA]:E!C*|&)Ӥ쎮Ef pxNuxۏݖP1\YR(Uc\$)Y =[/٘VT8@1__BTlڹZ#dc$j ypF71'i>m2zm!x5vSg ?Jn*;yɮ)닺5o Jcjxv¶۳ F5\dVIܾ@,Ku9?%2zT;LFFZ\e;zV0e)$kkbTyW8q2`v6>J޼Jz7ew) X: %(&%[F~aڟt,x ny1=}YV%߱8fhmJvz~pfvEL!spc }cevL8ctXI>Xp*ԝ=ZUW-[\ҭ άq*B)PJA1XCwrīkCI+ Q7ϨbUc傂v>U#I?1Wu UE q5-w"U"j#OGq]v8TR*2ZF+>gdyxaCTC'}+/RHe Z҃ISJ~or~Q\Ni3sjjL55N)#ʫ79\qjijM#5tsRe-QvZoT9 O FLh)EU\)8ɦ㹥'.1fiqJDdSHEFEIwS"3RA\iQqA)U\M"E HTejhbIڣ Ux5 Ri*B9""*&ZVeLdU>=#ګH79ӓ,_ yj[,Ո1I~(j1IiKP)hIjR)s@N"n)1M"i⛊b#4ڐi2ӈi)i;R@ 4S (j!⤓GC JŐ@i`;<ӳQV\zjB^*.F2⤦ȻZh$^gHzRҀ$SA ZTa*JZ) u3 oCS!NC@O^j¦NKb8jZqsE)if^kiĞ sXUGRq](TzR5G5vƪU 7mN Up#!.B\I(H&#f( q+h4b)TqHG\RM"ddRqbhKF)أ3SHiqF(_VaUV?1dtjpH]UҹF<;vqkF9!uϱ5!*Z[q`鮌a;2j֠-fA,71E9yF8#p}ٲ5'0+x)Y]pb18EKim<$)(%m=ǀ#>?0`jpQx, )$QU{h 9{;pσҳ][8𩖀LN,j"\r l7M"2FҒ6 xSbuSV?"m?B@h6 3L'Lr?8i 07jDثQ!U9|Tƪϕ|cm@)7U2ٮ@$f]#ޚ2+ȯQ i+\Vzv`ⴝFѵ({TmY^jpy ՍOV{@Įy2h "noܺk^HLJJ˴t1dۖn Jv@yv5j  2GUm1Xאhm\{g ljd#dʂ9RFM\u!\VكHnG;W#H@*Nь`T+ $=O<ޫƭp*Ae- mǥV f ҴQu:Ѱ;Vf LZՊ1\׈|>2Da_Ú+[q] \EAђspG:L :Ek6m3Fw\4懲nMW'LAcTejO`e*emw%1\-El2ߥ(]9OVߡ24N'c DnjcjXRΥ$#Ut(V_%z1ɥ`*5l{`@PCV֘*#ݲk<&Z_f'<ӱM T=Gz m j*?'ҔloE3ږV˚zmj¦oK W' OF'McӳkX84H9hcu{ZGPա-Q0!֚tQo;aIi6)R *`do\Cf>ՙ hȿ 4[)xaI+66:7MR jMj444^i&&'nXCh r~ٙS [cdpxCnYFOz|;ڱRT NK;eʀ@KPnD gm+ic?'FZғ0RiA uDۧaM iJ789CU~b.F;?JBDj8)w #F88giqMjzԭQwBEWsUfORS!Vh?JlE]H ڮXX>¶i#5*wZa*D (ZsUwEb bUM1\epڪBɜgGm)\s'ғсDOJ O`0e yaph&piyҚLi K` T7*r>+`P˪R2H"WaJTGăF\X6[|MS

ѓ<Ҳ";тk!9BwPkEx)š n K=@s]) xj{v뵛^45^sۭݬ/+Y-Rz %I$g-zT0猤t8Z?*Uw]ēJ, lӥoOz[ Z{cZm?;h8l+R\؂TTۘڡԯ!b]STO,Mh ZM4I=E&yFrrAPdͶ~d×,zU{HN3ZҠ Ju HNԲ e ;ԽdJ(aE4*2h4ij2jF#ZjYO5բGJliALxXTʞ-%?z6QDاD;s_jMtBأ 1SB̿Z6Xc֘$ yM=sHB0ڵ^CJ횀@`8`}+BO@+15~ѷە%=ӧDT53<ғ֘O5@)9fҀM%fý8uJM;<Ӂ=i)BN4sHM0#ja4yɦ))C4搈ig;oPXr6U("V"l$vCfyW-`JDvVFISRܸ5J)NAR@ jC֐P2(R/QF89@@)<hlHU<a9L b:*sU+`.H  [*5\6E=O 4 \qQNӵ5xlODKf"ZgUZx¹K`E7bNOK ecVS})0 'qZt±=MNN*,­ʹ&_U9#SPޠDGKvpdQ '8"NU`~S3EZW)S]8:j2idŸqn;TG+rE~Pj)XOҜkm\s U-F~F:Ⱎ=͍9$zEEi#q[ČqS A@.ZڂD>lÚLHVőQFXW博PM2(*#+ %H¨[ښ_2C}Fk ֔'mg(,5T#ɧQ芌\V k~gˁʴ2v$nyS@eQfFjUS#mjA#ɬE%q`E8J{aSʪo2g"Mqba 7&֫ɐi1Y4G>\ hH&GqY0Ɣ4)SOޭ4cM'L c&K9N*lեgSQOD[3( 0)7Gr)JPi ø#lʿJKܲ۞Jly`6E88SRn{zM9ir4gM= BF1lcVՀxXOre 4֚֟EXHM&jZ P±r  G"0J ҸFD9(sHF !lCT𞆫ުhV:jC J \#J {0/2} vBxhpʣqg`y3XI˪91]w8h+%=뾛$,Kd| +@I p9ek&rT5%)6I9DpBT I 7^GzOJVjLVk7_McTզlcOcH\q֧e*rh^(SW-rGޚ Gi9„G JGl)cֹ[.HM:'$4qZX.Hw#4 XP~yEr=5, #֝:]³ZHEiqI3d bnjRi@zTmcw˚9>ԠP(O"j!43$~rt x>¨^CҪ\*pVkp 'S B9@TDsRM=jm̷(zQv M`n)i%ziM"CN4yZ#3Hxf y4xO)N'ju Kbj'4(H⒜xLaHOZLHM1 H4Jp8Ѻ"O5@8i@4Cyu)"jL.Iϭ4iIT2j@掕6n=nM=ZW(n:gÁ֜ SM 1K`8r)i㯥 V9eDV[5c9M&R⇨֣vE=xSv(Zhw6Z@pFڒF,ԛ)a<RVCb%s,E[wjve1K|£v2qɩ BXgj3fI~U73g? Am+\㱢EW`@4^\2VԻ_Dh[%S5tē(mWm 7L-HՆvr٢cқ{96oN根p񓵇&/o P1*>sJ~' 7,Lhxr6*RZܜr<|ǥJ98W1P.dcPa]H#ˈ FuDvR7ƭ-:8F+964rj/tOWVpsֳ$dœx tc ǖ[\+4@&-!mdӃ;s^VqԪKݎeʤw ՛Kaqw`.˥ǁȫ|H@z>[(K~E }EL{bg8j'ZyT)I)кw#[yee0Bu $It5)Jpm2dusCiq)Ed35E0 ts[ԥ/u΍UG1nKqځ&JǫtIT9F02ݸ)bft݌Q=2hFg a)pŅmj$^zrq\W, WDZnyR*5/ѷ`d֨Tl֍ I53Ot:.7jE;cl#= SqVZ8ɕJkNWZqV-6!e ȨSʂkk"5RmAW` ; jC?|UC֓w`8 P#d Uh]zU$.;qQAG#n9^;Ӣb_.$ 8Yvwd7H=c7ФX-0T| THZg泄n7Mj"D5f&Ҹ Q¡yN pw(7⭻jzH5-j&x^jwhR- DTHA=XHmtm݉˒N)BԟZ֙pFCtL/mIVH:V!4E8z 8uu7~KPC"TүHQbƈ9# !lphAQt|-@jVRjjtQQSJ xO4ԀPsO-DNMR QQb֘zԄfx%))M!N)C(h *!<ҊB( < bPx4&IIz\^N'"Z@ism$V[&C$4qQO)0%`ԀjH$T 5$ўNASI0 KR ɥ @E(㊖椣M([kI[ҷa:E2F jeLP̣^bГ̵Y*Z["79xa8$v֤£ jF$2HUIMZMZZe(@SJGF*^'-sҠT6\9PXbjոvHM ˒9&+"v8J HCQGmv³ewҸ#ΨȻt$qb~L-ZZ`;*N'o)+Kg5\Njr:8uPm&'3U}*ͼyrOaXF`:+Wu6 NifP5+U8eYX>iwLj"٥FrՋڊvVLjYZ~s#$b9Ru⮤`*ϵTb1-Cg9`x*պ{! sVQQwQ;SIv}*"6vj}'*n2qUTVpЕ8&MiPFq֡ ZC&RF6kD@`⧋p`ÌR8i LgΏުث1 (=*7[eF;ETߵ*m8@ UwcԲ|sU%)*2a@vp՟\MSU-E0?́Y%y.Z 2je!V[TUhf;@5cC Hiӭ) ` Z[VKDQOzXܪAmIՂ5Tm'fjl"msE"G6O`kN儨1,s Ri5olsUdՆnrd2rqx˞7m@r5 7&sJ`hv7=Lˆ4п5U>!S*$& aPY`f/BjM-RIs@og 2AqcmOC֠ԈC]D3HKm=)((U؜ZdAlXd`J?=&< cDzz݆#|cڮz#eN\8S"rA<ď!MBH+Td$!O3[Mlݪ !9t2I g@O542Ub=#sN+( S V=TԮ>]R, )g\ҕĊc:֝R+Q5+xޖKVAEPIKZZh44Q@g&SiLH QNFxFhNKh4?COx5sXzR;g~iԁSiIiҀqHh4$ERxr:ObiE~xAHMFBO44' !H $iPVBxآ=ۊ'>ԅ杀O5 5Un`S΢i$[iNpNVƣ`,90<B>2k*Fİ?yx5W8LۂqҁMA74 yl*ib0 RB )& p#x- 0TRRȨ4GJ`8g4E%-hi3FiQE)i(Q@ 3IK@ viӳ@ NPE7-  NJ4Pj0isJ%hn)I :M-0$V!M4H*R`I)M4V4i  PO I&a4vnt'3.I4&h',ӷS&h!4NPa@W qFERctӅ8SIK@:R--4iǥ0@(4j yIO" E0zxy4iL4!M'qM#}M<)sSMS@#@ ?6p)S)uenynzTAR)@!L?HޕBɧ+M4wOD5 8`<i`dT`ӷqH`Z-85Gjg4b )sC57Zj_ᡈJkSZ@6ozp40Zi;sASHhTST8SqTdHGZaTSiQN"@7.i(<ތޙJ(QGz-HE&9b(S*B8hc 4B84 1NS)E%( 4QE4OJqLc))i))( 4SF)i"e46 \hf By@h4  (4 EU)i((()QERRKIE.hZ3IE>h4fh4(PiPi)3Fhњh4@ Knh.i3EN64Pi٦f4њfh+ ~hf 8SJ &ӳQJ !fiA4f < A05`%Vf O $Pj0hhM<њBh:x5%My J)(sN4)í78PPE Ҕԁ⒜i4HJEFE41HifAAPhZ j1֟)0 CJ 4(=)KLCi@ԢM#41@ ^i&n9=iݩPQJzTg4$sM""G@DzSiIAu<`)@N0u @:HO4SҢjy>/Font<>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/Annots[ 24 0 R 29 0 R 31 0 R 32 0 R 33 0 R 34 0 R 36 0 R 38 0 R 39 0 R 41 0 R 43 0 R 44 0 R 45 0 R 47 0 R 48 0 R 50 0 R 51 0 R 53 0 R 54 0 R 57 0 R 58 0 R 59 0 R 60 0 R 61 0 R 62 0 R 64 0 R 65 0 R 66 0 R 67 0 R 68 0 R 72 0 R 74 0 R 75 0 R 78 0 R 79 0 R 80 0 R 83 0 R 84 0 R 85 0 R 87 0 R 88 0 R] /MediaBox[ 0 0 595.32 841.92] /Contents 21 0 R/Group<>/Tabs/S/StructParents 3>> endobj 21 0 obj <> stream xmo6wKhPHl;oNop(n{8%2=#E>Hd?ru?/7*ʾ]_ݔMY(UmU*k.*׿\_eY7߿e/o^v[i,JP?WeѴYYXɴ: :yx}i~-o_Gl5d]iP%=VVfJtTU4dxblsU.^y}~~Εi+j_5im֢iڎgHD=}j77y֮pvlO (МY.uh}^}#o.WwUw: pg;uq2{uF ;DGYKZqNAm5ܝϷ{lx,p NA8npUm?ղ>d-߲:OAw?@xw |W([vw>or5~5Ԧ*Zn#6QT9R<)*dd a2 :48L_]} ?0kjIXmn1_M|^,dUL{dq$J=y6d YBF,2E4eMP6O龂WԒ9Q&YQ&lz*Dϔ>>GeM-|?O :ۂwF؆U"!۸PsӶSYj2 D8zDÒX%z e 3`҇>l|\I&~ؓ+/|s"* UW$mu>y򫾫"_E c;Eo.z>||U>åNg:uMqmۏ/?>UW/YrxQt%V%(OQՏXARvGǴleJ,/4(%ИyZ:S%A}Ƞc b5trXV[ifslU|J ˜`GlMK@'mAe `2/xQ#Eb{]h6dv]h|"UrQ{odq}dtit8q/k4V1]NF! ["8|Dwk?ce m9E.#lh&җpv $l_N7}6(Ӵ肐RU.1cZMĽyz  TClj5 ȁƟն3 fnS){8٢GSH QVI s2m,&*mL+։{ h3պg3|.s?dwpGkه}թGF6\iI.vH0+UsiTx#HDd19ů}}.TxڿCu aՊBiYB&#SƅDFt7A _ 0}s  SZjs6w˧VF dj^ ϗ7WjXQc$Ǵ$ 9O~b!),$>$HWAxI∍$Zu7 fdƅ̲M7m&J+-{ DnJ#0[؇Ll:`bV!a`m e^{tǀi^C#@k;Ja2, g1;7^ uw82d^>hxh:Y1vA xE2p:Ńx4}MGf.QB1cZLN^¯r1Ok[;EȈ[:B|֏db<ƴٚ-{ 3)<̉vu!"l$[^Lv=?szܺ.U5Zi1v/g>V8-{ drf|IxndjgtNc7%UIr`7OnNYk$U¥ÖcuW4se%ji3q/`pkLoӴ b_r g ȃ:Au I4.eVzW%l@vpK#[嶻 'p/ >)S>YQ8ppIuϘOc[>y)Z&ܢ/Ea܋nf R7XWl֏ 2hsP$SLYؚڞ~U$AG;Fm^'G3iE4"[tC,xppNo:n-]pX/Rc'Dz^|g?NWDhk3wѠ .1߅>sνcXsHTaCds$foN +I^z/rb(L('I/=8*wW*i_8ӗNcҢ] d&Z6DDІ- ? @o endstream endobj 22 0 obj <> endobj 23 0 obj <> endobj 24 0 obj <>/F 4/Dest[ 26 0 R/XYZ 87 769 0] /StructParent 39>> endobj 25 0 obj <>/ExtGState<>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 90 0 R/Group<>/Tabs/S/StructParents 4>> endobj 26 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/Annots[ 138 0 R 139 0 R 140 0 R 141 0 R 142 0 R 143 0 R 144 0 R 145 0 R 146 0 R 147 0 R 148 0 R 149 0 R] /MediaBox[ 0 0 595.32 841.92] /Contents 137 0 R/Group<>/Tabs/S/StructParents 5>> endobj 27 0 obj <> endobj 28 0 obj <> endobj 29 0 obj <>/F 4/Dest[ 30 0 R/XYZ 87 769 0] /StructParent 40>> endobj 30 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 150 0 R/Group<>/Tabs/S/StructParents 7>> endobj 31 0 obj <>/F 4/Dest[ 30 0 R/XYZ 87 738 0] /StructParent 41>> endobj 32 0 obj <>/F 4/Dest[ 30 0 R/XYZ 87 387 0] /StructParent 42>> endobj 33 0 obj <>/F 4/Dest[ 30 0 R/XYZ 87 173 0] /StructParent 43>> endobj 34 0 obj <>/F 4/Dest[ 35 0 R/XYZ 87 601 0] /StructParent 44>> endobj 35 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/Annots[ 154 0 R 155 0 R 156 0 R] /MediaBox[ 0 0 595.32 841.92] /Contents 153 0 R/Group<>/Tabs/S/StructParents 8>> endobj 36 0 obj <>/F 4/Dest[ 37 0 R/XYZ 87 769 0] /StructParent 45>> endobj 37 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 157 0 R/Group<>/Tabs/S/StructParents 9>> endobj 38 0 obj <>/F 4/Dest[ 37 0 R/XYZ 87 484 0] /StructParent 46>> endobj 39 0 obj <>/F 4/Dest[ 40 0 R/XYZ 87 756 0] /StructParent 47>> endobj 40 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 168 0 R/Group<>/Tabs/S/StructParents 10>> endobj 41 0 obj <>/F 4/Dest[ 42 0 R/XYZ 87 769 0] /StructParent 48>> endobj 42 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 169 0 R/Group<>/Tabs/S/StructParents 11>> endobj 43 0 obj <>/F 4/Dest[ 42 0 R/XYZ 87 738 0] /StructParent 49>> endobj 44 0 obj <>/F 4/Dest[ 42 0 R/XYZ 87 217 0] /StructParent 50>> endobj 45 0 obj <>/F 4/Dest[ 46 0 R/XYZ 87 623 0] /StructParent 51>> endobj 46 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 170 0 R/Group<>/Tabs/S/StructParents 12>> endobj 47 0 obj <>/F 4/Dest[ 46 0 R/XYZ 87 361 0] /StructParent 52>> endobj 48 0 obj <>/F 4/Dest[ 49 0 R/XYZ 87 653 0] /StructParent 53>> endobj 49 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 173 0 R/Group<>/Tabs/S/StructParents 13>> endobj 50 0 obj <>/F 4/Dest[ 49 0 R/XYZ 87 530 0] /StructParent 54>> endobj 51 0 obj <>/F 4/Dest[ 52 0 R/XYZ 87 685 0] /StructParent 55>> endobj 52 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 174 0 R/Group<>/Tabs/S/StructParents 14>> endobj 53 0 obj <>/F 4/Dest[ 52 0 R/XYZ 87 218 0] /StructParent 56>> endobj 54 0 obj <>/F 4/Dest[ 56 0 R/XYZ 87 769 0] /StructParent 57>> endobj 55 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 175 0 R/Group<>/Tabs/S/StructParents 15>> endobj 56 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 176 0 R/Group<>/Tabs/S/StructParents 16>> endobj 57 0 obj <>/F 4/Dest[ 56 0 R/XYZ 87 467 0] /StructParent 58>> endobj 58 0 obj <>/F 4/Dest[ 56 0 R/XYZ 87 379 0] /StructParent 59>> endobj 59 0 obj <>/F 4/Dest[ 56 0 R/XYZ 87 291 0] /StructParent 60>> endobj 60 0 obj <>/F 4/Dest[ 56 0 R/XYZ 87 204 0] /StructParent 61>> endobj 61 0 obj <>/F 4/Dest[ 56 0 R/XYZ 87 116 0] /StructParent 62>> endobj 62 0 obj <>/F 4/Dest[ 63 0 R/XYZ 87 716 0] /StructParent 63>> endobj 63 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 177 0 R/Group<>/Tabs/S/StructParents 17>> endobj 64 0 obj <>/F 4/Dest[ 63 0 R/XYZ 87 628 0] /StructParent 64>> endobj 65 0 obj <>/F 4/Dest[ 63 0 R/XYZ 87 526 0] /StructParent 65>> endobj 66 0 obj <>/F 4/Dest[ 63 0 R/XYZ 87 451 0] /StructParent 66>> endobj 67 0 obj <>/F 4/Dest[ 63 0 R/XYZ 87 266 0] /StructParent 67>> endobj 68 0 obj <>/F 4/Dest[ 71 0 R/XYZ 87 110 0] /StructParent 68>> endobj 69 0 obj <>/XObject<>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 178 0 R/Group<>/Tabs/S/StructParents 18>> endobj 70 0 obj <>/XObject<>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 182 0 R/Group<>/Tabs/S/StructParents 19>> endobj 71 0 obj <>/XObject<>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 186 0 R/Group<>/Tabs/S/StructParents 20>> endobj 72 0 obj <>/F 4/Dest[ 73 0 R/XYZ 87 684 0] /StructParent 69>> endobj 73 0 obj <>/XObject<>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 190 0 R/Group<>/Tabs/S/StructParents 21>> endobj 74 0 obj <>/F 4/Dest[ 73 0 R/XYZ 87 584 0] /StructParent 70>> endobj 75 0 obj <>/F 4/Dest[ 77 0 R/XYZ 87 543 0] /StructParent 71>> endobj 76 0 obj <>/XObject<>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 193 0 R/Group<>/Tabs/S/StructParents 22>> endobj 77 0 obj <>/XObject<>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 197 0 R/Group<>/Tabs/S/StructParents 23>> endobj 78 0 obj <>/F 4/Dest[ 77 0 R/XYZ 87 443 0] /StructParent 72>> endobj 79 0 obj <>/F 4/Dest[ 77 0 R/XYZ 87 355 0] /StructParent 73>> endobj 80 0 obj <>/F 4/Dest[ 82 0 R/XYZ 87 769 0] /StructParent 74>> endobj 81 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 199 0 R/Group<>/Tabs/S/StructParents 24>> endobj 82 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/Annots[ 203 0 R 206 0 R] /MediaBox[ 0 0 595.32 841.92] /Contents 200 0 R/Group<>/Tabs/S/StructParents 25>> endobj 83 0 obj <>/F 4/Dest[ 82 0 R/XYZ 87 267 0] /StructParent 75>> endobj 84 0 obj <>/F 4/Dest[ 82 0 R/XYZ 87 150 0] /StructParent 76>> endobj 85 0 obj <>/F 4/Dest[ 86 0 R/XYZ 87 769 0] /StructParent 77>> endobj 86 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/Annots[ 210 0 R] /MediaBox[ 0 0 595.32 841.92] /Contents 207 0 R/Group<>/Tabs/S/StructParents 26>> endobj 87 0 obj <>/F 4/Dest[ 86 0 R/XYZ 87 738 0] /StructParent 78>> endobj 88 0 obj <>/F 4/Dest[ 89 0 R/XYZ 87 470 0] /StructParent 79>> endobj 89 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/Annots[ 212 0 R] /MediaBox[ 0 0 595.32 841.92] /Contents 211 0 R/Group<>/Tabs/S/StructParents 27>> endobj 90 0 obj <> stream x\o#n~6z^-,"O=.9܇"Hqoz->|zuqsw[ź.uD*ɫZ~y_./mQ\ۏ]={<19\^\˂ VVغ,.a߫}S|pym˵XUZO%g'*vZeq/^~غ]an/fx%u׷U1TZQ&ZZ89%7VFT'rtf6rfUJjc* Q//>߃Xv] ѫ^X0MŚѴYm+g lu(K^Gvi=䋎nz ղ+2c./bjnB秛_T[j v|7 bJ Psܸ={[~m]EfbJmÙAǁ.D̬>S$K@d F3phf dl릵n.ҭnXM#xЭ\#w~KJܔ7Nt~ki+;~bph}{Ƹ~\p8s`Zu mG>:8Y\NeVwε`/g6\{gy֓}^FѕY]!^ODk~TGgxW,cڙa>fc;y`xdXUِ݀n@Bi(QNY P͝Yg&m*׷.Xx1:.[C3h\j+g&%֔3ָnJsyȳǘn1Ub:]q#04=wT;ޖ\MG6=p[5jH= wa3y>5F+/3݅6M%4FTФ8 jd-]Ssy3טrvSsH n7NŃy(m88`E}57C]ky^9#4Nx˼-k:P<-KXE[h"wff)vLU<4vǮ(pt?zgs'ح)\xmSoN(Tm}(ȇ43?|YՌ&w66b LC~LIG~LG~̝9ȏ> C}{;٩?}VTg*+.aL`[)%?2Ql] FSVgna-807RZɳEEd0"s=9n FK&g{@Y-,i}`þW[)[9XCZȻǪ9kP;f#q1eh%d#A7H 8&Z7f LZ-Vf(xցox^6@?y*Ɯ,$ ҈9Pv"qۦyydEDINڳM 1Æ|p!|GWG0'N?cЏ"P[5?J?t9+hڃ̚,sfʺLyaFCa!\Ccwɱ^6ci!^`l%TSj%m'jqVXH2*IR_Ӊ2 XArGl^ # <Ѽ9B ql9%!pn׎~ъ~~ $I΃@2w+<HIrUВIeM&hym}!biB֯Mf_x`i98|'~A"ߤ-ci} ޮgu0ZBrϱgEFQP ΝD<:< o_{Y@{gRMzئ 2 D-) <<ŔS.qDD۲9B/ok4N§W֢sW/bqrY6 euSryjGǔN&b"߀}xpn!=HYkk3 9׾0'R]fQ欇gkR9 *?gXfI1T:7˞f$|" va*e1!կ3nJwE}h(` $q:h#7g]֜OXonxd9mD9V?5zruKx[Z &\9f0gRԤgkmKH ar9/K91P%K9<ǔ[RA08׽P>PJi(bUP6C^x!~"j;v*ضٻ2w4(Hq:v)x Y><˒Yj(M#y)0Z0f@ ԇK>gm.~fc^3_VNa!*~>SI i6Sy a/PRzmΠEzHQf\M 9(ZXMp1 ,ńtT>~=dA4QILNux)8 p}8-[ i#/Ɣ7VwǪhG? W7ƻ!rwf$Ei{~ f5Ơ|L))KLr2ULYj TONY/3ȠϨjooR[{ϰ endstream endobj 91 0 obj <>/F 4/Dest[ 93 0 R/XYZ 87 769 0] /StructParent 80>> endobj 92 0 obj <>/Font<>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/Annots[ 214 0 R] /MediaBox[ 0 0 595.32 841.92] /Contents 213 0 R/Group<>/Tabs/S/StructParents 28>> endobj 93 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/Annots[ 216 0 R] /MediaBox[ 0 0 595.32 841.92] /Contents 215 0 R/Group<>/Tabs/S/StructParents 29>> endobj 94 0 obj <>/F 4/Dest[ 93 0 R/XYZ 87 703 0] /StructParent 81>> endobj 95 0 obj <>/F 4/Dest[ 93 0 R/XYZ 87 612 0] /StructParent 82>> endobj 96 0 obj <>/F 4/Dest[ 97 0 R/XYZ 87 769 0] /StructParent 83>> endobj 97 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/Annots[ 223 0 R 224 0 R 225 0 R] /MediaBox[ 0 0 595.32 841.92] /Contents 217 0 R/Group<>/Tabs/S/StructParents 30>> endobj 98 0 obj <>/F 4/Dest[ 97 0 R/XYZ 87 738 0] /StructParent 84>> endobj 99 0 obj <>/F 4/Dest[ 97 0 R/XYZ 87 610 0] /StructParent 85>> endobj 100 0 obj <>/F 4/Dest[ 97 0 R/XYZ 87 564 0] /StructParent 86>> endobj 101 0 obj <>/F 4/Dest[ 97 0 R/XYZ 87 505 0] /StructParent 87>> endobj 102 0 obj <> endobj 103 0 obj [ 104 0 R] endobj 104 0 obj <> endobj 105 0 obj <> endobj 106 0 obj <> endobj 107 0 obj <>/F 4/Dest[ 97 0 R/XYZ 87 360 0] /StructParent 88>> endobj 108 0 obj <>/F 4/Dest[ 97 0 R/XYZ 87 286 0] /StructParent 89>> endobj 109 0 obj <>/F 4/Dest[ 97 0 R/XYZ 87 211 0] /StructParent 90>> endobj 110 0 obj <>/F 4/Dest[ 97 0 R/XYZ 87 109 0] /StructParent 91>> endobj 111 0 obj <>/F 4/Dest[ 112 0 R/XYZ 87 667 0] /StructParent 92>> endobj 112 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/Annots[ 227 0 R] /MediaBox[ 0 0 595.32 841.92] /Contents 226 0 R/Group<>/Tabs/S/StructParents 31>> endobj 113 0 obj <>/F 4/Dest[ 112 0 R/XYZ 87 534 0] /StructParent 93>> endobj 114 0 obj <>/F 4/Dest[ 112 0 R/XYZ 87 430 0] /StructParent 94>> endobj 115 0 obj <>/F 4/Dest[ 112 0 R/XYZ 87 430 0] /StructParent 95>> endobj 116 0 obj <>/F 4/Dest[ 117 0 R/XYZ 87 769 0] /StructParent 96>> endobj 117 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 228 0 R/Group<>/Tabs/S/StructParents 32>> endobj 118 0 obj <>/F 4/Dest[ 117 0 R/XYZ 87 688 0] /StructParent 97>> endobj 119 0 obj <>/F 4/Dest[ 117 0 R/XYZ 87 390 0] /StructParent 98>> endobj 120 0 obj <>/F 4/Dest[ 121 0 R/XYZ 87 717 0] /StructParent 99>> endobj 121 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 229 0 R/Group<>/Tabs/S/StructParents 33>> endobj 122 0 obj <>/F 4/Dest[ 121 0 R/XYZ 87 241 0] /StructParent 100>> endobj 123 0 obj <>/F 4/Dest[ 125 0 R/XYZ 87 769 0] /StructParent 101>> endobj 124 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/MediaBox[ 0 0 595.32 841.92] /Contents 230 0 R/Group<>/Tabs/S/StructParents 34>> endobj 125 0 obj <>/XObject<>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/Annots[ 232 0 R 233 0 R 234 0 R 235 0 R 236 0 R 237 0 R 238 0 R 239 0 R 240 0 R 241 0 R 242 0 R 243 0 R] /MediaBox[ 0 0 595.32 841.92] /Contents 231 0 R/Group<>/Tabs/S/StructParents 35>> endobj 126 0 obj <>/F 4/Dest[ 125 0 R/XYZ 87 738 0] /StructParent 102>> endobj 127 0 obj <>/F 4/Dest[ 125 0 R/XYZ 87 639 0] /StructParent 103>> endobj 128 0 obj <>/F 4/Dest[ 125 0 R/XYZ 87 552 0] /StructParent 104>> endobj 129 0 obj <>/F 4/Dest[ 125 0 R/XYZ 87 494 0] /StructParent 105>> endobj 130 0 obj <>/F 4/Dest[ 132 0 R/XYZ 87 726 0] /StructParent 106>> endobj 131 0 obj <>/XObject<>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/Annots[ 249 0 R] /MediaBox[ 0 0 595.32 841.92] /Contents 248 0 R/Group<>/Tabs/S/StructParents 36>> endobj 132 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/Annots[ 260 0 R 261 0 R 262 0 R 263 0 R 264 0 R 265 0 R 266 0 R 267 0 R 268 0 R 269 0 R 270 0 R 271 0 R 272 0 R 273 0 R 274 0 R 275 0 R 276 0 R 277 0 R 278 0 R 279 0 R 280 0 R 281 0 R 282 0 R 283 0 R 284 0 R 285 0 R] /MediaBox[ 0 0 595.32 841.92] /Contents 259 0 R/Group<>/Tabs/S/StructParents 37>> endobj 133 0 obj <>/F 4/Dest[ 132 0 R/XYZ 87 419 0] /StructParent 107>> endobj 134 0 obj <>/F 4/Dest[ 132 0 R/XYZ 87 288 0] /StructParent 108>> endobj 135 0 obj <>/F 4/Dest[ 136 0 R/XYZ 87 682 0] /StructParent 109>> endobj 136 0 obj <>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI] >>/Annots[ 287 0 R 288 0 R 289 0 R 290 0 R 291 0 R] /MediaBox[ 0 0 595.32 841.92] /Contents 286 0 R/Group<>/Tabs/S/StructParents 38>> endobj 137 0 obj <> stream xZo nUŊ)8㚦uТq~Ply>|u.KrhwM f9!CNɏ?ۤo$,Y]^\U3ZR%y}{yˋod4n$mW^gˋ K Ò *efsyQUAI<ٯNm~{2]vm毗?z[ F ݦɈh< 0~r .PoEB2jٕN]'ٕ;m:=d*m7Mv%ww ]dzM3>e8XdH7F d8of~2}IMeq,O Hw8{Uq0ڔccw;Sà Ԛ64$4mZʃ4RJ_v./"<* {|'AE<ȼ twy@0wDqs^Wnc6=Ÿ:g0}ߏ`a !~b234嘯 2+x ,GI_TC*&Ru":IM:L0 2b0Bƭhkxҷ7D$-q] L#h #mY>fbA.B٨3Eěj 3PRwey8c`҃?Opѝ7 rA <\EҀ-L:[C7q', xE2 ę? t`eX^Ŵ!&?]’,Z^\u WX1|t^ͪ20\f;Z,$1R-rCXgZ3cJ0R]㌯-$ص̋:,Voc BzC L#Ä3\ss}&>̜g-yYť i\MdWXhŦ - y^'uU.yy2~t!m=a8q"_ ".ZYboF9K!.kÄ3|mKn6>pfg1)2,}̈< iE.BҼH\u'̣ {(r5Y܃Ӿe—b*E.S#]r/K^znA{t0L <5n,9w7d⣈⿂k]E5f C]Z TbĪ BcF⬨ڜaɶn{l.]k$r}=TXt#eOӷD/l7SΓ EPY邮eX1T8mr+aZ#Z=* GAvsO `)J1ѩ 262GA*woũneoӿ`⏦L`{p*LC5 AGnv^:M-O N>Z'[ 9&`׻QPhaE&E(K9;NT&8)k`0PR4sQ8L3Ւm(qc53Thc0K ,XO@ l:ap7=G_! *^dZ,Vj@<#fJ U {H%uupp)eH;EdI?ߺ' yӯ?۞]7y|4y_%]y[Em3<`ngREz7 @z,n! SbP0zQК @Ú-m0몋PF(1X*!S{"|},y v4 B '*~U endstream endobj 138 0 obj <>/F 4/A<>/StructParent 110>> endobj 139 0 obj <>/F 4/A<>/StructParent 111>> endobj 140 0 obj <>/F 4/A<>/StructParent 112>> endobj 141 0 obj <>/F 4/A<>/StructParent 113>> endobj 142 0 obj <>/F 4/A<>/StructParent 114>> endobj 143 0 obj <>/F 4/A<>/StructParent 115>> endobj 144 0 obj <>/F 4/A<>/StructParent 116>> endobj 145 0 obj <>/F 4/A<>/StructParent 117>> endobj 146 0 obj <>/F 4/A<>/StructParent 118>> endobj 147 0 obj <>/F 4/A<>/StructParent 119>> endobj 148 0 obj <>/F 4/A<>/StructParent 120>> endobj 149 0 obj <>/F 4/A<>/StructParent 121>> endobj 150 0 obj <> stream x\[oF~7@`_6snAnqbش-T~ϙ 5CrHQPȱ)ι|3g.}{DwϿhx~vF)<$BF`$Ѷ>?{,(r1狫#xDtp~FQ."'4Y(_EǾ:?)ID]4 OWЊ:VIGm9v\aCPA~ohJ2f䃉<{hZiHyביϜ$ r3JhqCY 2W$ATی8,8A}^܃ uPe$72B{Pd +(ufjcCjݲ^lyk^%#4}yT׶@ HCd{[t@eR45䀊]6 JfnˆVω+(ꤰ;qGpJ9oY(XWV dة*۞8卛oܗwK·ڡ9{ou&nL$,1X^0{+ D G(,]5|¤(IiDM0lHs LDCSO;gS𓚑(8r7LՁ+X6$ @BȀ BBUED^EIҷu0$$>5|N]  F{L+n>5ܮNx Ņ r0*,sXjeWPcR, \),ptX @zW`苩^Ӂ{ <\<ԂոEͽ1m8=BSNF$]Ah/It?&AFzCbBDkOqHPyT|yNPui,1 4` bɆg,- #},n N\ob,<̬Ɲ9+Ԃ$5W06S66C94LYIH3 #Hx3$ #}$1myS*KP\๑#,R̸~ M*?H?82 =QD+8Ӣ5).D*x "ʖ 46hM zI)O0'A&YAw]8:ࠥzޛqwRdl؅%X5dTrd<=dN5w6c6/

տB0vϖ n NsWy g HXSc-YO!S'_}=2p= t3|01H@(&ݚ+d2m޽]ҁiGhA.t*8%:g* WJ:&ͰTGBvS\0xc OZ\ԗXjj2\S 8 N%|~ٜ:`^Hmus|mkhm1|Vm>CWoMC`{R*}N/o.BcS)Fә#س iF>s͘:|zQ,3ϼ2AWI%g|{|R%JT 3P̛%B0zz#ON/X{;7JAFUcף@sh7ZsPqP-TCxaq%/>9ҿ7@)e]IIY5w9%l&܁:3޽e&_>Ql9&L8h0a=ٌտlށ짷jou" )\duOaeܥ@'@=JE jzuGN8תDƫn-+l,;l툋d ak0wC#nD+(ziញPus}gӪg[r u'%%9w f@-rUaZ0}xݱkzSk};p$q٦fYUO;oB-@AhXأU0b5 UʞBŗP T[%Bj}gm -84UfJV=XEUj0fm+7[KwK4]q_u8X؛H轢uPXhc `-xSm+PxݰP_W Nx,텾~bm4z4d= 2eͽju]Ë, aߘWug^(pQÙnl VVH|la^ 愸g8쀣_>=w΄jyDw^ `{} -t#i4ޡ]6=LU*QN-N.v$dy6e$M_q9/-7='ݲV\]Y2o_70N-T& cϜa{X᧠2*-T/r$LBd?-\/\3 -*ܮqV=KJ]4elSm T^gI1Ɠb,R ۓ Rf' hc)M4lMl`Fn} #1,ަf&Ә\5y-;LYC`Ga,Q-침%ǦAS^>1}4{rא $NNMXm,F2`' P.=28M4ȳw @DISgɣ;aŒSPXzr;CS_q/S-ӧHRo#6!V'&t$ewBװWvrSWu㕍m*ry+=PiC]Pف ?NdVԇv}9ލ͡:6ltfL[ѩɑz[*7;k K)+ =YuX`֜~z:L-gsct9ǫcړv.kZ,x>=)OgctNY ׂBiZa"[΃uxQ]i{INP!EJEQ#>Iv OR1GI2ni c+BxRFNQaiG endstream endobj 151 0 obj <> endobj 152 0 obj <> endobj 153 0 obj <> stream x\ko8 A0K$~h;v2 ]n48vv^(E eED>ν|Oٳg'/߼ʊϳ^f4txp\dpV3łk o;;_=C)('Jz%;(Rae}#b5$>Zb%?VÁOn(w^y xǩ@FjAN "g(O^87eҀ `e?(dggOۋZ )[LCZH NkOWݍh10^y KJs <{pxnh/7@z ]eáCCy.n> 'UR,Z6 Z8aNJyT0}1G-%rCDٯ}ټ1b8!'1iXjX7ץ06ҷYoGQBеijOfiJK!J1c61i'd_yὥ4,Ί0گY!mu) y #7 3 L㋒g{|aدxEx>ylPI<4U+] DnfZD"//"*OD0.("͖Pwuh4HIY4ȯ#Yd@6I96cI)Oq3ICRbr"- z@$b[fQjFuDK"XICu׊` jMA#Fpf:r=NgE3t|0c4>f-dϡ0m_yOn.?mkquA o\?/QՍC&' { hAuUd1a{aae" ʹ2M[w]Er=Gؕ#R9}E2sLedX|}F!~}36Sh2z81"4KNjÉZ]hCm探FD2M:1ba6E`&&RhVFRuIpPvZney,eX[J)|t } X |:txe, u4o\įU^Gdz"t DEi"]KVFSnP"8#Fy_!Q%ŇpA%|eOvU 8J$zM6>1>!@mN >4 !9<6:Eg(b>u"2i v9ah5aj.qHG 08׉jdCĉ_'"~1Ҧ?}= NK\G@H&--߯Sf(*x7Nti2qG0'uG$DjԒI#lVӳMyX;)}l$=r^2AH>0$`(dhN>HDu;G ɝOc"VqYm NzQ%XKO<7Y?iu >Q_`*Z$RmW蘸{qLy/:Dj􂈋Q.?e#r= tS!KU aנ:lfGI{= [}@1 A7eogKnM"?Vm+JLJZMB쑠 Op?ov:1/ g6e{tbb+xS|2H6/q(};tiGKȂ*)>y4/[|b~loXԟu6~~۴xeswU3K£{~~7oډ[@*u2Mx |=ڠ}C4]+bcfƺH Fm9l_㈩NETU~)Q A_9VH!r2U[}x'.=h0]~UZcR'z؛+_!Z06wyi+рP ش@# A<\}B6|@~.a\B+ܽvfՁu6LQ[t>B+>)1Baz@^T톆L1RbΛ=*\A;p/}CCGya 9/O=Ajٞl6M tf-{_%#a_ݪlC}z(wqR( Z'=ĎM:",м0/X,P8o>!d0tӕ_'sR<sA|_j.5r+0z6LUh7WY{=mh6^ϬegNeCo.Cpg@whr迧^>/F 4/A<>/StructParent 122>> endobj 155 0 obj <>/F 4/A<>/StructParent 123>> endobj 156 0 obj <>/F 4/A<>/StructParent 124>> endobj 157 0 obj <> stream x\o݀-zZ^S@\q~Pb*[$;3$E"#p߂z>{^p+T L0^*u+^<{R~ 3d\=^aƢs,b=񊚋eKsrj j8dY%~Q].y|E}%xgFTŌU>gT^2{5¬̏ܖ%.S?$F?eIm! Ҙzh^bs^m-䝆xuSXù'֦Jf]8 6W.ɍ*軕t y _(x8+"#zJ|ѥ!$ hqm/˶vGiYYVA' sNѣγ"SU *)d&|8mq2^W&5&IU&L쑢btU$^C_-IU770j`k4}(9kᣘ۞qsltHT`80D>EژiXTaϏ/1 A8R\D5.B6eL#;^yT;4`Jn1,BՈEWyVyHFhiQG8kL"/4f󊾜ۛ>* $>ڐ멺,3ڪLVaZv=]ʖzAX+"3`P^+}%cc-tVUt;>P8.>T7Zo רhm\mMJc.o-F߮s!Q%ͼa*H3^O#|~^"{Yݙ#eqx=46vCCs9+CR}O΁ᇝ64D2 ig5S;Q5=:=/mpuz @ lC%/Iyg?.7|y/,,ygG*QDnugbi4DU=h1cل#6뒏%Q- φ- Km?l_N(JgS2Y) u[kh݌NC v_`3Z Rхh-NE.&p,&r6p {"h4*aܠ|ݳ ]fѐ޸XPU˜7vl%'Q.xIO̭Evv!g"KM\i}A}E7s/{UQI‘Ɲ缩 }ȸ۳Cu^)hX8笣ś/d5|~N,ˀM *GBDkIYCKhs8SRs 8iƘw4&T /?&G 8e*-(]sh Db%θVJEɿA13\{&) ޸fdx[;Ew.0#p)̾YSqWqBk c3kEr,0Va+"El0G^hFQz vyޅm x@۬+f e E9m<-[3h*47ҖPInxSV2X`.F7g`t`*E!Ν:eYPڼѪhޱ%IuEFuw[;7ss,hZ7xg7t^Z<9*}9ˀ[+wuޮjcV.˦(\Iݫf 1섁%BӷQ\Ǚ9 &s]"c@Q ʵ ^>μf_꯱l= Zχ aXh(E.j7OkWuZ+~dχVY/ <@HQFӞ­c`U}>n#8nQ 6JY#| q~_7#OznN?bOo' #xOjy38Ȧ'~kDfIM*1ML&ߛ7ݝkqJds Mg?z;2J|Gc_znjD'031IyggyIsA C|sW$"U.n8Y HaنBRo;>\fvYaR0yCC&@7kH km!)mS< KsP z pSj$čC[&/Grk8߇*uF#ocWuvb=$Хڦnܱ]mwabk=ʦ(ZmaԖro ^m `W]?Sj(}d$)0ZaExntؒ +"G*?lv 1/pq13-Ac$'a wr Y_֙zKSކ#ѹp _ꪽQqK)΃<:J/G0 8]TIGG8 mzgE]nfb:`0c +SM!> endobj 159 0 obj [ 160 0 R] endobj 160 0 obj <> endobj 161 0 obj <> endobj 162 0 obj <> endobj 163 0 obj <> endobj 164 0 obj [ 165 0 R] endobj 165 0 obj <> endobj 166 0 obj <> endobj 167 0 obj <> endobj 168 0 obj <> stream x]mo7nam5_wTK P8`٩e'uo/ƕHI!rɇ3CrN=yrjӌfyF)ɦ^Gan-|9(-\AkmWEY!^7Wg?Fp8x!&Yy*,n/rT3*65ɂZA H{\1~k97ӛۛm^MֹdOnrͧR_e2$[b'^LV{x<2[um3!wI,6&RЛ^7.׺|b2f}56 )B[=^uT  NM9XĝKP@AK.ۛot|: Kɽ\町-<.˺]L7e-YX?/ߠ^|.5/Tm 6_>Z f&'߱!Z PNKL0r`|^Pl6m;\pZLݣAQ‹;KLujM_njբ&βE^"b ?0c HTVbDMnӡO.Q>l_ֺ05$r F L\m/7f`JǽILFPˉj쓮=a%r &L fZ2@4i:yb(* t6]=gZ]Φ lF |ٔQCLal6-L$|ɧxW2 ެ)0wwX0gOgÆx\a ҰNNuRz.l77jJA{, U-ͣG,=tx  vƦSSTݤ mtD| 2ɽiƾcGC)$oLJQ}+3%NT\x7yկ?_S34Pe+6Im;u(ĖB;wɦвP_V_[!$:a:Ϻqhq9-)d1̩(OگWƗ t.*\`J`L_хz^h5+>?-&|?ۏ,-MV8L{J'Ä>賘,XA /L' I# rڧ7~S*r4{c@vԝ =&1hL`٦Dm`E̓mIvj_"^~&S녅&.3,, *}gV?11c;h:p쩮ۖp6g6NQ |'N919)6\MPnmP ZQJ3/mTB\w]/[3E1+cT` -,fI7.rDh>6nuVHh6S5"*L/{O_jXQo6kQ00FaP %"&d,n?dqafsK`cuENy:.k ]tQu)jWmAϊvBg-#W_c g( 'PW.>PMuA]yjmg]᩽eK;X: (A!Ե7# u{xڛP"%q_۟9H?}z?-dMAxnbpxuAp1Jè{AY1՛8j=PցԻD  YMdfJCKM;R4c p a⇩J1vU;Ə_, I? ,M{A6Zߑޝq* ur& R!|JEd?oÖ+Y)b(I=!C:L"vz+IHEFNr3r.ams^8Kmj2j|熚B]GlT-P08f{J'R+umU~蜚\t` N3!P|nb s7Ļ&|†a -#KIθ;! Y0cf|bz]ym??b]i,@<.;w1);qxu"AHbh;S4JyYZﷹ[*m s؁so^fvs ]&-gf}v=~js:<;-{]~xB{j1b+ j{IFNdc.y-!b9UeC4*Y`9NxX!tWªΩjCp:fvg^HNk@#{9)ӺcW!^eMj%ƫmWB`9Y@5 7im #F|5Ow`@KWg,eUHA`ϕ0}7[wfbd2bgc0# ~[9 :ecI'gzhAJ%!A*+S1w~vxp.fʟTG8D:|2 ?nKF8e<Mj[A@lx|FڝMJvf. Ln;҈6C,9rel."nRi>ozO{=o :n@eaxX'c {@:9_pȞ!BCF(G0 6uˢ%8tZ8$_,q ͯ@6pW;6N? 4 endstream endobj 169 0 obj <> stream x[mo8 A}*%W$lI^h 7VqvofH٢%Rr~8N%7癡Żo΂ի4`( @**%Ãg h f/.& ,O"C/"29<`AXP$qMb\8/$DլÃ\5PG YȘ-8x*uY׋UX>THPx(>pWcҴ4U8Otc) @4Sz>C)HedКxMPH.-e:$kJF#8!AgBO\#a ː6W.{2$I>K?I>Zco(/7$^ǔ C  ,[!TAhN&捄@RcF!;)S䟀>DqQW ?o+UPq\3%$nhtЖLpb$cRJĺHQBY@V0EՁ.qqX|(1E8x3ޞU࡛}s]{Q v,.gm+} c ڨAqV !YHp"CN0*>)]jx9 *A4xL^*if/@8C[mvW 8Em/9q(cZKw7w{(W=j|[b ׆Ez)AX6vq"H\IDH~pgszυong"edShٌ\6X3 vU(>i⯁E >>)^I6EU,2^I{!,fޙI=^ymdַr̢ͅ?}ޯ!N-8 ? ,6~#'q?҈Nu8Y(6-{ڳCU6[x2)zuWsm<`cx@/;3\}3vׇBȐQV&޷:iǓЙ#3ssh|kѠ[EөĬ&sKPcPl"@uo>g,?_W)4sN\2[IݘȐӬC}k'^nMsEQnSp2[ endstream endobj 170 0 obj <> stream xko8{E%JEa M v(+~dmHIl&ÙἵקWty{`q|4II\\q"mq|t<,~ss|tzIB#$ $N(b% } ']bPbΪOa"i=XOф*[ݕIt܆D8wmk0;TFY&<$0+|{DHWkDt"̖a[X{0b43Ǿ4j1),5@c=l{餘E4+bw8x"}O(/NpNK~'H;D-*h ?jԢyLHjse}⑖w}ˮԏ> xGC~"I{칣JpΡϳ"{7y&0ds+^rwPYCiR%B"^J1 šӳ/QEU DOu;ΫrfWy[$I4UVuIXps)|立hBhx""x ;&KO[`$K`4tJ4G(($f@ CGsG[f0͝>D5n^/ҧ()WjҬԽa !,&90שHL8Fd(gmrIzJk~I_m-X ~_q ˃ּ{g2sǾځM\2kdLg!D;@g >+ט8p19;\Ї+I,ǘH U|1 Ew1}*bDBV >HJNʞ]x̩"keaC]xq@31gg8]`plV+qmu>~Tț<Yu:츣 |^BE?~Ty& M?m<ĥ˗&WhaѢ2ZDM,xDi~8sUtFFХ1CKsH`3aiTǶݛxIselx d٢RwU U+?&s7r,}[)Yzʡ؈_؈dspXJ{\uqy.\TC;ēpajs _p< |r̅ YЧI.ӖG ]GGB< FBW<] 9T$Dų`#.ƃmޥ~8/װU&!^ِTə[*s/ MCM]ʣX #5W6;X#$UE@@g+Oam TV S<WSبu}_ofQ>.dYݔr(Xסx,7aRzF׸tIu !v݋#R$Kbi4 rl1@ARp8i% ` Ǚp\;uY" R 4ԗg`S+a7-1; _$/S0iԨ+ē7~_ſl;&X}%*&?K\$,Ƴ)=9[*(&RW &T)Xj+w6 lpKw: =S+E3eVi'k\jR;̉0UN3[.u}oj*Tt >~sT\쳇U>Pgu✮lX2AS2@W}^3mHeZ^bjcBZ\YژLC)rF]{*u}ɱ)W85g[r3[ `:X;в뫳?0ꅲDy`6W >7y]Ϫ8/"՚w44#),DU}saNžl@GFk`9fZ\sqBm0ר eͽs(\ :Ķ&.`qfRM0}eD 0EqC{_Ζ_)̀[j'E5c23Dj)!UiV" OfOkP|\BRB֏f`f*97ߪ:WRrTz#c%8qVG{ܕ9#{nCg&r `{وOވiNG]nWz.ۦڿySdh Ɯ4NH/殨\~^۹LgVNjO܋1(enZzb]14K8R5gXZw@k WczgA'߯uZt@Ű7ި!+f-LzaTunzE96yQcǜv駠Ʋ V柴2,:\ =8}~ sd).H.S)ێ6cB[gϐ`G*CK r8wlt³U32G#*.Zvi7/RkvnX en¹hDh _bI2,ute6 z⯿)U}nc9np`:6u߿25ͷ=<)cӡN6{݇6 _ʙ0 $|7¡)leo2bw1݄OreMtd'yGK։ a<~3ڬhxocBM*f{bÂa{J6T$r\fdU[ujrb:50귨}@x4ǗlkF:T TjJ,TrV9srN&U%*E'C<;Uçk7WuzNi]b=H3FFAFF畳Xрh}w:;ؾT\t;.-rn8)#:O?2e7 endstream endobj 171 0 obj <> endobj 172 0 obj <> endobj 173 0 obj <> stream xko7{(4Z/ܞ@8iNKP`*ɮ8MoJrWK) Ek.93I*;1;<88Ȇ W |/Jx>x1dSAsKl?g Sx6׵2̟2<HL q Y<Ϸmcގ](2EFU.U8E333Pu6O&  <#d`2|I\9^xÛ㓋#B?9E 0К\ `̆#F>>XVrpOiD*tN㮾\D}c,M R>9Â\rX;1qAш3)I%.MI'G\gAu,a}u1{&Xńl 8Z2Q9XT5~2 PO/gCHW5̪zIN @YVL_o_jB~PpKY]Sh>JhW>,q tkͥ6ej+m5A6EDV,ǢxQZgVdUߜ!B]~+YuR -A>k+ <7|ht?D:eLu/XI6sFvY4x;Wr 9!ՇH˵#lfC ߂>^(vQ`X )J_Od[Ȩ'Rz2l-=H$ct9 z%n`[/YOm?%@020DZ%ndP'|{Xynڶ HI2=ʀee0̹3Mb5T{qp1,yv;֙K-;VNDQح2dhX^Ux.\Y~MmScT}"傅LIr(Gy[O)g cKjW!j||"{>rIAr+: ; (̧UgJAl >g7,\ [)"&02Mt;in[Hi|cVPoW a>@0|jqtU 쑹7˚$c54sH_k%66oc̈́,s $ c0w3cxRB"[0 B d2]ɍ kaqpT V(McM^Og19Q|#F$ZEK&XM%6r/ VoL+XYZ/N_9u9]uj"Nz 6٥T D-rH=P H0nUj#ǭ nD/T`6mV!I 'ֵC 4JXT$z7B5PdYa!|$r" _+N$CLq/:uFגQۻ9Dջ;4Y /-B܍&@zu98!O`jf;{2qY|qBLi<5 0kϼ]f?A?}$fW ]ԕ cF|3OX6Ϛ0*ՙo]DqmaCw>N/Dطvj:F,:8x:5|V\Ү 8[7] [x: \\nc-}0mESņ#+C¹IZȦȵrIZ] Z PYODȗ,r }?m{Y+XAOBZhɼwoGaVI%1UGsqLORP??m8 7nmh{߄(foF-7r'Rb<&ޜ)ʽxtaSϾGWI{\ӣcZxmN={YSLx}dMU9M,,dR7b=CB!Rgɺt WHsHTW\ xs鉫eU8QۤٗPĀ";А~q)U<G4V ,{"nL`XtS|`<8=y>~/*H.f~QyvfϩG:Ѕc).7ɅaJX[\0: Mf f?j*)^{rחBkjܮlմ ո1*L*RI|)&yzfL*+X.Eib xY{q%x;GX+?]LkyV(U +л4BNJ4YGɏ(~F%WIٚ_DBmՑhڵb~}e?RI9 ?$\`5ycMJOc, zz@YV)Q$5&BTX*BEo1=/.'7kӍ/E`c%o1;@>:z^> stream x\{o8?@V&3ЦM>9ᲇ8:{~3$eSdɊBDh8/r;y2!iIBà I&$cҌ7aT}_-# e_0ZeTue )hV'6aC+ED̆yPKb-4~]h b#(cc_7ǦX P9r>hHV5Wté z4SXT Pr2aGE+yŞ+܎n>2Q&0s"C+:͗/iQ;c)vI3՗1R9._?n6o|lF% ,1XX|\Kd> ;XC$NJK(khl| s,faZR*S.&h&.Znb!~KM'j4{SС+l /WxZ,`/'zso_孻t_={k" ѩ!3Әro >οb3b;Zkѝ8COYwn S^X)N8]3>G~ВZ8Ra"ZzWlE'g=5~U:ΊΠ#/~l[s=Ƕ~oL1Kj)7lOgV9pw"nnGauI!~gЌ|:QDŽaRM'>|c ہ})ٱk$VN =SO46F ΋t-BژێKl%@J!(r:Of'~954 xs e eQQN) (FJʚaZNɊ~]HƠ `ā Se&,rX^ o9N84j OEOOe.m^,ܜn>_Y 0)tTY ͜TGZuФZX7(.F _J;EWN_}ixw9^~vNAҚ(Iuys{ŲDr\RJK+VcZM$d"U 5c#tTF?c_\Br42;')꺫|ƎuWoERм{nQ9G/Kxbb r`%&BmsBDd tf LvmE]w~" A%J5 SmIWw#x{XD^BALˌDMԑ:H\fteeax鉇oݡ Vi&Cu!m((x|/@+&ˀqVSVma<b,ډ#kR _v66i]rixEV1[?0iue^!-!ػ@#ԫJ@?x'A*L źՠ0|,t4xអf] Y,h0PZq&>^ bt((1ি{jeHSRҚJJt5K58Xb8H8@zU MNpU|[ TE÷.cx쉖~GZ۳wk J51r]|4[,Ơ_?)5ڞyrw(Q7ۣrPq8Ye7e|bgΣYŏux7nR t33j@vSհ:'Dm2`'u)oX1l˖qvxGE&i/ޥ+^Y$AvU d*Ӥ$yTB3EDBI8ON#S?U ZGFfm`Qb!JeXvRaS1dˢdY㭐@;;.aϿ2QYrS=2N@D,ŖZmh .Fd-e`B8z3_7Lo2hC_Z 4㺉|;oesq^oOm}CVv6 3j$A Ht'@{>1EJ1elc1zNy258pϕP`FS~2x->e{G)ڣqP|thoq>G9v:ͭn6Y5F+FmW*+qꞾmQꏨCU_g7?9fI iX5ctHThߪDXz}D&Y95ao^c>3\ 4Le!ЍDd <6id,h"hZm>\\E$8jnd!F|Tȧ|M|7gGPLԥkYJlT)FX&HQEp8<ezd3 -,X[3v4(Z4ARgUұ7Vʗ^T^J#e"虗 h& awS `]O=x[XR.' 3KS5hxHw azSaRDo_\"wps7po> ޼*^Ϳ՛9+*aa?;WحΦ:D޺erzMOV(-R@/9sx6d! 5't,lJۤ$wNBLB00>h mϕ endstream endobj 175 0 obj <> stream xZn7} ЗUQ;~ic5$[-;|IK rsaP4\g gBpq|GG%af:dR&rJE4Uq=\?NɒdRg>%#%+h-DrM#,UTq9&D2sG,mKyBgdBGV lʚQn:qKytr|7=Kh>.FV?N'ǰ/-peLH*yn4yn<;hŁQYj]tMKƖn51 jNwa .*~v9rA*< 슥QQSE6\@\<`5,%zpDM︩Nvx"m3C;hAHpS b3b? NAAk*BjonB۱qL'[ CkL)uP,_֗2G"32mJHx$6):T.Db`7 Iacƃfc= 6(m))SϏCL`T݁#CVCcO5߾]Zf4 ^xۋPPc-OSY_92$\?OEOs / )p.>;م)?C)8.nnUv5v}D^׭ABZ%!(_P O2(8AkSUoL o}Aomfg0{Rؙ= ^ĉ\L-z`l[s'6òE; ]M>4me.lP .d` ,XjNDd=:) vH2ʚl>2y22 ȀJ[˙w '/g:y ;h/fs 졓3,swE-tNf﬊ 3V%[J*SٿunU+Wj}1rջ?Bn,SUrHS~st `&3O.,{3şw/ng.\_A/r"m->("øP nY|Q2D:5ޠ: 5[Qq( ꃏC,!(;+Por;h ] 0t%Ag p;ofS0H%>0\YKl?xAY˚cL4jDMeeTe8IK5R:Vͷ*a5qVrPdbpX5n_Jn@-bxbN3XVb_[Rdū abmVGt;ҲZ_XvmE)UtwAIFs1N㐌*2C,Y2`TL4e␖/Mc@UDb<הEHL$ R=&L$vkQAIV8M@+2BlRJCE&Vt%bj,B5dYb!JiġP_yj8e'})x n#Wp@*1{S_"ԃ%~lkza^ J"Ret\$μ@6N- F18Oޯd9sjܞуy!(?j"W\Yhfql\!~٬%O&9*A qQ0PixidMɠ ӊ^ endstream endobj 176 0 obj <> stream x\_o8 ^E͈%rnp؇ܡp%5Y[p~3CJdQ\umg7.>F>J߼޾lFqB3\ hS=p~x.ZŇ)m(9?IFBE7g (] kO&_Gfmeq%2vʙҤUt1$}okG3&)mCYjcn~Qhg>_FOhuqXv8E6PYZ9!žH:#̝A|OnڝPNTMo-zV!Qbd7%RUCAbR͟A ޗfM;QU r (T)a/ 6Qvs ^4 THq$H6 1Gab6-l`;A0}]F:WE@&SYQ(@IK;=]*}'g{o`o&$.H\C0^炵q [ղLTKJg%! St3,ZeVN[Le7Nh[s->x\=xv S&U\6랍qఱg:h>՘P(|xذ6aTU55@qvYޕ 4eӀo+ƏdJ0#VhDt Mj́&„ai )ÄrO*b4ĪP0:7L%z`\ońS4 j˂ɾtI&a|E-`)a O_7(e|G:K\"IyPR0Nh[-ZO ;La=U>rC&JKRLNx3q-a&ꆵ:?u뀫HӁB0ȶM:uu҅ɋk9l]>iq!p"e=0~ϵn7Xõû)28ELas^(O/S߿!P, *0V+=j3A_Xi).>K(~{7o+z3f@sV&\p')wnҰ;7%|\wRyفE9ȘˮV\M])3T~S\RKv7pJe+F|0Rj,^j]Ȇ-z‡JRM|ڵEWuhJKc[imG[[7G N7ނjmSFQ˥QưWb#Rwc%\tJTDq©p g_"n}K0iXV| Ekq|ݦCnrq"CIĭ5 ;6J/f 2b`NU֜8PamoؕluYz+bU)[GtoYl}G!4;E1n όFfzXs=WӨb (&|Wt[Ң;dNab)L?:=㎂LY0f@NֲK.:Z5Hw5V]/VW4jn[SkӶ%+ J6:l`b _"4)HDOp8C /:|޾̡׽ _kdij'Df k^EwLPRl@u*o"ZX]2C] ]2OW0ӷjƒ%m?A#FS lhrJ],ȥN ;_U—?O6) R 2l$W `袳=*Ū6w`+s{0;XN>&Lgm!xK>qŁP΂2q GxBgښ1kr{u5wμ}%+ޜ'v׎x ۪A-?vgP F#Pu˹KcՂ qU$\4};fƲŦ3a_^^FxÊ6q]bh&uF''4 )ӥn6 @J}T*.=qݘ 98NBJ.AJRJ-ג%(}%< ׃7kJ蚥E ǺxM 4yh.͗Q}ݴuíߛ9Yl4si]߷/J]ӪϝW_9^V2g=]U2jp0Z 8h/C ~h1/l^.w@2`LKѦow!)O1~ 6ӓsa8i_Mu;7`Ex:*X0yIQdL*ua-vLNg J=f {+[=Tna";4 endstream endobj 177 0 obj <> stream xZn8}7cky&1;Xͳ:mݾAxߪMɺ< v$,S.TtG՗O_GÇHDˋ9 g6Q%&*ˋ\^D~E`qy]El;W>^^\&"!ۇ q'":JL <\^pG7w?xf>Ymlfxg*rV?y\bkd{zKl2$(a[HH >mQHD W$gR}}%K/)ý%Sfedt[`#׹JԞvn4~]܁ZZS Tw^%e^TSE1$ttr=\ÐP;UKMsK^Yf[oI2=^FR.WFO#X-+ˌC[REdS XZڱ4 ~Pjj]("E4ɨXuDXK  fZ}mo_Rْݠ?E} v{p&b@ ؂+2+D&YӜdPw .K:ǔ!&q7K~Mol0y[9*zar נW=*vοP]tDkD6"KT:==DlـBDX\ڜ` ]نQ'3dIт%捽Om=$T+y v/<DӬ@rPKT?_?F5?K (V]>V%QV*`x”x{uh= 1?"i "]RGH0m ޞ%t1`&2ndl29@7-J_#J>'<+дV*GqKCjXgw%B.sDS5gF]SDvQf"IO##;41iw|Og(ucμ=rG) S~S9@[ ˇ +6}< @)y`+0;)!B4VXVj΂Bt i xA˰8ğ-DwD8cd" @CajU: X];*Ui8LX/ʗڭu!UF kAݢKjhjQSyp֬Kel 8dhC:W];g-Pcwm5R %TtԂ*U22!\jlؾf;QKkmƶ[$9˻z/AɈ{ORf]C<'ԠuR;6Q#*.AE۴J kf6U%U=_"T:*8}@fj*ʺ GAf$!=YZT*}> ɖq#Eh DI]YRUy UbmIt?/ڮ[ %#SO9s6xA넹2( c}/G:4ᒩpf ʻ^@D9%Dp8|,5D!<5̀Z) @Sߓмi0]U,K}}4ye't2j[xހ 7L#'OisXb_|\-Nsu-]] XC1 4alU1RȆH}֋ݏzh=t( teQXGwZň?2IGM 48sLJ&b}2-fV޳Ɇ޸R`=#|kRC`OV?@d>ǣvw<(x9]qP|UF/P fA_V'R&üw9lw[mVAgi6PuT$Lm D-==8vY}5m̘pQc*˩xR֚*NmptǯA~ bwitVHTqUePm i>H$Ҕ9[H[> stream xQo0#;ܣ]5g;1UUڤH{=T(Jm6u~-An ʏpuU>L a<* H`@^<[^T endstream endobj 179 0 obj <> stream JFIF``:ExifMM*QQQC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?񶣣nU[DUXx`|? W,S R0 5_-v!u%r?kހ8euKTh nZ]}1wzmm0U}EC(3qsPQ)pq]iڬ[5Y5c}J^,Llu41Oj6:mzW>&7.+>uHO-x,A9z5c0+qgy FzWCgz=Qm)=svlOq^{7<2z3 tM!-M([ƾ!Lބy{WoȰ>]MBbٻ&} nHS>Q KzK#rrk۴th'ۚse +͡xZ23n(g>5dR8i+Jq?^"հM1 O ~0;|MZ+ӵ-w.$^_Ce8#hkf ZLl܁,$hlj`0s@WgV5G~ֵ (q&2LO6#<]>Bz=eab61[zΝ-ΎH+|CG2I WԄʬ4xcHA(mFtևMr1sVfe#ekz)h!뛫Ƹ5ͣX1q햚MA \pjX4&ArSǩkwa[5x[uAc5q*N=M7ž|,j=#Qh{1@5M@U>+PGs>6uZT&>qajF̠ <'{Gwo!ڀc괏{3Nj;oZD< ) P6ޠp8 O fi?-q~3˸5k+Hv|e? <ӗZ^JciB  ֵEy\3KQuuy%m*3kZtx#^uWp0º? xŽ?_Ú#A ȯ-6-iFiF:W<1h2bqkf]S־0k;VI2vx+(n3kkQl"@7:M 'i*(l$v,o:K2vet:#VwnخqKĵ71T~׭\]. ;Ӵ qV ]pھjJKc\E"rO4xS8w6j@"8kҼ!onWRxM 3q@OMR}G]cxǖ^jW ֹ'Kec&gnⲴOy?ܱ[6y(Qnxy;q]*\ۉZAsq,9?@ ϶aMѴV{8k/UӭК藚YB4crDdsӊnʞy溭k-vJ/.lToi7 6Y5d[Y1߃X~ Тu"M[jm[RV3(uk#hrϛIA ٭s賔VGŻ{{lzxKrW-<)In)I}>bI3@go\FvWkccHk:ΟiGf@:5S"J$2[8xjwM ̃i= xIӭ jߊ5b(<ia\~=*XPd63^ߦkzun]T@z"~ٻb^kC|~4rv=Et{o|3곲;Xi5^GKy+m/5C_Uzoǖk./nf!}:y4x˷5/#[! +vŷQ xّH:q^3WKp%8zt.CnyMAU푊< >vIˊ$ME+v[??AVk~&\%_YŁlԺW.@l|:[ǴVXM߻d-@wؒ;d*:p}y#6^2+JI}wMn@3I}/BM*{Oɬmw mEo$<ׯx3)39~/ӯ5#Z@f"!wײ*XAA,j̩%yXڽ~'0Y4w(9 vlvwb!Vz!6'VKamP3+r0(ϙᮟNfVG Rnc|ͬ@7g}uf=j I Ÿ`n$EU'+k[jh'Ҁ<_Gږ=f/oԊSR߇oFY1WghJq@ȗ1[,yX-ݙTqz5RBce|S܀XGR0,ַm7BᐅOfzW=z>e[ojMcl-9_ͻ9?#LOIECzPWċC`I|HP[ @[ұ?N(l @[{܉hPcKi+DWoBO";ƶZfv.vxqw]"衽kt[ !\vZ։][ͫLP?;p4e]U6fU<`WZk C}k[H]- 19z7<;o.5ɉxoԥ7jQ3r6^V~Mܧ&5>kY^=N̒Zǂ7XkHV'njxO4:F ~5kwəVzoۛK̓s\4 k]D\ h4bP˼k$hSySU/5$Cn}6W]Uq9C}qn?hvOvM{ρʂ_,ظ#/X3U{^ oE5b[*Xv=Sֿ{.{/xWo\J Mzɵ$a.sךOJ tm5tDg"ҽ;SCE-e0S5ͯ4O_0܃57#Եy@sұ"fɗJv.&4JHl[/.%;W;{U-.$-Mt3}cp^Y*jzLj;x~"{,ۜsu;^[[f\㚹xbuaNKo63z ג)`z$RJC/RsjZ:rKv U?V0c<"a5}]@9/x&+p~bk[~Wp5|9Ҙ]8Z7t&?&Erho4 Ok~6 qJ;RZ'ix?Y $y #MMTPp^E_ڼ5w u)t;1ڼ* OEZUJ:Cl4ˡIkqcnuKT]cU$ߓ *.]?\b;]߅~"od*8: "1sY_MҴj^aK[`HLnӒk&٬]j wdnsw6ol QTq-se!U'O:N85® sG?I$+q Fk#3ʍrjڦl%՝HuV:f-ڀ-A%mTj~&ŧM%Sz<]4N[ZaxRNɉ@+τ8;XwtgM$Hw9XJHL`:+mwm#-ڀ;O ue6|=|7cl+ ;MKۅ,@5ܟghx*K95QM90^Ƽ]ou8S74sVPs@}\o1wz~!hʯbşq:>$U¸h^+]Xhh=~ n~*ɴPoo-D1\yu4"s )+~!_]:[3KCs^X؉d<<)[Gs\VnuA3W KG]gkŠg{XWm Q\ z'?jW*~ˮXq^{8/^x3@Ѵyǜg@tftp6PBRsܘ읶R;}k6(\[X({=$ج~1֩[ZΡ[]s5;Cgns@iRtO5e F К'/K !*9>^&-ի u.mb21ljF}"nk6ؔg8xSjpdc=kYhf|*2MIH'oSk3^IxJ݉#5/^Gt\4|LyJz4"]F07Zj 5/N /MY1Wu-3Mu)l7ex-2Аus^'ml˞bmu F(M>2C+qd$]92_v ]IeXzYpDXjZv ǣy/ ZPU hM4 r:_/%L nJ?ϲhF 氣Ʊ~LH'+{X^@{6R1fɢ]bFscj>t[+W|$H@ k*Z]U5}:QH iN7RGt TcxN3ހ:xMm>`\p+ˬ_n"Yt'Hng7thi1FO״_i"5䵯HJx{GɈBدHO}v\ˈrvc5CK^ 9cf8;ҽ[LJKtp1ހ#OXc6Fڷ v/i+"5z."DDheŷN+Ҩ[h=5}v$[)96V7QW^Ԯ|BmlPí+MJm݌vMH0Ƽr+N2םk(VZ 1hphxR˞+lӌ^ߦjmm#bIQAK=3-'k ʭa/ y_1~=/5Jss M[MNvOף_ċiGAJC_3";]+֟m V~Vs])%.03\?5bQʹz v3%q:gf1X' nX.Ul_u=^A9&O `<7k٣8^+B fX\[. su?,(Kak.t2[WmCoa]'GB(o|?H+zQg x׌:lwO-IW mZ+P_In7Z?Z5K85j/֯m±( 6x<[m6K]|`Ԓx5[jqYAڸ:u;'׬Qwx$7:rßP~dQW5=ΣE9n[OkgȬ]]x^ĈLl XnkCc$ƛO| 獭#n+]U.h/ԶFvːoN>{{*yhJyA2gW76d''ր+j0p+SMݴw3r3RO5!Mjq,,YҸ \*wvnc5h^!Uh' ls@|<;j`/ ][]^Is` VWgX1쵱m##ui#ʿ1٫3z='@% w72\iń}~Z6\Ҙaq@,qp}EI;jf>%qdⷾ,ߒU qkh^q?wHHH;Sh-Ba@:waU ; ґ$c5WYa{齷x5Yxwnڽ$-.X@_j--2!=W>Ȭwb|`TK{lFxovzͯw`kX\ק_ fܶz׵gaZFx]jZIJ@H:rkծl1sd3x֋i;3)\[ ޵/bT q^?\#aezWũ+t[8 Z? n[OG)֚#k|Ww#rjM4aUMu5Hp:ǦNw-&IחI.uIUl@2hGR82v.IivĮqXZDzLyEjY鯬CPo|nܣ1HqVWMXi)w>7<6{m1< ])Z~&V)v#t^M`+wVMOkˍ5i*K[T$+YMmʡGs9 ϵ';sXWZI5:V]. K?Kӵ899j/AiCN m]--AךxhǞhϵ}5Kxc+CB]DˁNKQ7>j^.-vajO\۶;Kw@񟃭V&\ O˱us+&]Ȼw4x_L}{+a_`*xš_Kjn3|DY#KUuoq^9ѵwgӃT-טOzN,aA82 O\/Oz}O]c7 s}J~V ^ VBޞ&1\?1P\j"1+ 548z_.tWqz.s}>'m{f|ڥB\c3k]inF h:+ջns"Gkјo*F85:߀5+ nb5O`bnK̬W5oKڙA5趾t%t( endstream endobj 180 0 obj <> stream JFIF``:ExifMM*QQQC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?H cڱci" z}g,yXޓkgppq@{o$={=ZQ.nVhtm'O``x>d}k3osJY]$k4GDxo_[]YFx_M0Jd^h'D3'n9gŖZE h<1̂x yⴼ3e{nquֵXF+ZT1E#*mḙRC&'?u$jCNF*A\\߉n4:nAU4/ m\5|֬s}kׅ}j8JLdVԞ*csۚT.|Cj[X0Gz5x_˃%I@/|Eu]2TWRr;l`y[g=RFR xB+JṲO.I ǩQE5j*yKO1ֵ7 r~%-*Һ7gH@[XۖpX:+/\Ubp>8M7M-11#E+Qq :"ϥzbTwm6sr~v,7Qӡ&hwP ,?9Z`PIoFi#~-X׈Ki4:w,H5z~ˤ* s@񭆟u[$5xB\3m5&?| 7`*3Ncx6)~5|D-Ν7{\ۃKHDaKmafrɌ[\ 崇#klj;Wj τaԁ]]֬C9~٦\@3vEAyeUq8ú w?1\W^h{I2o;CMjEpcNn-rrOoqh4xRi<ףPW{$WnE`.msa$:VuߞSs]Gpi c&6(!H 5f`*igL;*'> 4KYgL1>z$vOr Wؽ0h֮dB F;W1߂\+mOh-Z(4,$&8ORtqy^i5x9-f(^E 5 %y αo!!SW\s4=4`溕z#SģI];㜚oxt\4+:8q_XuVEiJ239{-VTdjL]cVuZkg[[A Z>Ĩ7{מ[+@ "2H@0w J|A5Or*ܓx. X9ր9kH䵸FOz_ aȹ5 ct{u+DqAsAts\Ծ2ξ nVVFkPq^9< [xEn=)Z22˞+LuVl#1^My߇5u#v WZ[i rFMQ#(xprC^K*Ƌ3tr5y'#rXhe+&y05Ub@5A=$}N]FD5b dv2LD#ҹ>F8`9E>{f0cys}΀8_qڌ !c< BmkFcV= Dמ8YҀ?|` eͥ U|IO5v$cst\@o--آdO 3z&%ʃ+ ! 21@o}HD |}/xjte|O|]ŔcWexχ$6*WLXlw4;KfTRJowMz v\l TVF)7p]*ܨ-p|˱'4&A$ςnB1]&3Ҹ+y@ml62]_k<62=k\'$ h]Λ mz]C6( pEIi<7ψ0m'\^yTt=N{P\ðZž ׊o@8h!0S*S3(D6%B:fxB q|HWWC0'c)bC_؊-[LVW@6 @٢]_>Aϩr!2¸,GكCN:lp@S#\56(K,A,ZV[%'ހ;OkGMA#/KqW|Vf{WYu-<$ԞwC~bSRe<}*[6JKd'%$oxPp+6;(߸Kcd8.my#9MaN1 MOR} WOc:H; t=ú=Ɗ&Q6cvV_Mhfqֹ3IuPx'pQ7ּbF_9r03YW7^LC D3zgvl'y.A"qq@_Z}.+% g/5lnk:X ywt(.t 3*qZ{>I pQޫWp5'SYG#Z಼3>k5r\/w\!=kmf\{S{>S$v~Dcu>Ե]0hk>04jmays޽E\q^A⻹m^" -E2p+?nc;8/]ܴJgٝDDy8E},] ^kau'[s^jd1b19<]ٖP5BQpW>k~yn\MDI=H20V4[~Ll95[jٹBǎ͍nC{Aqqw$M2*ݿBA+I{elc`@x%aѭ679euv0Z=@-|Q^,JnNd,ڋr f:ZYsZ~,ff([5ZЏgՏj: NHFcV7z?6;L܊mwbnnkcd,;PnW\=C=STn^mSeq<Pk}\YدEtI%둑!bɻ5kIo39 :gC(lzOCipgқLkxo-v(>kKAg݊ʶM9E^Dנ_{Pkvy-_OaXyΩw g8F/\k˵ ^ɯXl^0i"l9Uִ*۔LqKG,%3ڤ|;w]oVi~?G$Hz ZSqjŁdqҹIE<@3M4ޢN` RҸJN 㱪EbRvG"Oj^g) -5Iq@gZQb_M1P׮@GǓuÞ"q.-7Uf);W'[8N.홮t߰eSh[Zȃutr1@m{$[]jvbOҹwJ"az$n%w 6`vO}= kx jy&=%A6UP)reO=+CV]$Q㰭-#ŶdB"|KmͶL`iz.yjڢJdwO]>o9Us\ύu4Cڀ5 5ykۼC. @$R +-O6Y6K% zS ?*u9}iHma_U7|We}:/גBBz.#Bm GZ~bmh*1\IMhGifGd6VN m AƎSI1h@mx~s(qM>bLk-܀jҵ{Xٰ`=.:~WW+B]rkRN}+优H~ `[mހ79_Os]m].^ I1nFO[R$ [. K` ]i XTM= oYiV_]}EI*O /&NsqzDMlnWZ%#߳=l4k}^o>X<]G{B 7s/mA=//'et~vJlwt Vפ bma8uYXXݻlPk; _8j4f:7:-3'ywͶKXWMʋ: .q^q_.a=}+RÞkր-9g7;]4L>[I=j֓{z8rr{PYIn 5j1]Ak珲q@D^ԭ-0 t~%t |)X2\}v8PO֔p[myS"-@XUЍպa蚌RG5s^agb%koܛ#*>"?7>Ckgw# SFD {W kBgWdz˸=(Oaimn@+Vګ,zS[Jݱ\MӽHs@ѯ ecRm2ҭ|0jo^o23X/ʌ\4eϗdPiԎ$EgY8זiڽͅEwuwp`N(C>!kASKh7)=u@_zUdžG26\OO':bsAwsXc5jP(>~/ kj$BO6^۔9:M]nsT+٬el+w6h#y- v+/b8-Wx06j/#nvzdRY=ɠo5UQkӭV !t^mq)sh3WTO8wJym5yq8$Vl6;k +&X 1P!ּLN3޻OYi`%v;W?o>#\9^+7hGPd63^q\uDj㛋ˏǒ { :܂qV >ˆAҰl4eHkRG(:mʙe9٣Q'ַĂ,~lP-~gԵ׵kOJL,.F\\[s==hҴoE@5N 7QUVk͠ΣTS=^?~bm{;H湝Ww+,qkGçiE98 ڌqv֫xzoy8r3^Io6A~3s yεDN=hx+O sWYX>lȼ՝ONԅ{5 +-+Cm/uy]śe⼪Xo\hPXw:-۹Τf[,|8a]Ephz -s)\](T{Kgl:N&F"Jo \=*Lc֕OӖ^BAh;@BwuUZ/Y=[bj?op wZi̥w`Wɍ6Lkr{0Gz䵭2ybF4xکk!snOv dc5:}:PY1_x:w`j=V.᥋qq8d'緱lW-D|D:zzZ^-R7J 4x4 LyLZ䍰6k#vZt[0:~\@8\8⺝IZ ό7f IdtW.qd@e[O5Ątynd:pjxhVZk[E8 (חź]a>Q#եڬKJvk:\]ܾN'g[v~4oם^xrX)v{ ?Hw\u%ϒPGك,8VMįqҫ^T5'lQg9%NװCkmM0=kԭgDFޘ^U;{WOs5Բ&OZjj@Y3{V^dt}Hei:ܷb@9VhbKiZʮ5x\ɪ)[Ҽ/V9\ן$ad^NH'%1y>"m (fmt$ & (sZ}q9mKgᵵI@_2px&~kD Q4 ƽ 7Z<7kgNa]Nykt>G5c{MoTH-p[<:dfFkČTǜw7W[4x>K!IOg=Kش;?Ky{C3ﮞ`v!I3¶w`<"ߑ'4 W,Fk4 RM>5>5ف8yܱԎDnK۾}ը4Uza#4ױV$338e^iOQpp7} _5> 63EF$`8/m`hAnw(ԦR!EbnDOQoyѷW4Fke|xMW|af /j|mfKKIr~Z:d:T/lnH=ѵ ]1$ZЄ<\' u +4-N Je^}oЅA@&m{݉X|)l,퐡Q ʷ՝)4p{8HYzF:]Ry> stream JFIF``:ExifMM*QQQC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?mbk^Z-D_I v Yu0O(l,.uf2WwzAQj$h@ڪI9 (#7Lf:s.FJ6!օ?ŊY4B@W5Wp?pק[k`Vs:.= lL#9&|-. 㩭 KQK1@la}ҜVzڌ9xl=Z;iͼd'B>Zu#@D?5sW[xwgYJ`"m4Ϩ B$`i,졚3oo0:׈L[x28mVʬF3U%+լ|?2ZPERW76EgI '4ۇk*PTV20t<lKc8*M?x3~F3UI a_#n f-8{(.-X"eY1m2PK[t\Wo֨k|1-rMvP=mQLćK>+M8x[K"I[6v)W5_4qY>!uKFhٴWK25kPlck]D3W<=c<$>xSgfU5ّ:⸋JkhcWŠ}jM'Y*z4V*MuZvk(dw.sZ>uRV;j٤;Merb:[H6q$LZ~e\Cwf8 ofW|A{hgk|FD,5>55]CRI$XN_/hcedWަ\Hp(!YgTuXjot0kuXN(]qpТ1h:͢BAzu}3JyEoCnc; ' |C`Nxn_5 ѨEx,gKs6{,LGQ dlA!Ӵq.(MlgMh'ִz 3g bh͵m8h6Z4ZqΙx-NPtYYgOֻشwc( RiVV1@U+D[ x+ӧ~uVN~\b1bq ` 4d$RVAnkV`:P&,zaaj"6+}/ӭH&5і*[{7Wr+7]%fX~ö.-*i|h_R)eԗVlՙtJ@^; $h{Oa|,-D8񌗺BZ25mbQና+|!1Gsq^yxF=Osq"ST,t,CU`1r>'0in#pVbA)՟k52YP7@WNl.ڼ߿zu$ډ7%::imCڀ9 b9$V3'\դ`$|V.^_]ۚnasKix qV`SQ*wvV>iۜP:s]f$nzՕ_Um nXB vWzᵝR;@xhL+ՍI[$/3[lzfMR4z[:mwJF@ n3 3Xw%{]El>%HVE^= oϴP=hbEXakMIf%A5Jn:%f@C֋+]CFI3 X"iFua-ڼ4]Zd;s7L/LJIn]^hm]+ʝ֤v&258(R!U+dRѨڳno5[ЭFq@^zl#.T4]-⺹ho1Jo!$N9J,M 5yISZ֮Zݎ1+P[7=OOR6mnSpP*-B w0ܚD\yK _#:W`PWYi;Izo D9][\3j& ronKc`G{ Ӝֵu{fSR< 7 Ib~sE{*=qsKF֊^}e+vjO ѸێsNf%&*֋-jŷ#5X)gkWO:JP]gas65sVtX7ųj^YnEkSNol Nv;נ % z]ʸ#yZɽ8v6v5$^~⣭v6Y㎔"ix~hMϖ}zRxÃRWuz,4kݶ8'7R5y\ǧH$UySwPhjMoҀ<^ m?bDVȊP(ɬ.K|@mavx5dT-hdH(XZ}ŮIc5xI5l_ⶵCHZtR79hh#9h"mJa=ƫǷ4nAUm5tnj΋j#bˋ%IKQ23]Gmꏇ?%¤F}y%0v$rsܶ3)-RN2klbKes՞c$bFhfӴ]j j "Lzzv+&3@XAjt\ۼ $ԥ]? rElۈy QxkP.T9OJҵ[}=]F@k#P{ Z,zy˷Jѵ䴍S"$= Eqӊ?ȓNEhpΞs,V; um7FҶ?j\?I~!Y'(կiP4(U[x3+HMRAInVȼ0::5Vgnภ!>Ե IcWF#wbk Ş$a};~@ֺ+ Ԁ,IP=naԓYZ~taWimܸF=֫ifK ^tճaan;צ c5V'% {Pf$.kүy5NMaʯ&|)?Zu5QڤT~f":+ >ό_*, Bڐ+[)0t԰ [@vVZN$ⶮ5d0sT|%o*,Dfp)їp楪OI&rzk}&Kn6z5OUv'JJ |!ZU ѣ[:|*! I x,lf_6@w’Y@]MZqtisuEo Lׄm3:~#ٻojgO0K5*֥;Il4,z23&f)d *E|Ҁ1oȴ(H *֤a!XYud<AK[|@VZR@8Q5iW>FqހJ3H㠬 B;=UmCw7BԢׄF1ZjFy$jM* oOHq\xҞ 0:U3sҥ(!M{tǵFM%s }ek;^97!1<+S@ %ӏyoi}5闞&uB>(ռG˲$]չ5Xm>Ӝf;&mNn8qn-* /UKM 8ր9J]Mҵ]lِ=lvn{ Ӽn9-esN,a5ff,s@D~4S|d0=okt 9\k ;5s-knN,i6kr7}$S޶5<{bO1 ݓ[&^ټ`;^htGe~]K0驼`5EkQRQjj$@ڨCru9LkI >b F9_藗s]fbr*;QLn}^{Rx'nhi- kkr+ɁUX֧2uiw88N[WH0w{]-I @[3(;sS֗j$}2Ryg.4Y@ VC4.3$B(Sp>(hދY-§#y亻Kym]\i;өɤ5}kB-X@//|5 Gjf|tZu\W gU*LSCb8j3]yV8 .dl<4>Sv{Mɥgr;PڝjY$ ~۾ʯ84Vrk7rqs{zkN{=9I`a-* X7 cQF(5qŰ^hr%Hpi6WY#gu+#+R^բn5.ceDVɠ y"sg ZGM FrH A8@O'z Tg5tcD\[{k r1tx6nYVJ~h1i}m s(}+or@[YbGg%9>#gy4=@B^+:X-Z]hkHwX˿$Z.5(&$4NMVR ji=u;}0Iqz}ܪxV{/"W85s]{Q3TShbY3qCqPd] UPpMoԦTfm/na|-,& wc[mF݆z T~%Ux8CI|ۈz+66pҭ֑,s'޺ 6,dUFxP,CշMfҹ;n13@m('avHqz6؉qڨi77`͸ Wz-ov=v앛8m?x8]nfu%YX.H;q_-ZJXy@,-nK;ߚ%ͥ-;MzPҢ+ivWOֵ}B}@$k* {5x~h.V^+(uu#5oF`u(OMmx \8Fk:y,\Υ:j*PKԢ҄rc8@pq\ {Ս^i't-M@ ߥVn F@\^;ryp3]ߒۚOUԶB=|1uey*v^#մ;PH1q{lɨV5ygsM}I1K ȭ(!*V۴U1Ƞ E8`3\enjg{kZn.n4ƍL@G94I IiU^H*RR.9XO$|) 5kh,r()W屍 iB󊻨[bGJ欮 SW5=6"[ {Hk~IhBP pBM2RiUzfҒ@ u:W@*YqWR\Q]tKJ׺{"ҨbGz/jں|ȌA1Hgy-^Y&k~TAf1eo%girLg9 WMsEm+5kKozd6[ 3Xڞaoʪ/Pr ҫ|4tE+r 㠫{Dִ5ͱufP8M63yȣqϧĚz d#F(M$3]`I^%rkz%;؎WWD_z_'8'\vseү2xIFy9ԼAex`6*C%zVsY<W6#Oے+ּ@{TQ,ʈ&cT* $k2s(fcu$#>'VK_'k5g=Ⱥ8=3_ ˍs^D7D]o[ƹ/jzI-}ou[.shr[S2aF3LXXnV&ERZݦ`Njzyj ۙ&"9#:m؟Y8 CDA$|ekFk][{p]޾L P>NyZ֜m[=]72ԼNm4kLӦ֕K۱ Bb79>kW|?Nekx$ yj% 3ں: qހ8ěnrќzTG|psSlTA]3]$6*j.k:P4[\Kppj;{{yoc5ؤ6e\@2Y37B bbWrj#9S+ҼI5rTwPGgStxɑ漘h5Xr?-qҀ)x[ɄҢ[ٖUkHu :dQ]=DŽt&> stream xk0 Q*Y_҇c {HP M6~'%avۄD'G_|uqW@γBA ڡuFɳY@+/5f[]}Ya3oSPlg*J*˳ff#[WHhwi[V6М Jێuqз>x-P&u7*Eʊ+X?oS%ݼƢ$)N,ZZ1=u# fL;;ytr}Xc0n1̑bquvĸ1ݰCa8AuSKeq.ɞF¢a1HV ,6p5dU2'dU2r?}Y3FZ5521-Cݬy.tYZ0nԎ5?5\'Xem"{'NJazV{(opBWhQvuk\=a3^`j+`% uç \o}4 ORoJےvPRH X{%][ŏ endstream endobj 183 0 obj <> stream JFIF``:ExifMM*QQQC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?\ܑty=uIʲ\qs@mp`zV%і;xsLą] X n]o}A".ӟ(H_߉&@Ui;Pou4 W٨Ȯ^/+2di^)i.B=kL6=+4`zפXEf(Xd,sT-@{Ģ&F+ӌtuZV-^NMwie^_5Xu0,lA@s (V#nI|.z֏Sj<tq J̖;w-(oI((F,B1yyDv1{l@Z1s,L5[כ*O4yCҹRkV!H^{{G22j;S+8-[v2G>ʩ]I*kֹ,na\ 좟za[xn;p,[c+:X{ Q*+"nnk,t%Ya'ڀސ4òެ»; ~ k%YmSK.,3@X GI>P+uyka].- 㠮 V {{{gyB> h;>/]y\]|iOէ;}+q LB wP.ĭg[ 5ҷZ>V''ʦ6`(B}97$˻$eSe^X%֙k~نj۞yᕚ?k6wuM/RjV?jmitjm4wD.zy}Zܨ#qK Ih։u4d's[`*O8[A8_^W!sėVVʹ=J)7kلc@"+:`^m#jXc9Wk^ctJ >ba޳e,,\޴6x)E3M%lRj݆q@spXh\u{Ak((dP)iϡE:nW,xk>cڀ25=PaAoM:$ r:ϑݷ ᎕Zَ<59\47Z{3Mi=ft:V3ZiruhsO~DLu(" `'ڀ<'rݍfh:,|d9jէp>q\KuQjK=y.z߇إt25:dPht \E8]U(tQOpYsր;m5ZygicMKsV'=(޺5^鲤Č՛H.c]zeAfIY0[B28 +_zۈ܅#qvљ2=h4ЀOj-38{HZPҪ VD ր: esh3EyI)R[B8x牳$֙yՁo2 ]6cV gݴy^q^m8fk$f7ZqA+lsҴ a>jjE 8y6 G=kCA6V%8ZK*;P _gqX;uGϴCjpni \۞ٶ"gyw(Ip[5[Ojm"y4,i<4OuB3M{?\E)5CB˰YŴ*[ࡾIB+)L{ > H݃;YzW->{^$ NlH+] X|nvs@ڣf,֘ᱶ~lP/=IMd7dMv!qW.]Fzr^- t/W'9Un!J.y..rA@e!'5,:kl+a0 PY4łhckյ1S\=ǝq9eZ4BY!aHVz.5^Ld3\YnOzt_ "G߃[zB%Aj`ȱ9l.4Jm .^"^sH0͊ع!K)T-e2׸LȪQaj7K8^l0 IV^eݣD Pݓo@+:qM}mCysؚ'*EEL(ng5i8Ek kg~kQ"v [D7OJKw `{P!%qm"vf^!f?\f4mnEjIm =+[Zw,HIt&f [^IN+ĸBGXV@3@%^՛/sdu^Y}rxBF(-=vy;sRɭ`=g@Xq/q$XhZ*]F\#p~!X\\5TU t;N*Lj"Y[ hΩ~"t.ms)* nI[Qҹ9u_{.bc}:Y'z~sNfYV'5.@̦#uFnsf۬Diڜ\bz{m Pv;dRXzb \]KT|G3XZgs6N:XI%c&>cr Cե2⺋#8-?I[UYqn9 "%=bGK6H6pxޱ>ҬM'UM pxVbQxZFFk;EWX%bzQTL K;rRCS@z<*TAzkwlM@ \lgbVDZ[jm$-&y*ӡXa޷mojk`E6f HXz! nkp܀hY87s^eIsm:^xa8 wY#g%kOpr*u]q@lMJic8hjS*&{\s‘z(ٌդ{N3ҹ_~5iO0qҀ8v 3P1H5\`],(*Y$6OJʹyn=NxS4PWmlRǟJ>ϭtSXSڸK=h_^&93WS^|Ex6m蚴0Gc@Gv䢓PH@dR+t}2u;$-@ .0VM*kuZ{&; '.n$txnΏ kʊ~3̠RR1@Z[[6x5im_JRXj5'=(Qy]sn$t3]GI{03@bs外\t5<kJV`Wz \ɮFieTɇlVYa^emb.J5;-(]䀨"g;ۜ94}:lj-}+⹭NS)U(ޙ2rizUAyz/NG~~]\+إۣ}GYXKZ}[CVgö+7Fi0s@=B%ϓ:^G5_SեRj5*( @72]N03Kamtu6ҀX w/PF:lּ^7$6+/[xP xt[V8"ehct*W%) Fy>IQ41=sn9]HB1 ]{Òjw+*8,aImnxkE$T^*Q ={DN"E_f-/īq S»e dv?ۑ\IL5@Z$v8^x%NW8_x\hfsc4:yaNIoZtfZHUHOK7XP!w9a\J2ecZt XBؠ *[+M7d@~v8̊Fu^þ&1S^=7^yy (fCU\\r<$3fZk =ky V[r(d;ոܥھRAo~ͷzTeI'֯` k2o {jm+L[ր;mR'M{nz7MHmăҞax WMeb+]er1D܀IlұQ@v~%in@޻(% Ep6Z\ G(m(l+O[s^"llP(VO#rvAQD"7:빇JZPhh"Fq\6s=ӱ\2 .qZ鴝.φM5x{_hF4צ6 2֣k*ֹJϺ=I3[zM i,3Db0q@6֌Z+2|W15c@k>!;V =kmX"UgL@>"S|QsR:VM㶷;+{skr1gPkG]=klqrijQހ5^I-{4޵hkN|;$sze\nW%weFa =*v=vBW%WrQC{AڍޕvGq:$- Oqw{oG"GJhƻhA+ LxGQYp3@(k{rv$.ZXPaL'ֺ{\`KZ6@&8=M2MAڅ9Q~[+! YKx#1Kkk nΫڼ>y^5Y^chO%d\OF+= 4Ꮬխ"' AԷmP(*'EO8 =`;77 A#4hiҫv`*O=Es4 endstream endobj 184 0 obj <> stream JFIF``:ExifMM*QQQC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?cDHaY~'ZrFЮ(Mtnja^sq4ir4kI]β͐{ 5ǒMWmA|1E\k^+ uRWlAuٷ$zW spkf2\֡&v+B5ia:hn0+'US\c,wVj/&Hs2.jVqJ8 ,M8xSjԴp73@-޶su6Rvk4ʮ(DǸD5t)fHynU @=@d$V3dЖt V8 :ʙ&g:v`ǿhM=kY}+*G`")YsOf5ga*5({3Z:4fIa88:JJm>bq+444@1]F48b?( Կj2WjL@$R`uq Įzec `z<2.HM-E~ybOEe@`P5Zkjed⹙Ruۚ8}s\6 ٱ2!78v>-N;g@]qڝ̱pOZ v& 0^]^dޞ׳mɬy&:o\(c,D@^+> hPt#>j[7Pl3Zk<XVJU-y=ֵZNnI^iM;OZ`p*zװhWp@9ݢ ?$+m9[kS(:x늎T@ŽH܁ΒYNI weq H2GCɠGɎ+;<Y\Zv;|{: tVJҟ E%G -Nɏqֺ}CRajp{Wj7o%1*zo3 g*2(`pt\* @$2̳O rHK,+Ǵy&2]TzPΥ{ R2+ؓIXڞ2ѯZGiZl-M- ^v'^UIW=hܨw\׎h,ֽ;G,kր8ex[ 5j,YCĐkxʄOG;r}7ּGGeI'zCoQg%>d뷒$\RZgi:ebz|[B8]9R {W5M,2\`/^y5rkԵY@bg8gYxwGӣi@f_YU4y-48ieEq6,,»R :W9}0bր4cS}g ߛOHw`t51\Ń^}`a+h1]=fO-5@ۑXlIreCޮicL ElOq E⑰e}+f#V֭ I%, Sx;Qڰ g.֍ ='DOXf}x@p oWI%.{WwʹɮmEMh閑]X@ek{*؃O^l!Y6V&0(# I+]-mpdj?'etb +9 A5;`,3޻=ly6vvy@ezF|2۔i޽gGJO(AۑMzv-mJu/jijgC/#ҼN.a$,h pҊ,!-tgn նkA=(z$(qXr*1wչCy=+_<ܴ'UӢB%5X3S Ѻ )@E kE.mnZr@j  ZM<+AXvP۬mP +J8$wBOՃj+jv,G }Z/)W{BH^]|Gpz':~)[GЁ$t5$P($VGVBX\a^y^Հn7}[IDx- ^+xXCTne <%CXs\9#$M\oObFmeJ5'-!2TMhyg*Lvֽ]U=:9<#7z5%k7Aֵ4L|@Z26Njnv"2@ɽI\63Y7S2fthUyKv޽qItWO{O-T{P5-,$⸻ ^}tGynV*(0$V{r+u>kcNlz3j2+N5_?fjf liwMFE-mRxrm}+ί"j?Z[vǥyUG@R5.^UkrʣMz]ƶkW++6O,&;FKZ-^;# \D>YOZ ۋbGJ.ඹ ր9]C6 #a 謴%#*(ɣ*id֌ b= q %2o@XSWocxkx[nknF@B:G֟zTšʹ2@3GievL7[pcxO((uprj jHb5wHiuZLs$ 6EҼ@Bڳ.4XℲnUIOOE'Cs}o0a^hn=5qI}zQ04Eti3O#KkO`<۰{]*+Y'zn zP{hJ5^`]µg3b|2o2ֺ^1 3\ݜ~t>4+$4%"+Mb\@$DkjDG7SjGҼW/zvk%rk~s@Z}(tn( k+MҸKY䪱@Di(Pzn`//xa2z5{uݨl-yԾ!^.qMg[\6255H GĂxdH&v{yj=7fhO#rVr;wP?mbBq/ksGh;ҭYW פi0?,I8Žir#1>I[?̘wRChX76PZʹր0_'\g/x5]PXK,9`JG6k($v&ϽtҤ0+2ߦ*pi F2 6GU/eA&[shF*K&@7HkaT@Ɠ"[TB%{>m1txz6ooA{War UIR̗cے*I9o2 2RSﭝ85J͘K@N#p"qFkJƱRESk[qW0\щ s$uLGbiv vXVڀ9ߡ@N8&:Lp̗^ۺv2~Uyr3@R~3Zr1qzuہ9[x{ebڼYCtq\jc=˚'h5Zo/c_<滨"0Ȟ^89>pj$dICCۓҸKG 9@i7ړQX#5ʛ2*i/jǂEsnFkjY rZtCր:3QgPz-BҜܩ`z׵薋Ҁ+k ͳ^;e[^ӯ*Fǥyt؉#X^E&b8y/*XB0JWvNpH]TZ=?XҔDxM,JOӽt:0HŨu5> "<UduH刁6LJ6th/!6$t&Gw{4nM_%'msf]Ājݤs8 ]m tG l6kkNGEO٤DZ>tV1 [;z`qtvp7  W2dk4E` rh?wԋw`fkvH0%k,zZ8sXt|Zt`+*&;hAo&ː) ֻ]y"ij+X qY + ր;m[Xh ڸIIrO?̚D䚅cmCEwQ]HAq##,6'QKe-jzUM_׼C`7zIi3*.տk}o1 KD? ;IK 5#ujq t{HP`AlVݼjBɧB 8q̀t憎ϥr3abR`q޺Gs1^mha,85v"8d'+` @P"m8FW.Pu+ t5xg4 uVڄq V#5jԲ^gy]\4Z_EvZ\Ey& v:Vɴ@lH.YW\G:GSϞHOPEk'\+s]5f 3aQҤ;קhZ[%vm""F;HP2shI.B$r+sM0̡>E%\YbKS:W^@ DA?g+ t2σ@49enin#eIn-Om}+խIbnҀ1VxⶴUVd$Uh<@1T3@Tz]f.7@!~@+P%A]9`(%&H5jH{ qnpJfZ,Hpj-w݃W([.3Ɯ{{bPs \Gyt[oz[S\Ƣ#@[hrGJC>3ޮkw،YZa 3Q]Ȳ6km\g56^hg* [Yzn;K4znF ?PAfURktm)/"R9F]=}R5ku.bm :Mnsznє1_4Dz۟Jp.޾l$Jdƀ:dՅ{?>vCVN6&4%LH{xrٴ$94^8J/['Ryi[$qc$g+Dj@6 F#/ X0"7W'u}Nh~mIXIe=jɮN/PNA2:W>ùq\e+55e󳶹4=?QR9 d endstream endobj 185 0 obj <> stream JFIF``:ExifMM*QQQC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?txݮ}ke}+Ϛk>G(@o4p*k]S-ul+t2=(a#i'$/z $)8-; o*1ڵ56Uq@ӚN\AƁP'>NiNqD6xtd dPlcF2ELYbCn ]Rٹ W:Mz $Ȭk@]hZ;grI iM倹 E)`r ,hi)lM0^b IGZ&jFķ7cNN#8KIUݺ7gڸ]Z@g?Z% qڙ>qB~jܴ|\K ۃ!h]&j(4 4o]&>mk:=lg4p(1WɚG׊[WkWcj&J2.Rynz׫xoOKu,:;?C]k$`n;By)\vY2MZW!-nh-X[t\^^;zQjCv[VЃHZ-V21S}dW ydaۼhԲ מ[knKj: 7UvvD "/A/Ad@7:oVFQ\<~#j-"hu[S2(v tv+mt1dX{'2f[~wZT$ɧLV1]cq֣ P"5]v++ i0@ҼqbԮҼYdor<\.vsjHTԶn^>v' @ |oN3V1Ⰽ/i tM$gr5yMz ;P 43CֵmXC sUmjV5ji5n]eAJ#z~g\Ҁ8Ű)zM_1&궱E `pZE9P{qs~! ;`ghW.jބ|fs77Jy@$Fh\ޟ,dl]lV1<;([ +sLCy 1m @* {W#'gbElXڒJŸ4a~oF\ҼM7k5oM(b]5up5GJ߸& Hآ\jܕf.jr1z'wP ݳ+t=EXW/}+YqȮTpqQyʱCڹ{P+j .Un$5jeV5_J ӚXiJ `B#,PyFrB]]œjv%9Xn`רi=ӂL8h3v,=+V@;EnåD iD)kጰs79 @ƛ=kӀ[QJֻR~1@u02k &pk&kG!c5j^ NNj7%roX^&-[Sʒtԝ_jEe&fF6կd( +δa+].z׬0ک=q@-\ɦJ5Or1]Tk6i tkJsJ6:TFF<]$h үiP(CWNmw64GEO>xZxt򳃷vT* 6";Bc6Z7!_Tmk) ~=1eT$uMi25mJJb 址 KȭF^PqO$#'kw*b<מJ+էekε+aǭz.l>>:5kϭzvMwE&fj~kԈ@v^K2e]ŪfD5[O9[o*JIv:; /]x=2uAtP@^ft f`5&vSR[0E]qVZA1uP`۞ Zߞk86NiX֪(FUWֲC+{^l݉is*Š=Er2$mA>`0nJUNf: FdWJ)ghsjҹ4VZ3۰L|PW6Essִ@;Et]˚Kft@f,-z#bo6h2bSrGzs\U(*iQgw e WMf6pΧ$\mε4:KV+͵X%36zצRȬ&f8;hfYFAL0 I6c _Ak7U鄸v1ʡ3XH=njuYɠ zv#2h&HYW`p:V?"SGP @ۺVZӶҷȠb9@pk*0 \k(sX@7jb#5j{M~sVml$P*Ɩ;WC]h詝ER7("y. b,=+5np04T`†=- Pe9\ޢɴӭA4D5f+ֺity N@ ->+~ڂ.4_S@<6REtֻ7Q`T#2 //RnogšW)ܴ*V-bke$]Yͳo"I57px}dI0Y*gޯ.V{οg{WJHF[vK=PE_[(6BāP:{-KDx$Wt4}1Mul ,i,N/VN )y PjVsS^i= @FJn^rvxnhRA^QhJvEWK ɡ{u2C ּZ,-&p+jM(2%#9kP5#V\{f_38+5m@mJ)``^sӒ=j5w1s@D I^qn^26WhԿCUk*I5YrMU&qrtn.ޛ3@tp&jܑ+k{.wq@0$ (~“/ TkP~a]CiqGsZ܁@ 8K63[6H'4'Kl WSge h8GH5wrɌ{Eۜcy=Ak;lWakf<@O9)+LŶRX~j}#53j(f8 __:F{wk8cSZ6Aɮv1{PЀkV$ |r' P$oK%=mJ! u8[ P_/2VrT܊Mm2Ŗ<6enAIqݹ7U> XEӵs:Ȥkѭ-oEY8 ipC_;޵4>3QVW7{X:5HֶWM)ֽ+Fu@.p³p;ywEaK _$P aKpjݖ"A ki#䊻5V16|DgqNJsh0N((IFkB2Ep81hEw*4^DLN>+> 5,8<m PEq4ĨK%mtddi2$kN5TlԉFcjNMrj,hYPk{Q+m~ό׷v3@v ZMoqlҸN@zn^i0 oiH5D̠עij-&0Eg\bA}bUAp kK"kgs@,tf@H<kA+ڀ8k/.;qG:U3RW76%A4s(5Zj2k@q@f7~WqG0/Ƞ Cs}Eeo@pkU'IșMEq^g'u>M̵xL-t{/3@K|⦖rg̙r3iRy־`qE'aPBP`-֏3X0'kQ~ږ\%Λ7HSֽ"wYdiF ⢀> stream xVN@}G޽""TE4R}g@3gֳg_d|3|ΧF)!F*L6Fˣh7SZ0_o MzuTHgh4̖шI4,ClO*Ɛٗht1H#j;8jƠ*nˇox' Dj#XKT3{}M2i`92mF&Ixݲ^\\6@bLmrf{#v9$utO21]iCƜHƒqOvʓ̓gVdiL *$-*QX iM%0OY&;&\*9Z9DF!$KZqP F>iF-A}fPv`׊`OE0<~` 0<`2^yr\ {p$KOG@S+:ppaA)%C=@FrQ!S :Zly0/̮;GiQ%#Pa& PR*|!HE'`О1 Tw/HHZ?$;-V4XvK+VX!IƎ8*?i`L' Ƞho-fGE8/u^ rK\\fNT|sGe;Ϧw}-ǿ6E n`;#'Ddǵ.娊(p_f:)8 e~py}_΁[WJޓ-iSV7ITe`ʻSQ endstream endobj 187 0 obj <> stream JFIF``:ExifMM*QQQC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?\ܑty=uIʲ\qs@Pk^N1hBisI\f9rrF:Wҥ%'*s2OzχA{:' š $q[hm\LJSޮxT/59>>E4n`+/*V4Eh-m$cq0]*^aOz]Rr?+\~9׼Ӣq ZqZzAk\ܑty=uIʲ\qs@Pk^N1hBisI\f9rrF:Wҥ%'*s2OzχA{:' š $q[hm\LJSޮxT/59>>E4n`+/*V4Eh-m$cq0]*^aOz]Rr?+\~9׼Ӣq ZqZzA-.viAyi9`kG@ɔ@u [ҡ%ݺOE}+#\)q@׈slN IZ:L[Qޕ.$Tz}/\YN3@˝;fp@P^ZNFX$ezb|IwnA"?~_JH2qP5\E0ӂzr2֎'(=_@CKuB yW%FS9<2n*/ن;t <@4X*]۪H_ҹ/5̲gx;qQxv4ޠ5IW-PPEGxe8k ۊöaeO&P z(oJėv*=>Kčs,s^ xeT^ 8 w/-'#, hy2h=nD zT>$T Q/r^$ke8(ƹkm #+R {ꓕe^'ր=gȠֽebЅSsZ孴6t& K)WKčs,s^ xeT^ 8 w/-'#, hy2h=nD zT>$T Q/r^$ke8(.viAyi9`kG@ɔ@u [ҡ%ݺOE}+#\)q@׈slN IZ:L[Qޕ.$Tz}/\YN3@˝;fp@P^ZNFX$ezb|IwnA"?~_JH2qPrrF:Wҥ%'*s2OzχA{:' š $q[hm\LJSޮxT/59>>E4n`+/*V4Eh-m$cq0]*^aOz]Rr?+\~9׼Ӣq ZqZzAk\ܑty=uIʲ\qs@Pk^N1hBisI\f9rrF:Wҥ%'*s2OzχA{:' š $q[hm\LJSޮxT/59>>E4n`+/*V4Eh-m$cq0]*^aOz]Rr?+\~9׼Ӣq ZqZzAk\ܑty=uIʲ\qs@Pk^N1hBisI\f< ۊöaeO&P z(oJėv*=>Kčs,s^ xeT^ 8 w/-'#, hy2h=nD zT>$T Q/r^$ke8(.viAyi9`kG@ɔ@u [ҡ%ݺOE}+#\)q@׈slN IZ:L[Qޕ.$Tz}/\YN3@˝;fp@P^ZNFX$ezb|IwnA"?~_JH2qP5\E0ӂzr2֎'(=_@CKuB yW%FS9<2n*/ن;t <@4X*]۪H_ҹ/5̲gx;qQxv4ޠ5IW-PPEGxe8 孴6t& K)WKčs,s^ xeT^ 8 w/-'#, hy2h=nD zT>$T Q/r^$ke8(.viAyi9`kG@ɔ@u [ҡ%ݺOE}+#\)q@5[hm\LJSޮxT/59>>E4n`+/*V4Eh-m$cq0]*^aOz]Rr?+\~9׼Ӣq ZqZzAk\ܑty=uIʲ\qs@Pk^N1hBisI\f9rrF:Wҥ%'*s2OzχA{:' š $q[hm\LJSޮxT/59>>E4n`+/*V4Eh-m$cq0]*^aOz]Rr?+\~9׼Ӣq ZqZzAk\ܑty=uIʲ\qs@Pk^N1hBisI\f9rrF:Wҥ%'*s2OzχA{:' š $q<2n*/ن;t <@4X*]۪H_ҹ/5̲gx;qQxv4ޠ5IW-PPEGxe8k ۊöaeO&P z(oJėv*=>Kčs,s^ xeT^ 8 w/-'#, hy2h=nD zT>$T Q/r^$ke8(.viAyi9`kG@ɔ@u [ҡ%ݺOE}+#\)q@׈slN IZ:L[Qޕ.$Tz}/\YN3@˝;fp@P^ZNFX$ezb|IwnA"?~_JH2qP5\E0ӂzr2֎'(=_@CKuB yW%FS,kے1Ҹ./0\.9V^kѕ.r}h|?? ki8V_-U8=ni 5ZCnHJ`TžsĺYyFWYr(5yDsY~!T.3@ֹkm #+R {ꓕe^'ր=gȠֽebЅSsZ孴6t& K)W$T Q/r^$ke8(.viAyi9`kG@ɔ@u [ҡ%ݺOE}+#\)q@׈slN IZ:L[Qޕ.$Tz}/\YN3@˝;fp@P^ZNFX$ezb|IwnA"?~_JH2qP5\E0ӂzr2֎'(=_@CKuB yW%FS9<2n*/ن;t <@4X*]۪H_ҹ/5̲gx;qQxv4ޠ5IW-PPEGxe8k ۊöaeO&P z(oJėv*=>Kčs,X-m$cq0]*^aOz]Rr?+\~9׼Ӣq ZqZzAk\ܑty=uIʲ\qs@Pk^N1hBisI\f9rrF:Wҥ%'*s2OzχA{:' š $q[hm\LJSޮxT/59>>E4n`+/*V4Eh-m$cq0]*^aOz]Rr?+\~9׼Ӣq ZqZzAk\ܑty=uIʲ\qs@Pk^N1hBisI\f9rrF:Wҥ%'*s2OzχA{:' š $q[hm\LJSޮxT/59>>E4n`+/*V4Eh|@˝;fp@P^ZNFX$ezb|IwnA"?~_JH2qP5\E0ӂzr2֎'(=_@CKuB yW%FS9<2n*/ن;t <@4X*]۪H_ҹ/5̲gx;qQxv4ޠ5IW-PPEGxe8k ۊöaeO&P z(oJėv*=>Kčs,s^ xeT^ 8 w/-'#, hy2h=nD zT>$T Q/r^$ke8(.viAyi9`kG@ɔ@u [ҡ%ݺOE}+#\)q@׈slN IZ:L[Qޕ.$Tz}/\YN3ZCnHJ`TžsĺYyFWYr(5yDsY~!T.3@ֹkm #+R {ꓕe^'ր=gȠֽebЅSsZ孴6t& K)WKčs,s^ xeT^ 8 w/-'#, hy2h=nD zT>$T Q/r^$ke8(.viAyi9`kG@ɔ@u [ҡ%ݺOE}+#\)q@׈slN IZ:L[Qޕ.$Tz}/\YN3@˝;fp@P^ZNFX$ezb|IwnA"?~_JH2qP5\E0ӂzr2֎'(=_@CKuB yW%FS9<2n*/ن;t <@4X*]۪H_ҹ/5̲g endstream endobj 188 0 obj <> stream JFIF``:ExifMM*QQQC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?ᆨެEhztf<`SFL ZެEhztf<`SFL ZެEhztf<`SFL ZެEhztf<`SFL ZެEhztf<`SFL ZެEhztf<`SFL ZެEhztf<`SFL ZެEhztf<`SFL Z endstream endobj 189 0 obj <> stream JFIF``:ExifMM*QQQC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?txݮ}ke}+Ϛk>G(@ 雕+9jr`qz}f>pkAI^XI^uHG5N9P8"kZ=>dJZϸv5 zfl /,$CB:wGi#yaX@v[ϭzlYyB-g;xERhu3rpG!סR;ST,;GֽOOY,Ҽtz~")4ޙ[K #kЎHXG*PVs^,c^|ЋYƺ=?^D]oLܭ\%儑x5GT$sT,# (+vSK1>hEc] M.nVH<#Gtv9wʅh\ש%W4"}ñOׄQ&[7+`W ya$r z#;I;B ԥV$bԱ֓5O9|>]g]7m+MS["rhkRXRN3SZLS<5vrUun'v0%$tRI6XMomɠ JUbJ+]K8Mi3]L,ڀ9 UqܑҹK$ڹ`:U5!&6)U+Xu,d55u0Sk_nj,5WYzc r[rGJ/jTHܚԥV$bԱ֓5O9|>]g]7m+MS["rhkRXRN3SZLS<5vrUun'v0%$tRI6XMomɠ JUbJ+]K8Mi3]L,ڀ9 UqܑҹK$ڹ`:U5!&6)U+Xu,d55u0Sk_nj,5WYzc r[rGJ/jTHܚGֽOOY,Ҽtz~")4ޙ[K #kЎHXG*PVs^,c^|ЋYƺ=?^D]oLܭ\%儑x5GT$sT,# (+vSK1>hEc] M.nVH<#Gtv9wʅh\ש%W4"}ñOׄQ&[7+`W ya$r z#;I;B xݮ}ke}+Ϛk>G(@ 雕+9jr`qz}f>pkAI^XI^uHG5N9P8"kZ=>dJZϸv5 zfl /,$CB:wGi#yaX@v[ϭzlYyB-g;xERhu3rpG!סR;ST, -JUbJ+]K8Mi3]L,ڀ9 UqܑҹK$ڹ`:U5!&6)U+Xu,d55u0Sk_nj,5WYzc r[rGJ/jTHܚԥV$bԱ֓5O9|>]g]7m+MS["rhkRXRN3SZLS<5vrUun'v0%$tRI6XMomɠ JUbJ+]K8Mi3]L,ڀ9 UqܑҹK$ڹ`:U5!&6)U+Xu,d55u0Sk_nj,5WYzc r[rGJ/jTHܚԥV$bԱ֓5O9|>]g]7m+MS["rhkRXRN3SZLS<5vrUun'v0%$tRI6XMomɠ xݮ}ke}+Ϛk>G(@ 雕+9jr`qz}f>pkAI^XI^uHG5N9P8"kZ=>dJZϸv5 zfl /,$CB:wGi#yaX@v[ϭzlYyB-g;xERhu3rpG!סR;ST,;GֽOOY,Ҽtz~")4ޙ[K #kЎHXG*PVs^,c^|ЋYƺ=?^D]oLܭ\%儑x5GT$sT,# (+vSK1>hEc] M.nVH<#Gtv9wʅh\ש%W4"}ñOׄQ&[7+`W ya$r z#;I;B ԥV$bԱ֓5O9|>]g]7m+MS["rhkRXRN3SZLS<5vrUun'v0%$tRI6XMomɠ JUbJ+]K8Mi3]L,ڀ9 UqܑҹK$ڹ`:U5!&6)U+Xu,d55u0Sk_nj,5WYzc r[rGJ/jTHܚԥV$bԱ֓5O9|>]g]7m+MS["rhkRXRN3SZLS<5vrUun'v0%$tRI6XMomɠ JUbJ+]K8Mi3]L,ڀ9 UqܑҹK$ڹ`:U5!&6)U+Xu,d55u0Sk_nj,5WYzc r[rGJ/jTHܚGֽOOY,Ҽtz~")4ޙ[K #kЎHXG*PVs^,c^|ЋYƺ=?^D]oLܭ\%儑x5GT$sT,# (+vSK1>hEc] M.nVH<#Gtv9wʅh\ש%W4"}ñOׄQ&[7+`W ya$r z#;I;B xݮ}ke}+Ϛk>G(@ 雕+9jr`qz}f>pkAI^XI^uHG5N9P8"kZ=>dJZϸv5 zfl /,$CB:wGi#yaX@v[ϭzlYyB-g;xERhu3rpG!סR;ST, -JUbJ+]K8Mi3]L,ڀ9 UqܑҹK$ڹ`:U5!&6)U+Xu,d55u0Sk_nj,5WYzc r[rGJ/jTHܚԥV$bԱ֓5O9|>]g]7m+MS["rhkRXRN3SZLS<5vrUun'v0%$tRI6XMomɠ JUbJ+]K8Mi3]L,ڀ9 UqܑҹK$ڹ`:U5!&6)U+Xu,d55u0Sk_nj,5WYzc r[rGJ/jTHܚԥV$bԱ֓5O9|>]g]7m+MS["rhkRXRN3SZLS<5vrUun'v0%$tRI6XMomɠ xݮ}ke}+Ϛk>G(@ 雕+9jr`qz}f>pkAI^XI^uHG5N9P8"kZ=>dJZϸv5 zfl /,$CB:wGi#yaX@v[ϭzlYyB-g;xERhu3rpG!סR;ST,;GֽOOY,Ҽtz~")4ޙ[K #kЎHXG*PVs^,c^|ЋYƺ=?^D]oLܭ\%儑x5GT$sT,# (+vSK1>hEc] M.nVH<#Gtv9wʅh\ש%W4"}ñOׄQ&[7+`W ya$r z#;I;B ԥV$bԱ֓5O9|>]g]7m+MS["rhkRXRN3SZLS<5vrUun'v0%$tRI6XMomɠ JUbJ+]K8Mi3]L,ڀ9 UqܑҹK$ڹ`:U5!&6)U+Xu,d55u0Sk_nj,5WYzc r[rGJ/jTHܚԥV$bԱ֓5O9|>]g]7m+MS["rhkRXRN3SZLS<5vrUun'v0%$tRI6XMomɠ JUbJ+]K8Mi3]L,ڀ9 UqܑҹK$ڹ`:U5!&6)U+Xu,d55u0Sk_nj,5WYzc r[rGJ/jTHܚGֽOOY,Ҽtz~")4ޙ[K #kЎHXG*PVs^,c^|ЋYƺ=?^D]oLܭ\%儑x5GT$sT,# (+vSK1>hEc] M.nVH<#Gtv9wʅh\ש%W4"}ñOׄQ&[7+`W ya$r z#;I;B xݮ}ke}+Ϛk>G(@ 雕+9jr`qz}f>pkAI^XI^uHG5N9P8"kZ=>dJZϸv5 zfl /,$CB:wGi#yaX@v[ϭzlYyB-g;xERhu3rpG!סR;ST, -JUbJ+]K8Mi3]L,ڀ9 UqܑҹK$ڹ`:U5!&6)U+Xu,d55u0Sk_nj,5WYzc r[rGJ/jTHܚԥV$bԱ֓5O9|>]g]7m+MS["rhkRXRN3SZLS<5vrUun'v0%$tRI6XMomɠ JUbJ+]K8Mi3]L,ڀ9 UqܑҹK$ڹ`:U5!&6)U+Xu,d55u0Sk_nj,5WYzc r[rGJ/jTHܚԥV$bԱ֓5O9|>]g]7m+MS["rhkRXRN3SZLS<5vrUun'v0%$tRI6XMomɠ xݮ}ke}+Ϛk>G(@ 雕+9jr`qz}f>pkAI^XI^uHG5N9P8"kZ=>dJZϸv5 zfl /,$CB:wGi#yaX@v[ϭzlYyB-g;xERhu3rpG!סR;ST,;GֽOOY,Ҽtz~")4ޙ[K #kЎHXG*PVs^,c^|ЋYƺ=?^D]oLܭ\%儑x5GT$sT,# (+vSK1>hEc] M.nVH<#Gtv9wʅh\ש%W4"}ñOׄQ&[7+`W ya$r z#;I;B ԥV$bԱ֓5O9|>]g]7m+MS["rhkRXRN3SZLS<5vrUun'v0%$tRI6XMomɠ JUbJ+]K8Mi3]L,ڀ9 UqܑҹK$ڹ`:U5!&6)U+Xu,d55u0Sk_nj,5WYzc r[rGJ/jTHܚԥV$bԱ֓5O9|>]g]7m+MS["rhkRXRN3SZLS<5vrUun'v0%$tRI6XMomɠ JUbJ+]K8Mi3]L,ڀ9 UqܑҹK$ڹ`:U5!&6)U+Xu,d55u0Sk_nj,5WYzc r[rGJ/jTHܚGֽOOY,Ҽtz~")4ޙ[K #kЎHXG*PVs^,c^|ЋYƺ=?^D]oLܭ\%儑x5GT$sT,# (+vSK1>hEc] M.nVH<#Gtv9wʅh\ש%W4"}ñOׄQ&[7+`W ya$r z#;I;B xݮ}ke}+Ϛk>G(@ 雕+9jr`qz}f>pkAI^XI^uHG5N9P8"kZ=>dJZϸv5 zfl /,$CB:wGi#yaX@v[ϭzlYyB-g;xERhu3rpG!סR;ST, -JUbJ+]K8Mi3]L,ڀ9 UqܑҹK$ڹ`:U5!&6)U+Xu,d55u0Sk_nj,5WYzc r[rGJ/jTHܚԥV$bԱ֓5O9|>]g]7m+MS["rhkRXRN3SZLS<5vrUun'v0%$tRI6XMomɠ JUbJ+]K8Mi3]L,ڀ9 UqܑҹK$ڹ`:U5!&6)U+Xu,d55u0Sk_nj,5WYzc r[rGJ/jTHܚԥV$bԱ֓5O9|>]g]7m+MS["rhkRXRN3SZLS<5vrUun'v0%$tRI6XMomɠ endstream endobj 190 0 obj <> stream xYKoF #Tk'qS$@)֢e!z8$3K+q)9lKof,~cϟxe/^.``Qƅb4\Vh3Vppl8`_0,U K?Rj88{#v8,Ϥf)' CT%E:ʓzIfW ! mde7NYJG6JT$w)Pl`a bYޤ#|O^ӒvK4oD{uVq:^-<-j V<7<*kdcP&eSwR!ܡ ?"<Kzbܷ38ka1]ΓZQd*p_l{}7 ؟%?W3zpTN$+ X]z_HUdB 4ɦs}˳1+h -'β4w,m:\4cF#\JCf=H~ZC\Bdi~ۤv!K ӋO| ժZ~{UoC傊EėM8=NTXG$47.Va|mFRQj^d6'DF+qY6sqz45uT6?ktpdCT(wl;fF۔BxRAojM]kNCLR*X%g}TB٬[JwmIs-۪L/xX ]= ޖ\p>U9jC!„ z2pyW勁a{N$ `܆]jȜJ%(bXQtz-oRu&y^C/;u*C"NexHw2VY;K(n\dTXGl5Z@ctUֆS7 ]bp$%ŧ/)fV a1/J"/!w?,2ؤmmR\AUMҌ0lh$7bZU~͂az"J ]!%8n6"oWUU'x,Nk+BW|b_AWN4H TQk)x){9^~YA$3t 7 ]$<&FiܰlGMu/8"x?F񢫃h 6|?wv )Pg8X[GY>=BЄѯ0+G6/Qhw<qcwco {/k"=tմ FCKD%I hU&޺rx`x&mzS{)pi?  ]te0Br?Wď=n|0{\q(xVsegOS)!+c̱fv6]1r@eTQ~kpEf:yؽ, Ĉ}h'NF;Ux MAD^|Anl~~GB&cBiqF8ÇGxNh'}r%l!yQ( ^~T~*s?0< qOn!-VN= +O-kסH@㥔CgN`>a$𳤖3\k!w܀jR WK{.6fNW6z&,O᷵ɶ endstream endobj 191 0 obj <> stream x*.о#/qQ5g~~ӿ9֐mPboy?+ |~Y_u*X@:DoLj`8H#S8x:*[{Y~s7/K5۫z9i! 815,zt7wAGߧ=|}S9.ab؂<34/Wj:A=Je밍Tj3~̤6:[Up8RPGn\w / C!]#t6+xωeF08Hxè=KƑ烪2 @ZƪWJBPm?I#-giK e[˵k_vss[YboՕ}7=H/7 Uуg>r ?HtcJ@&?HO~*P5V*rmy1Dh?w<;ԛYv%kUMUS,z 8][-/JK>|L=-NVӻh{yHpȋ:zVWJxtⰵ8sH ?w]5uKwKveP/ޕNoLGW ޵ڒ`O-v>Cs0KF2skg~;|97N<87W&ۇ"ɉjg'4~SR`ǗqY5)I93z;11\s] pzfk{Ƽxnٹc..yV[ 5~%N[4yL|o4; VFf#]6Xuz֥`yclyiUSxv`Գ5y$N9'qDS%8.?˿.=]l`+ekީW^W?plxv~Fh\s7.> |5O+/9y%R޴= Qo\1<ۊ? ګzz~9S)i/zWuL׀]yW{iTƣ0OLbm`[ڷu#S#=YÖȚ",hvsxyl_'ۅ:~oleOqx߲MA Zw67~׷?ޛ]qȕM5ZI/(l+xvj¿p`H:ur3^Jl+,g՞Bxv05~ڻWu<-j?{`M`$΍P(muMkKHYXv\_3Ku,j\f:6zMw[$6@-mndD֢j:WHx}HHs`d\5%m5]<;N`F׷>y|xاS H#C_-;kq(J\a[%7\(r;̻ƏluSg/+!WnoA̦jrȏ~;y`_y̳(7Tpjz3#W˷7oޥޕ U,{qrm? h p(> {'sz]zh [h덿p.ܵsi糵I7HYNO*- )f,y׺`]kE&k׵}8agrhI[h(@OfL#t=H| ~Yq]m#Ct> S)Q[.6Cwx9 od^]|ÈHWo ٓwȂ=ǐXssÇ}F4^Vpt!qZoC77D7yu$m|xsrmr5Ѥ6*ox5csN|g|Wƻ9Vr# D.hW8{y`S?S>5w)$l?BȚ^̫߮e#"T?Fޣu{~b%eGoam } &T>mfL>J5 w퐳]+U5ɻgG`׽~T0= ˷97K2ܫ5zp"òZw]pMݸHF^oܕ`J\ F Tqjጟؤ4hra}y;pދԇ^-hpU:~){FϞ2MMG5cC]['M]] 1{3J .F㻹rgcA|d]އx6%9i[k}Ly4*_ 77~*R&Yx`3sN#~Y2TX\Lm|v?pK|tQ`רmO &l^52F5p\|3J5|SJϺ/XVK.^M 3r-*`5Z#Ť0>o?jNUOxNgv-xp M[-.~,z?7HTe7AKhۓ69i|y7pE+UosQ >S#WYop(d|ZOZȩ %_/N|GƓqg$ w?z{2>?y8wg$L.k~|u?G@P]WD)dy{1;c`OO4ڟ /I|4'Mf@NWVkI.3Β0f{o߻,G fg^qj`O b1TO2%qOcX0Ì8 %=P?>N8ZՋ`эu+L5\ݭTm 76|&5V}@\Vߍ,:X'=s>B퉤3y m,IJ39 q6/(lnvy[xLjd\ZPHnjgZ .-8|K҉W(7y@^) %"VuT PUJMh(kgxOJ8[u3HX]((OIkĿw`8Nj!wmAt@Z9ڴpi築GQA i #_Bgx _~7/V U4Tior~ endstream endobj 192 0 obj <> stream xak0`v`AuexI{sIܲ0u]w>'ͧTv]KGru1vgfAd\Б (?{p^"<3 w 1E"IYSh@/R`.v#F)7`L3LLV/'Y @wf:/0 @>xG"P_  _a(@< ij&/Һ}PUk y!C>2@0xs)gR (J{-+xjy(H#L8EX49HƂԤH/O09R5Sp< &,+21ω  L@vFT9e*@+U@-L $Q/zH `$@"G`o)w8@Z`c@0 pZ b#ēЅH`1[7ǹC@<+$ ˼cI[:C/t'|9 e:=ݱxqU +4${ endstream endobj 193 0 obj <> stream xo0#ǤoNUH{{`eUlBb|btpwq{ //ag}}P) N 5lfy6?3dbߜUQ Phgti)V;i)xpgzx)ʾ(4*c]QrGpΌ,+|1æLf^jR͈X!y+690i8;}z(?uۄ\<26J%x!б"cRuއpH-zZ%I* Nmz ?Pu_?$TR2gU_=\ o`i.e:o'W1AR ɓ h)U1kfe3:MM9M.R۪Av%\b;>>G&d12>ߚe>It x4Z}t*yfARFmd4eDL:܄h6(M虵M49ߪAuDQVl'-GFk ۑC Y/x#`㺀Htf. :8Z׌ǀ$| 6} 1&eD׊-A J]{5^ hRQ 3D|Ez<$j( M> stream xے㨲y /2É=6B)Dp???_?o輈Mu6 ) ^jli2[=.om#(WsWo߶v=_΁@ iVw`rH}T+b A̵O"2CzϪ믚65 ky 1pZx^+Nא<9hg;PS6񏟢xY#]"Ŗ#ѻx.Z+Pc6b O23'<ͣJmɵ[_#r&!_Q,)>tb}]t|mBNDa; ?np׏M3.ݚ\UgWdќ5n̄ئ 5"v!c/^e5˕ÍFlo7 ﻈA~QGryڃ&i3UH\^ódjSb'=f+ʫ>}79cV߯/w&Kiym76zSs?#ؑsv"8"6k׋#Tjiӿ8gu¤ Vm7pRi%7dΩaiNl/əahMk7;M~]֪hI/&GyѮ:@=X}X٢i]O3ؒ9TZMǤm~ @~ӳ!Cgh;m^}F=uAQ;n4+tr,?O/n8lygΡ HQqPO:ʶނ{VLP27E7|$OƸـv.=,/Z+l du  "ն{6j"*Ӗ$\l l-^چL[DX~Rɰo%B6p%nSA6b78y5zY~n!z* ,`N3!^զK6 *)(<_#̵U/w׾$ʈՁ'PC\F2\zsX=IajS7>fb4p8?qW `S= y ft>j6KU8o˙N[!7jGu5Bs.ْ`}Tώk{Q4v->P}-v<]%lqݎ7kA&z>J&iw|-WlS)Im=_M>K4gGO#` mS!nf2|>efU0Wu)n@7gz$N::*=s̄!U-,zC]U\*Aǝy^33 n@AN2 ם[M)ע΃ՠM:=8U%^3!7Bt/W><_0%ߚVk]U<!_,o|\UsdMmɞ/4'W@1錈 L3(זP:❇;{'i,9tIyMFcET2V<}g _bϵ9>]#/0AN^Qxqhިz2^Ԛ]Ӕ!Ieג|͠d.&б|*nPN*L?pljj)KgDW^.a HJ;'W y snA'jʐs\:Y^kjk JU EDx5OkIS]8Xvd|w! @~c5pk2Ǹ-K3ׁ¯4l τiN@NiGUvH{Azkp ^[J3z#^\$Ƶ-: =}=~. pK/?뿣]wfR ͯtr[.UI^*it2ͧ5\qm$ʐ鈌J+/߷iǛ\L`萡W%G|дvJXei+]]l;m/f•if좚%C6{Z뜷./s(і()xN =ϜtX^0[^?b7a:ٺa5=a7)+gIP=!;d֍.Z^2FR}q.J׵eԓ'o6*\aU8j#Ia7Bz`^ƵPcca-[>=O~o=d nvT`!@=&O-pF*vUm?pA]&H$סMyL,qǸb ԥ]u v._U9m._~Gaga\1(n_:{܈UJmk8PvO@?§`*;KX2B`ĉzEϡ9jzֆE09SY2? eԲT,N7Y͗e ??heȺnl}gfa Kf!ʩ#+vjQ4( \[j[2KF"~CcہR4 IR=5TFR,֪#Hdܒ[-^^AFg|ʰM8/66@e;li0&W:v}ka_zZ+?*R1P::,917/O=F}6ai^Mx.ݴUOm=|g!ŵm[TП|5 `O34dWU|aTO_rm'ꩅ ?Cca-g8\k&4( '$Dy2{-L'w~^m?% 3]gKlTO3Ѷ<\[bm/(aޅGLSZF { sV+:ri8XlXU5%FKG9d0bԷ[$pk|jՉo52%#XSy{RzykE^`Gѐ WoQ 0ڪL~ѳjԊF 8@sx'-$0ڧ J-i¼2N=VŇ[T|5 V5I\}א_}RP 13œ2w%6ȼᱰ:;亗l,j;VF*j: E> k1n 6 iƙg]rο2' _j=?]A;I7,7w;(Enbk`^kk#S鞇=ﻠ,2pDž%:U4o)y!zV03$uҟZAYk_ -gΏ{ېnQ6+wR}+Yl? ï=]7jP¹5wH.0vyri]ݷ Uª;ylקaRSտP\0G}?Q=n!-n.{{ 8Ry][lܒjlc >SNFȪii0tGiW]ylDJUCU:[l}Ύ滭z44a6N+Qu3wC=]fnnHP<e j6pQ;*f6@f&޾V6"q7 ʷԟ8ǺC 6$F^Uv[y!:j-"|6Qߠ3@oN2PVwb vYs,ђDkQJ=<bvc['V{/%6wN*Q~sȩaAaKhK!i<>NI\Lppjy;mNQs^S8OQ{AorЩ\gxy4nȚ/LsؖM m!n %T$RѮd: 'j6!-_}z: GaT\tѫ=8["@rr;hh32=VMmR|@4JnW',u>~}zzZ6L&hFj:fܶq k[& ˆy_jU}:O ,KkkzCO_ @mz>4)m vݩ b'5c.JJbGm#撁^ch#Wucˤ:0X::.o)UϪwГ7( UO9f U殚-6'j.Ү: @'\ڈ_GT6S8zkhոFʧA8&=ۗj˪{o[x WZA#Eϧ9rsz5v\|2kGE?}ƾ!R:{/o~:8 ކU> stream xѲ*>J%6B`0';%H?]w#l*~<(J$^6|j|lD!+ &R ^  \H}=>^>\ >HZ @{Qa\/+oZ98]17nqY5q;?j[gøtKqp$R8F%r#{w/#E|kou-Ł\+&ˎFNmYV sɼ6};{T( oquY ȴah܄+]=+\na?ÈǶhW*Vnnd\fGgg`[uթM:5Ata!q 0k%+o (hWHj r%z5xZt!>^kb^1@I.K߹N#ˋ ]Dg.QL#+-֟7z;wV>e^1uUQ'7M114ܳVU鸤:zaS]UITFV;2"4dW98KTAپ1c_s)k+;|+ݻ FE3+y(Su`pAw'v[v`͹%,-нQ&ʼlGk6&.cg"6Pªf5wi[.oap]t,tkUwJ{|x%T,v%Ń4@WNX/Υ"]A0׵Q*e6V?3b5nj]wI}KD>F<K '9`0׺|TF Uh:u,` 享 9x!v^ٛ{^/{oʃGD/[ǎD=>e_GJ5e]0FTMQlҜ_kqEj>P"=|}Og2.Dlh]=ړ|gt=Rxm6J~x*^e(O"oE>Fϼ0H31`O^+#Y"p,#oWȮFFgG&CWw,PDNQr .[[ xw|>DO RO'@D֦_6l>}DU %^0iomv9xaPk7,X3jvm۶ X^}}ޭ>Kz%ϵfhl*K ̨7x\U6E97ܮs{ 9FnX k |y4Y.wFc"5گX~,Dm`CSS*lOn bJՓ^/u0uэڏ=%5r[$V-VG\Ƿvվަx#'Miy|.'q.g}P|F[x)lkPH|V8~ =Ɵ%LFYk0[/[t:އy8je sr#(H⍬oQo5pnr*t'ybĻg^;^1~ȹfk6Zp]kG?g3(}:agA?}c;7F^L\WR5շtu*@|nc0s gˉ}|)g_HG>>kyD/<f7^+Xu줾Fl2gƽMŌ5ȳ_S#ykWX & s_COT wIrk?܃MY"ݚ33X<ؕDܹK6#,5OM?wwͤ:/ǟrfY3 !7m5vM[5θQn~AM pU{#~ԴkYGoSkt`Tj\jX]_reT>+?7R/¾ň\6 3'3rC&md\FU,LyA!'kH]#|yRjlՑ]f1ڟz7l5Ugq.SBpH7ÎיKj"m|NhVu8i'j[թiq{,Ƶ#}rjg#SMn.fv`UK%lt7An5 WQ ;xFpH*z#a916AF"Akd y X{y$vp\#KbO_\ԭuz]~[(%nV5񨫝#& |"l*HiU]3j$;ʍfP|FVHO4.ƶf\`I:n7l['M[Ԟ-Oh"/0H<~jw؊^Fk+⃭yjN5 FyY6}7[KI+wm6,zzO7Lar垥5SaMyq_M?{fwU%6iigZ+_Ko_\=}쳠Y$fX+u@ KUn# 64 ^i$TMVb:oogScRy6bް+DwpӛeV gLoW>p~}qݧf U7wPæ]& $NL 0<-Ngvkkz(_*-_0];_mo]3кr6. d#>RFGb`>[Nej-O0ӵ?:ߋ8ieArn0C"7!OZ.T7A! }|mFԾtRˇ?]k.O`•ӓi_ZI5`2]^xɻ(^r<[N̨;tZϲeEB+gtF7Dî)p?k;{jd@m1n^%WH'GKtV,1{/kGrv̤_ n#ӈiS ^D1 axIPd57'mbxmJTC2kopOf䔤H=/_}o~Ĵ\_"9h{Kmt˺na4yܤZI{ _Q|{\O)ս3{h|}YO_1[8mؾ |ݦyk!1 쯶؛uRש 3\V*ȭ>[Tm)=p_Yf#H;?2lhp#̈\>L*DL=h;L{g>ɲf$[qf s-/Q^vaJo|4EĻ $6>f[fkJӑv,pp7B:|M}ߪ=&a'F޿׈<w5ɕifڲ{n5 S紪N˞XAג~ W{ XVygǩ팊uh..C7u7߉ pܤ:r-Sn"Rol?C%^Olr[<P6]~F,e 6Won_a=`^F*\zN3 ld_}6,IrI<#lqƫ#si"uґ<,.1|vL%f:ލྠ[g{}dM87Kj{m8^5vEdvǝm-猉*=۳xXW٭M^>4/;eFemyK3.ys~)D ~.Q|sW~paFF(1oϤ5Щ붍6sV9L\> =""4m8SL*[j仜 :*ip<zwO˻f~`UsLA&mh|tq{{bMnm7I͛k#?ܑ[5>.wf.Ɖ5w6v^uՙ_YfLU;p?{^+ɽa"[Oy,v5ؒY}Ah8\ެ 1@EogHwU@o_}*z5.[ D{sR e~;|)95 PkmUHϵ՗nvhm̟7j7'}]heJu`# o_m?`]~iK`[xI\&CF47Aˮ I>k_Dzn zA;-_\O +Uimt ;ĦLvๅou?VHxYU7I_!MJ~$݂[?WKB8 temZuf~JnTa0 /kϷL@ʝ]6*@v7ֺĹtvjH?Λ endstream endobj 196 0 obj <> stream xr(мKSuT֯=Xjh9??߿@+;8C#95u=b 7(<;Y!v[48T Z.^4rƾFZ_n`W:^)w2b*g EYyeN= [5.4Tgxg+7hdd3:x@\LJ]4ﳡ'Riu[a4-o |A ݜO!HL|-z^m͗Uύ!pJ/ 6?R|Ub .6h 5$Բ't/ E_'N_1=@ŻaG&l~a8v6G;8N* Ru5`8w g{ o~_YZ3psT%F!#t-xk$w}clOl JC#D=ĨqRWur_b:yl۲W+!lổnW9[p fΉvxCWͯ`xzea!Uvr;`PdKXzytx+1Bśj+{Bz r7SO}ipAV;^&Ncu{>:Xp>U8v'.]MkyQzΪDr>Exvź߅r8˹vy:̲S֙V/sk=}lk,q7xzV]A$9}ȧ'~=ǗxEqw'.Y}ng1܂jme͙F:'V"2p{;Gr<. UR㝦22/)fųPR"ʰ_q1i;wt;@ɶgM/UŭEʔs-ͩ R~S̰[㫸sǟRz챤j ET}opn _Av._O'5~uLD0fivOPOD .B"shd5`viu|C"a58ۑ43Ö^!hP1 \6_LDS&z9TW }\uahǡ-W0wtq\d"e%Z0\m EsWQX<:8Lʎ2=v BUm><ߜ0\B[d)*zUgӧJrpvOy -5q*q%|ca T{ԉ^˺^FSƞjֳ*KNVknEbO!(`{..1Fr\Z?Ã\KlVT#4qo7w 4}tH~GR}ƃ`WGo=Csj0aMD%*w%Ik~+0xzpWXUs6Vӷ=79 vX [ۿm.yujK"V3a੤8~Lu :~2 \bB4`]PKn,1Ǚ}d{nNrj/rsU(jù`f\\P-O#3(\4K|Ksanb m }3~ y11<~GM] `S ڪăvF::ʂ?0w0yǯ;*W1ûnx/~zo`Ƴ=d;&ȞqFVq<$5U mOn2kmbj8%(]Ew`B|g7'v*j={//Ǘ3wℹ*;JKB uHԿ.W=eۏ{9eK"PfHTg_wa.Rȉg{@Y(q6O4+s" FiEME/իUF0RY~xQv}Ҷ[=|\ j;IEk?Qw<ߠsx6@Fέl?@5b$!gl5wP|ab[/Y,4rW9>"wwRm2ϤGEV/:/|`ЩG껻~ƗϦ⫝YuӲp?)SM|x];uoa?5}C()#Io< *G}eŔSsAYq w"^b}-˟@ \KgW~6S9ng%w[_9R/eW97S JL.qBKےsHȳqӝ6r:-ΝlhNRŬȦ%ށOkm =W7OOl`u-~d&.1/}]oh_%;s5w SiWmǛ_$ÑjElh+6٦n0EWeFS' ?Rͻ6iSpeL/1~ ó1(kH/9=?6:p`|dT &r*noqc\HX(k`v `gSs斬Ǐ1 g n# azľY#G.J5#mFޔ:%*ju­پb7-/_{bE\ԗޥi)c`$V=̫Bҟ潼Xgo!^>* ௶yr)X˴$w[2x\7{qV/2R}\7|b`~>cN.]}wR;NqzO΍/T|[hH38 wH==Szixߋ,[ RR$q.e-MG3uAg{P;axwCHezLӃO%Wk{Ǐ{ /j#񂫉#xHeݻB'%㟜Z됧9)=`qsࢎgɌ.oH0FK<=Q֥D۹4qCJX+Zl_R.^6O]}k^R*SFT8j&49J;99>f,ۆp?=sxJ9uD;vMjQ }&HFwfxVcA*9szM8R@`ܩK6om$#w>R}>EI/gLO*?~G*zjnonn?UVZ{K0~?K{Ja)?Szʥ]86OJ&LjKx^Zs<>t?֜Ώ kMLWWb#iCU8>r!r8%krv%\8zk< nצǑ󙠵Ỵ}zBՕ]E'?\XPQ#@7sjdw6:J]VWN}UEYkN$1W ~GZ>rU4ey6 {s{uJfF2H P*+6?Ry+=x/؃]sϑ"%` pvv\;< H.|bȻplVԗO#ХT}i ?By!y_~Ff|<eYv:N?O=> /䊬> stream xZmo8 f7Iz)Cr(Dq 8J3CIeq](p43|!evystz=K߾e3f㔍S.3pmX%O ۔ׯ؇c:t9cIz75;;<8(@Lڜg8e>'l_vÃg4n- n 3;I#Հ!qcj%X'r4Jo1<:$ . _e)W f\˞ dnjY/ LX̘TdLXD_$/uΨ9*j|.q'5sAfU\XϜL\c<@.`/b@khn?\q{.g:@WJHA!n²¥J ~K:[pzz)j"wqJ-/7ι7ݢ+'\A'#~JΎÒ’'5vmV q9EE@uf>~|} @|l@B01tܠ B_r dG&!Y|$d}yRMT%>H5ʐʦ9]C205u;Y9JhD|r8; ;" U~Zu ⼫W/vlYsر= z/ JRo_R0vbniT-av @NƊ@d!J63(W4l]0S2Ͷb>uoY¯Mʥ b' +Q(?OL< d %,S"TF]W<\6Wmv֔2W6ҥȲI5rC9f?].<e2ϻFT!Y˵ekes{ eol]"eRJC*sk}ه)D*4(# "i.p d$)R?H =e+qA4 `e~Bq[z`Ȅ?&axzr[n@ac02`= nW@];o%ޠ+vc@X f/7;z7̢ݑSԾCd֛rO* c 'G)[},fZV&(5IyyG8eh v 5- $q7V5DŽ(, ] oQmf5t 3PY0'8e :~ 2 ;kX ]#Wr&QӪ%8nf% %dz7OCw*Fg}퐑EMO$EZ}OK:BdS|+4 7wkq8 `lPV=+x#U@ð ~5;:*B EOS:0n^uzORE័ g>.7 )-nPM;P ! YϺx0) Qd\_맨W!򘻅+\{\В즡V .LϭBk@2Vz-$<-5:X3;%asY~Ŗ2t<2A0鬄];{b?e8 endstream endobj 198 0 obj <> stream xі0NuY= hUs 4~zz,M4R8{=w`K 7XB p VW+5੉xZ7^j00rHO(p= 9ReBBuqaWa`ЙvL`)`_ANnV_jYX\pwoȲ7# ^7:XOq|z|8wxDsێ$,R\(ϵ?_c_X{&ˏt.?L ֟!06|ұ,n)ᱨw]0 ُO O7ʅ 5k`oG/1:&׽$E8RZg$|?EO3y|t9WWk<..7r'/! ~tS8t0:k>H5R!yjtY;+R֞He5 0u@S)`Y=_ vn/Ɏ/j A|2oO:6gn#>{ɗZt֡sZeN[\yzZz׷>ά#_5xoҴ*'FFOGN/*ׄXTWC?I .27Qg?j{oh\I(H4#HghG/ۋK.SF!QV?٠sCQ.Am փxmzFĆg.r0ʽ ][;=HQPJg MI (}68q%yNVQ/eNDmuDZf,Wo;겼; Op{`MA"q=)/-ng9u3^Gjit~H7`i.'/8G#}ް7<%" 6mhmĪ8S4R:(| \Up৷<ڠI7\XC5|$P4;mswZ֩z\>q];on6&nS,njx7b-l<B*9+TO.ʽ)b2H+܈ܾxճI==uWO/N^`ϔ*ᨯεBG` U5l[\r4~I}MvS FCgXjQ;;_,u3kdw؝KW;m\zڑ6٪m E¨gӢkGS0i_Sđ^bro~4wm!\[o4f;O~^hГH=Tphi\aH"v}2#LMCaͶǑms0a|QPuEQ>lvTԿ:rd#5v߶~#0@A9q3 (g\DYsvIw _6̨>a"m-nʂ+)):];]nX:ٜC\p5`w?;'PcHhX%zD\ukhUA⨝qR glHJ #X*VUzG +kJHG VH_6G ? PGjn͕caˆꆽNƿ /6_lYq) x癶FF0? `[\h'2sls;"]*l[y2s.?K?={],̐m9xn>%Ro\rU{Stvr`# VEko#0)#`S2=Bmk,XdvꙐn\V "UmCDZG9Sglͬ Hmw`0!|I%f儩;Y-դ_o}En^KX߄UU|OqV`!Iö.NJXsdʬ|n;񳱻_YgޛP uToןkԻqc.oͶ ;nIL$ {xJ*і)7-F0ߜY4k ]", mq)rM].+Dv~FOAUY_psR;1CnwwڂʜM nSHrfYdc]_sN`Ē3Wa7Ovm='. )`)LJu֠0"W )C i6L^ .,7,n\G0RVsw`+X |Jar0]\,Z +;pG/WG"3| `!\CşAnRYq:fY6k-z\) "ud=[n7?/Zϖ3xis厧*//-;0.F4VyAO>uK$>St~|GwIPd1<sa$-ңmD]ݣk0 S#>-Yݲg<{z`]auuF"Ti™\Hy3[a }*_-duTdZg5!P֜;o'ޤ.'N+йquԶp)p4I|yN eP)ri'>ɾMޡkm.b{[vy3O +[{d۰vl*z\16hL=]7ێ_Z{|ν[~%k ~uLpGkiOH韁ݭz>{ۯCOԽԜ`,ay t&~W3p/8_Q6}6k i#xA_tIi0XOdx2,5/+ kرfy z^w?A+̙W;{zt7mxs:ZlXwXd4>`eQŧuH^d(]]ri/70A# { V/u?FLDѲ RcB9Q3->^Gw19]?@xL:ۯ:XI6se4̤7^R` .NnnGr4`2V 6!q\i@^\wg)#U}j3#܆. M WOKp_R ^eb +DeV pwVzM|+nؒn5/`&ײV_0B Xk`YW2p endstream endobj 199 0 obj <> stream x\n9}7n^i&יE28؇d1IJ#3ɖŒRS;ڒZb/TG'O>E>}Z={&-V3^ fzxpA󪊌ћӫ^M^?kON^V'jlZNLAjlׇ׍?z/s~wý\pp n9w%NT'<Ӈ%W` PkD {㪙7f"OvvU& sflC]EeWR/S${;W/7~ ܟ\>\k Gm&9f ooWrU&P)Z-N ,EX&2|\n,ǂhqs)|A>69x$Tmq IxTePZt?x_1 = Fuv?B}o>~y}qnYA ߧU!d-X*ͥχQGz<^{hIԉIٱN>֔C8_4C\\~9>F9R!v-KIB_ҧ-% ,OݸsO[Z2T2#RPyT%7Ǥ 0Bv^0N3L0c/\@g $(8D%@3x&EP8s!І<\rA3QhLRe҆^19XOVdA"U 9N*$p;a3 =w;>4Һ9 ՟0 sSk[Go褙Ԃ cEtn90{p:HU$JbtgSL r I"DK르,Biu "Hzьs~-_L`BFObZO@PR茗/A7(h̏  2A!e@w@v4|(8 zlJ!4űB@%'?HEU';ؗRG]p1jDL)G<J#fG nSC 1ܐPn*!CY zp{/O!g vn!X'T q@,:4$&>=#kNr0*Kt; S@{S{6&=xWCϒ^ÒecAMUJ26F(Mu*@B \_:u7 RJp褮9[(IjG3\)7'ˡÅ=pFIlqeĵLK 4 ڸ, m=z&#eD^2z_ :?f-i~CcT. )joM(Wq#(zP"RRi䠄g! X?}ܐ=^8\xP]ov,ߒOK$UӨ5V,nI}:p 7GewDž9*>ѴKLڍiwfg22#rm'(HZI?N 9#kv$"\/pd0K Qm|UG'dCoKB?4'cFMx~wc-}j~Om y!3k編R~o&voQsh. ;=6Po#RߢX v . $DoӨj֚yy ֑k[u(q-b<"Сܽ߻{~ E87޲LPY6W]ΐ endstream endobj 200 0 obj <> stream x\onĴ(t=HywE\Np[˾M3ZQn%p7Ñ˗o^}(諿xtyqFW)"RbREXmuyqEWQh̯_Q\*=}qRQ ?<*Sf2*g:zHYQF)PDE|{yq_//pۂ-N"ZDo71=xZ"k6K աJƯyDջ}Rza۞^3`q)nF#g,N~ *;xNT|XVQ3̈́M&`v zXʪmrųy3Sج0Twy6!"‹Y$j5]D]%y@TR K>T푞c4ގLOr87o |OJ 3#D$v$Nf"YM 4Slg٭of͟W<*=Y4q=-d_'䪤 hcUQ6 0\UXgD=C#爘rרd.Y^Lvx͈ 9WrL7S [yLDSْtpQ궅, Vcf-}1RC)(.g*3sH|[)ԁbn<)As;Y܎ά'OxNOqLc"a1qt,;HeI T^vjeAOic6ayEy`RLe^k{Cm0p*O1NVЌŘ&`W)iƁc2OnO@NLwG _mٸVG?9HCZPD#/ e iy{dKfE >_S1ʰr۰eYeh1lj2rS0dȴ Ba*w*cll0Oih80Tɦ隂N&m~w27C65bpVͫDݱ{|lo~L% &sw4}jtuk l9Qa:gRRhnBT=7cXˆ2!Ey~iķOK:ydzZ !mMX@[j9w@uvWfG!HL0] {V @>UW`Ye8w@0t -C2pgCE ̣h lliJL{_,Ӭ%g@?qA?QYFLdz]^JN)A2cYp'c_b,UcnL7N>IR:5? k|!Әd(F2cBqMol>O/E,9s,MިZdt<_:i|G[" H]ǟ}֐ ͔^.$Y3dYyV! &,$hIr{ 2A) 2=TYҐ-=Nduo',!t>Զr ݴU 5a ug`aH•4/ g- %>!+)`'Z(B1%s;pbKNT`-cmu3,4u]ޕkIYk;Ε9W =X$=If\vÛ`NRYpO.+2&e"Z|`>voax_`)Yf[z8OJ@ksX(0epm rFEw[R]+InԡY-!:f* $~Fͫ7Y5Uu0( ^mNiPd-IzV{ceK:)īڷ2Oi/׬kqZkp5X`x:pK̻T4IC?_ 0 uӂ?FsN^#&:Š-`a-uYai 8ҩ&8.c!qySKho ?ɗEf朒+ SLyk43kIwh1v Lu?3z0h әx^ wz8wL8H_>} vIxP ($̢oܑxT> endobj 202 0 obj <> endobj 203 0 obj <>/F 4/A<>/StructParent 125>> endobj 204 0 obj <> endobj 205 0 obj <> endobj 206 0 obj <>/F 4/A<>/StructParent 126>> endobj 207 0 obj <> stream x]Yo6~7;el$Acd71Šc'|mw` }Z)EܖXXXW_]^}wU7}[ES]45" vϪ_}[U]>]fmG{RaZ]ߝP%85ϚZȪ)|"Wwc͊S]0 Z# fPQ]߼YSrTe}a:^W z:lw/5Y6_O J A߬\`3@-OqE4޽$Qͼ{佲zk950˃~ݮgn-Vխpnxmo 1 7կzZ MfG&>UNq^ 5N֟a$JXݦ#+Y͢M|UA/Y%Pнr9#abxo)i1i=ln[=6B1Vwyݬ|\Dl0ԬĕU@@ZAT|B?ZrZSgS}ZeB\"w@rZcLiɎ%'_?PʲF\pyboB?N+S )b5`kik _HƈnjN{}7ў㗮4ư"XT,$ߔ,kAf [lxŸbQl)xY5$2`02xcVMrL+K_}w1ƪZE E1٥qv.gÅE ̸] 3&8Q5TM&ewϛClfx-WUVƮ;cA[-ø 0#'rѪ&"nlk Y;c0C'iezH _)kϬItƸ48+}?DMkb#(!iL8N(BgaqiB9Fk]Ō3+dqxt4Í|SbeOLey ;;_Nfl0;]2ucѻW޾f}갻/v'yP bµRTMCԮ7G}.B,AF :2>կ\; ]>n`#U_lwZ^^ϚR@:<H~jP:LVfM%p^KSO^ D54WGȍD45T'F-ͳB:X+je XxDb1"+mhho5Om>\B&f (6%Y`lSD~$̊6u"?Z;̉C6-2X=|U rَ,9PL@)| @omCU=,O+>: re`HJKl^)g['{Qķb`𙄯ϬQ/~K,MRGhi#q 7nzUkB(g9_Q&aS`*Ƒĕ/:&?F{[ԛUiR/,Ծ/mv'pj=U^Eyvޜhokm UB*IVLqgoO `/cV-Wyb֫ھauqg7U(0x:C4~>xmx2׶iM G`^LjR*l\ԔoLTߥ o{X)54ϮU.3WyH6$ґu ,yQwSa1Kmk:O>nG>J_o͸I=MƝaf ['`ݩ3bLa'B2$V]6.Ę#gm 7#Bu))j4D<8u~(w@h>{eL}JR;u{6Ew ׻o> endobj 209 0 obj <> endobj 210 0 obj <>/F 4/A<>/StructParent 127>> endobj 211 0 obj <> stream x][o6~be*h&"v. ;Fc;t˛F$RfQv4c!ϝG~<9{o櫯o}ZiS65" vGW_<{⦖-ѿ)vj$Aki2Y^Qk$+ԌGÞJg }Yݩs=Mx$( Z#ɣgիG6?tQɣFs+ ^]^]]zGߩa9Z" :^O \ݮB@e YS>ΰ׫_W ȯkR?_jZW?sup0 ~>ݫ=J@_kٶbNjR烸PRC(Z|(HfV$`"M[ 6bwjswe%G5 Uڳv}JW5WNR>ڨL.ԬnvOk1:_ ;Y>;y;z{\Y CRb#Ouĕ>:nP WC3vnLӥ!WSyH)ԡCcu#Ƭ;WTwr%ۚB3V,;Z}NƨQ2'd"O =jQQ[LgR{0*ܘTsD|f5 B=GL.Y]93{rc3yeꋍkW/ (8)-LFn6J> JbhMHf'{ޝ_xm.ӛ4QETv7Qfi0Q.C6Qe(LHTZ$pR\udsqIIZ LTz"5 ܗDb do_=Vq ~woPrO &VVV ׫ǽ(|p5W JH\qrήg=b9{2=9xwP 󌂋Ex%X!Ln4y.(*@L  ƚ0 "ViFuFPM9oPZwx`hH6(ҭlS=|"M3teq.PɆ$-ل̊klc&}ђ֙½uQۖUHuZD4c*g=y_E/ ^4b5bh66_iAdɖj"ʬմ Еj k5]& ( Tю<aM/NjH;%Dćv|׊ BMkcr@-Ӵ%Tq'"O DD4/E'":X)gED ؉mH&>t%rK$bE]*B2ι (;!,a(M@X+KD&(z t ,eNW¦Jʈ, ]0+>ϲuH}.Dx¤Iр2MGذ$MGNCd %nF4Q&k-YsDeV)Dq4{Rǎv4HEDLnn:;_ -`ťo] I%B &K!I]-[u T 둩>~yXf OáDҩmlm:m4q_jd5Az^ꥒec%Fr.jԝ}ЭLWfFoBf5R~Sf5Vܩ!!#DA:ee/߿e9\?ްV -?LJ9;b0Dt(P ijl+O>!ơ y`ͳи0CSQX@[ ٕ`20 u)v;;9 F]Ŝt! 2:iDr,0lLKǟ]0{aIڦf54gZ6DzN*&&Y'sGAݥVS3qAEѥD{Qt-x\eh&cd4`VTNcdԧ_NFak12 xtK'wΜnlDm g1ET+LcuR%$Vt {L193%6`VTc$֧_Nba1 xtk@<Ƭf\'g$ )AA ME胢#ahbfbx zFu$[,a`,6 2eԜA]P5βъ9`B٦e@g)RLD:tWa)]&MF{KcUyEWZ<l'9br#e`1rڃ))L4`Xt>cԧ_NNa1r xtaxkBN22\fMc{u®c4fe|O'=R[tR0,e˨Y'>rR8NjR,eog^OA51:!>TҶ;\c%wssw3jdoKC mqB`saӟc blf3PYh\CSjlJh7>JP1OAclFj;cslzL ^ik <J fi_mylk]~,yllg=&ftmum6%AD-l CS12/{>&Hj\CϐDA–C'!>w'.8:=+9=Νϝgj#Q*Jޓ玐yL[g>w'u{s$%۶b8l[Q-X oE&M]KisxMioUiU4Պx+PkÞ,4.rJfcf&Cv(q`2 w^v)tx-h+_%a(\G2M<\- Ntzt6 9l2{mTJMfcgɦ#}5l5ِ̀mkrxӬ$/Sua6/%o31lĆ < 7Nj$"fs)[9m{wW 2Uk QE8Qo ǰ+12`4 ,xc my V6 sP &1|waB 2%u*ǬYtmL2XdwLL#<._W(ưm0M`Η)15a`&$N`]nKCX)t*&%t2f$uЅ +nLy[ W 5ư2 V/I|T/98OΦ:Kd~OTSDT/Uj3'dSgIT?GmX/^oܧ9chxg>p0"j1S hZg֋gGd YŃ#xDzIja,Kb{F[=7^w eǐlFh;_[*q>]O~ޙy.}~%Įs^ endstream endobj 212 0 obj <>/F 4/A<>/StructParent 128>> endobj 213 0 obj <> stream x][oݸ~7E,Wn- CRNKm&$EQ&Xpbq>3ruz?T5/^T?:~.HuyxpTGMMX%u#Ã?T?~YU(ď/":hjMP^BAc4իÃ_oG|s]mUg3H7hBTe8ٰ__u7w|x{ $ȔCQnе" o7Glsa$խ pxvf]v_~>|3qߌzGwaSݽnCN<5ǣZxuéz7W_oûb.qx HYS&Z6 $_mͯN2^7TDWj`n,p?ndDL̦r'o2 h)swn_3}OBLAiQb@柬;u=қ-<OS8MƊϾ)Iz7cw|>[6b_ϻM(ipgz"RȦh3 ]D=6F\ h(4ckGHQ6^I teŪ|nR"pګ.CHaC8'b]xl|,䴿]R;u՘R-x7,zŒE]M$H,(#i(zK=-NitEE83N%C\2r4iC:zTϪ* 括*iP2kx4rK@"i%u's9T-'wD;(Ҡ;j ̂SV48'"g3UAl)PLtNHjn%%ٵ3҄#pz'Huj";L2֤5ams콻Α|N[,@G%)j -;rݮZ` `^ MZXaG+x:SإPG;Tˬ4=Jeq)1afr}FkU++.Z *c|:F 17 #2i;1hXpH$+llZ /~]-l;*m=ze˵9ٶc.zV=lY!"٨"#d\oU(4HjPiPu1# DX.cV"W<3 -=3Ֆ%l]H^۲wM'`UZ>pZE6|E ֣~qE`0 EeU7~7hw3Mk;4+jb`S,d5[5it!gtx7od5ta+4˾9-4 .4$]Yl2qqf 6U(>#s˩^+6׭Oh*lu+۰ۭKC7[|S?N'pa[N"劊*"xhr'pi[DVo54XmoeX]9o{BF7VA`[H_OUoy6!QUO تV11K{^NiWJ Ro+H5GW@KÜ2 Ws[RF'SsNYˬ񈞷`DxA otYX]9FoGy~=ofJ(|}VĈѻX%( VQˋ۽VMT2&L;i2 ۻʠt՘jL"E LpȄevI&6+k2Kel&8Xa |ՠ1!nz6pN8}`e.h0`X.,HgW  =^!_ۃb {!{0.0j`1{15~1A~=VYa[تp*WHV1@KJq~/'xcܷ#yFOY֮Z4`V~UTcq$7)@,fSh)YW-$mHw df.mkZ R$;A.`,Hs7] {Vqhip365+F |&oS["aWu?։^J^^*rwoل.( g2OגLi{w#=oR/ ٲ qh[]b;YCYS ;CQYŝ {~0}T~ S{-u"6QV endstream endobj 214 0 obj <>/F 4/A<>/StructParent 129>> endobj 215 0 obj <> stream x[konaf76n:@x"P=d; KΌ)-^]Wd/^$/zl%ӌPH#I.d)ߝ%?}$rM&jeZ5OHg4MLF2(B\-2$# +nXW7g+gG 4ou{=!R1YS>Y%c MN$4,t&E'ۑfL)hY{El"RDsW%K,WwT1n2Փ*078t*>~;,*`>OXS5f65z|N)\wiU%KMlO?dBTl\E4#0u;@IVC4|qԪI^ tZ,o]~ a˺-VZ#mKoXh]ޮ$Hc;۶FPX}$\#'biիC 6Ji%XFIgKJLwgZx0e<񰧃1P_=dAہ2ɉ0]6ԔI5{PBIj* 'h1uQm'ƦCd{)6Zߐc<)nJ e:g>.J0yYllF&$JU F\uKH1ܺ^>8(z5g[D6FȱlulQέH6M0stmլW=&;rwզ5[ъG S~93M9:K6Kz]I־gFc`$gNy{7cQeWr7rK㞊 T\݅sgA_qQ1no09dK#]O!=Ⴆ. ` w}GA(͖v䩁-{,bpi{YXz ߌ#vpWk yFILbZ?4 ph9{g"cQBڍFjuG7}nq@|gH3bz_. b|Ծk?(֋ zۖԬkWȓMf*Yy%eۢx4wY)&{*ofuVV!KtDn|^Xvv/X=q=Z/ߺ}rg erbT@vJ [<S\iA{2?>{ \+ݺ޶cm,K;^hgsswCejExgV4s el(M6jP Bq´6@w%ַĺ^1G#=B.3@xORoOS$:6I7N jah!Y!v gYALjZ98fT!@T6Hu1vs78wnp% fS/ 1n}O) f 1)vrHK63ش2[c[۬~-VWU?K,xov}T(T1%|dX؄Jj GilOa?AOyt𜘬WvD;sj%lJo& FJS)ٲ֜S,.7 8|ܴm奉A&a,Բ`2rrDa݁|=A Q(>˖=% 0%a!$謺 ?>:}{{AVڡE5Y$ "I[S;؃3zo< ji5h=yI|*ސ@ő?i9rCm<9kxhGn@}O\Y$!f$BW RX@&6+vfX82ɘ}aVz2ThΣ$`iޘbWI_+d { "Jǿ骤L$u2 ^Ȳ!E2YCx'8L<0T[^rsz$/~ %ɾ0)iw|26fסT_e姺k҇[G̚ ч:T-ȪZЅ]ꕇ"LE:juZx`n+dKkAtgr!d/eg gG mv6^uKq<4S7 *RnZOiP.>MC7 :Rn4A_ *Ch]O`FM1gϻS\{#mr)jC8^:zrɊ*=AGJC]=K^/dھH^]-ӚSo>{#;Oka$>3Bُz1cWv7&G PfN!/BA@qR0_8|8!+;ě97~  ?Vg7a!NL[`ݾ>6;Lz7=&(GSxt] yDa0S'6?a=Y$ ‡PG>|ni ?U_|EH a3R~箽YT{E, @eYr?8MW0ǩ1E{/&.{Apu@4`㛰#}w$P(Z J endstream endobj 216 0 obj <>/F 4/A<>/StructParent 130>> endobj 217 0 obj <> stream xkoFu}p$7܋@p#S2JTEى>HJ Xg߃wޜ]l2 N̏,@e*U"b*XG7gAY߾ϗ ,ӑtz{|R"ngG<`ǃE 8xp8>bQ,ad&|WGwa2_p`Z∧wa\g\(AȝCqH ,$ۂHh,8a0G8Q#~&!#6+*ZXQ)er`Dđ}5 Y>KXA;sMH>\\ },שj2 Hk.rlx*«ӣ.ɰ$gCręm=qUL3slA\re\F8WlF;dp;Dμ TƍD;#+'8im(\󄊤G*ϐ[pajD祶Mr7zBd֟[=8# +ZDh>Wa 9ʭAƶ;X&pMz AkkCT2i' ԷGRHHo$~NquLdxgsh^9XA hZ -͐!mϯgq |S=6o\bf y6 Yv9ytt255J;SN5b^/+drrQ,79yŌ>w;KoI>"i$SXHniҜpe!)c ?ҮˤsbذzaC%%|M/a8:iƵݔ2֘bľ1ER'C(`i6{8Ls|'L*evܲܠ 09cqLӻT )❡D_Nw%,Yn\#qyn856>^sM1>ǵ Q } "(SVS{W'O$" })ӂM.}$Sؿ\SZ|uw`}vbHXye+#MFnZB N6ũWeijM^qI9;G^>~8`_ Dw?_'4S/N)Ng$7,*m :r\h endstream endobj 218 0 obj <> endobj 219 0 obj [ 220 0 R] endobj 220 0 obj <> endobj 221 0 obj <> endobj 222 0 obj <> endobj 223 0 obj <>/F 4/A<>/StructParent 131>> endobj 224 0 obj <>/F 4/A<>/StructParent 132>> endobj 225 0 obj <>/F 4/A<>/StructParent 133>> endobj 226 0 obj <> stream xY[o8~JۘIQE4i2Y$b۝b7J";B鯟s!)ɶK!y;Tp˳ >9 ޝ2L` S OMTӿOX_YVŻ >Ndß X* 2 317yݴhb£ HËH:$[/e&i8#uFEX`V}'W82zuxK4i;ù>USG2".+}d}M%7Rn^u Q55ptjjB?ÃhT-4|jp)_H#wk9)exDǑ&g8;x̐(m.mhx r)bViHƂůQyQ ^ILEb~a) KNu_):lʚvͬ  -"~DzA >"J^\]O~UF}XiSR-Z+ 0]bBL%=*) XQzX~$#mc`J0Uچ+'fV5)U(NTؖ5 D ̠2?1cOUdKVwoU70 mS!vyܠĕȯfNR"φ"*AF_In,4flhĪD߹Pa:V=|<͍? +a _F\zL5jt)+ B-].Αڻ +$9/yCرHX ~b2嬉NX.Դ3Ib[YW} R!ކbȆEBZjiZ[N]E^@MM`+kfkDz15Bǃ}oBQ"P-KTB5/ H͑f!<8}&WrO T.Y0фF@hGHvpƳ[>U/9,Dfb1Єb̈#5~=\6E*d]s!K=*PL.W"7qN`A ]w <]6: Bycd,AnSd"p~Ǽ6jO>˵fQcUf 5|4V9FoJ >pU'6nOg>H!THot{q_=6eDi z,mȢ#k$Wr0u`?4ݺ-IuVDzfv "*R;ݽys]$:&zdEQBAȻ -ߟ E?.hLvbx73U}nw=fٸ6"rЄڮr#ZGp$^^NmGP'ʎVR|ކN٦꼻KBM6i6c$ؒWU%6vc8XQVu^ FD“[˱r)>~ֻ( I p%?CL?CDƑ!| %cezot+mlo-@g DZbpF[*%TN}w[37vgVNY:(Tmɀ~=EjP5U[~ߞW cMeY宸Eh*չ1=Zwی#U/=*p*=r3\dkb(hYgsڣus>@%!1ە߉hdxN24q$1W 褦QWA"ˆ7%<>6}Li_6Ud2?Xs/},Oa2V@`N /N&8Ӵ64g'27"<ǖ@ōp~o'.;<{z21ViL~ /eps<37 J"~d|2[SQiw_딻v}ޣbA;4g3}eǽr'֙E-|PW}J! E,?% {1p1TmLQ+}?~OLE?wE XL}Uܲ_^ endstream endobj 227 0 obj <>/F 4/A<>/StructParent 134>> endobj 228 0 obj <> stream x]۶ bWk+n]Px;;}iaH%2i}dI>}{tqc嗗uͷ Rܝ]# E!9EXgwEbrr+ŋoJ{o.g)G#ռFznz|j{k]*^JaUy n 0yIsIwg>ץoՇwuFCԆj n<#kM= >ݰ"?o7u'JCFmZ7cQ{Swe]uڷBh@z1J`jRAưH : -j}-^ (הuQ{SaV\\/=K5 "Dn&j{+I,/3Y;-69 L~:*ޑ׭ciړ>n7$~*l͂4!p~D,6UHp"aPp嵌HɑOWRԦb6Qn$&: b" Ĕ56L47(A0Q#c>$SaKl׋?3rP!U^b=* #CP=ETb2J0 )1q!{+1bV G[Om8)k#bKH2 /꯺0ԷyT@,l׋`ahndT&)`f&H VpijH8 )Sm?; AOF?ݣbPo0*csb mmbomb?HVZ=8.l;zLI덖0^'+ vSg@nMvobҦA5"8^ec M6A,uPf$*yE m޺í5;cᶣ:HaׅWIvדnKg ;ҶͩsDk,7Xp3"9 ײ rvB ˅LI dR"KᦔmB~A=V)?V%Y<'F"\TիV1xsCsw`HlkG߿)rʝڨƱ5U0u K&`,5ѱt^^ w$T52ȮԕgBPϮpM֙NH jW d <\6@\uN`iN KpFC@\%PAϑ#TIy_8_^`2GGP$`'0h 1," &j@<|әt$JblRyL3* 'CNu2OTEHC*1h.@&xf(1h6#`|h;1`3)-?&h?X@Ub ~ 4Z|ߏW[5q/*؀;!`J=#pBh(5FzʍCj$#)J؉2ãN0 O*U89IQ%;j̄3Uod-w4ŇUЃ!fܺu;Vf@:Y)rsZ?swqCPiL6.TJbd8t$ 2*M)Bah M.*bBC7(|].Si7Iړ%㑷+(gSYʩ7ɚiI:J쪡GvHSѻQ_Z9[YȇbefuY-vcȝ)uCw>1銲55:Z6"u7c MXu9LJ)2mye] ܜ)<3Aqg{E].O ΰ k(:"[I hRf$"Q2W6cy )x"a/#V?O [3"pt[8ֹ;F~({yN{9"7l\ƭ+ZMr"{MopTt"=l s_HX6gBW=Q/+,FӄJa|}yn+ĻsN(mYYsJ~Van~#SSF6({ 8"@8цFPwZV lXhM4E 5(_J3B{xiq7peE7Ip"Q%.R# §:u#+@ucMK&!js#zr#ŠiDfR# p< Ƀ˃&iG1". *69{*[abUD=k`uEtX5G)aV;@P:鈼rzJ0itX5GbA+N!!gʹ^XڑGa'MtA8ōWsId$$9RbH sHl)B88ՒHHxfcߓHYET3ITj9"d +3YWI0#:>Yn^sL (Ĉ׉ e&a#)E|ƽ3 |ƥr'"[n oԛ'rM+S_dLɑxjf3GiG]ȹ2h͡"H*m`RiLj9-Al#PZ;g6 vQo_Y݋&-اa$5jrݙe`sTP4ܙ5_sTPiX6GcR3ao ,3*5a°jZJy54f}432D_!ca,o=ևMAwɛ|&ay3  c"P&O1 eZca4g76Ǽ yѬ KâIvsnSTY%gzFha1Kvvl]Ҳej&fyZ^^s84Q#{R#NPuN-XA#j DMY{ӢP,&c2 e+3FPhXQ6 "TP2Z?'+@rI6%Yqp@;a w kZNǃ wh\PG fI fOHh2╥7D,m\n.maά?A  endstream endobj 229 0 obj <> stream x]mo6nA@nP^ziKڦ=$@/>!/C$^{?ꅤv(i\p G*N/=}໯޽W ^\Iɸ,tE+uqu~|QE1:'xqeQÿ́(o -X]umJ{n 5mKs%\__wONx ̀EQWUQiR%hJY<}yx/?O~|$)@M*=de y뉁x{?iwrwc^ I ǝE f^y~ܛ>GU4gb_`T N6IuRs{&lIJx/vt4/ %D)y,A%D%ݏb 9 He>\ρd)&H1i\V1UibbcIsR81M j$z~yQ/OJ8+fBĈkR*js΁4#<*|َI_Fk]aLH~rzxkvecAR% qX"*yx)"3>Mk%gU89{'=Aq7n>RNePmBUxT6$TnHfqؽ!e}6Z^]`4'Y+#^K5Α_Adtwa|#G%6|"kK3G uݰVTHv Bf* Y 0/I.Ynx= iRj.XAPm I?b؍g&߈W;~_)ʖ.g%c$2lTyktsW-nT Z׬EUɄ[ Q^xk@D[ ow+v[YmCī٦af*m:mh֛mfVLԙfpb.- zQ-M6%5lG[Ӗk- U{MǴ s:C6`-7  O;MI-#HnS(0$A,2[/QXf&thslG,-k8ː(:)/iY7R<ٻNűPL712%1|X>ѧn~fW6$Q6mbƼ$ک ݫ=\aԶkyвf:޿@[:%Q3}Q4V>$p\:OWr>QA_@ا*R&& Q3Qg`Q61ۂ1fLD`i͘fN J r\&V:o$j33N7l2W}DٰF7L" mvE&lL͉՗jD)Dmz>N@ U\OA,` / oB6(K4Dr=VEkќ/I<92 QSB<` j-|/@f7}\TW9)QO%8wVWP*Kˉك'!hPF!-"P\,(Ka (K\WeZ/tYhnp' B`'\FiA -uJM3SYؒ]j}o5qlE*䲪,QTeg}DxsyE@JaomEEԋWTujTzːgPHMtϘfG>6D(;>A)Q6i^,E׳axe(;d%ZʎJk=Ѳx)()Qҭxb.`N&ϱ 4Dժ^ZJ$/U^W 3 x~!*sg᠜ۛe-8= zgQug nHIN79z(kjD]}`i 34 ^ iq0)Kk_eֽTw`[1V;0֔ccʮJ45 pn_VDIA MD̀^SSU_ Q`DPA(F2V /gpy(:ӹDIZ瓲9RکjjI<92 OhDm&]ftr{9BdBkBkZW{U`z݄22*a<7nPQh}j6bTEI*7':kvPQ1dd%庲YAW+:]ZQtL׺VAԖ]#lX:hʢ=[TuZꨂe$Uƈ?:/heN}Q_H 2Rf4YOܴ 2>Ft|='*ij2bIÍs7*a͌y U +־Ux j탒 T2h+p[RTw=R4v#jA ? 1a7.B%uqH30dUs_0B yFKƞٹRz]&eTBDϩUkVḿuy wQ5wWlUN~=oiLR݁ɦQ,0YՁɦ&>NT=6d*o`&KLvt{&K#L6%dGHf+c޸ZP=utkJ;Pהscg8 u*Dm>:NHY,(>si\eA!&m+GR+U]WjMɐiO=(v'T8`ˆۛ^avppkFך|Ad9eţon'6 V./fη;Є?VbL-MFCO 3nof%2.NlfA3P̤q.sՎ7A~ b.ln IkDĄkmxYal}4< ??:IWn]OG=?Wf8-˄*7TN8ta-9/6D^]ju<~;u,7_wܷze|+*(_)5iQK Eͺ};qlj .5pkzje#apES_A{7tφGX~Xl쮲dn"졯O [..נ[[l7m1fQ:qؚC}2X@A$}ɱjYMQW)Oނm^y}?r |t?1cddx|vT^gW]T.ۢrfi"n[H- #DB9N \ܭ;sƗFwtƍvfb 9]J\$%uYPU(j \.}L I ґ\hVUɖv5g$6() r@NEνUp$ g&oU`'J0激on?~}t ާx;8gB S:\L)`wn4s8s#;tx$c|묊Z(FEHϨa=Zإ DM"%" R;+n1R,0 J߹Dȸot6AjdG_ȸ5pNM7Q*P,E]뼥3@4 en@MLŸM3m7 n0"ķh~KJnr䠸@q-t,-uyGet3Q`װkܳaAHU<f-mX͠H C endstream endobj 230 0 obj <> stream x[nG}'}#x[N ^ bKZr 艹&gT cHɞ:uOӧON_|gϚ'/\gG9Lôif}9]=Ϛ/7Yl&sZ4kJh H+ܼx; qL`6ZB#83yJ'rT)y=8Fo%"vzaH~? 7pE%Jx+JN$:m }=~pV?De4B)-j_,؍$ l>OjY#ZS4 ޢ j "rmcWXQEIԂP ID4!JB|Ze[& pq,ejUM D fjBe)rsJ ,^ JBg Vxx06[A|g4{枔HH,XʕU-S7Ict׫a>rsU[QPy;,K@ bˤ,i`5(> ; ua9ާ%N˒'?S= /sc\ g(zÌj@Rʶޱ?T4t)J+"S eX)"6ES8Դur5`T2-ۣ7KAE \I5LMxjj;҄mU5f SkDMiPVl0\>\F~𐦙lhc$ 2Uʵ?#_. &ߛҿKok+ R^bEISg\(C$xx̝1lrXlHV\"N\Cbꮟ j߯6a#v!1f00q^ ?Jh^tTħMUژa ښQZPt*: LME QX|9'8M~[=Ihhh s*z4Z[4#J DM.k/Nxa6 HD|ev^͝oVy鼧Ǫ{a;+4vDbaU=gm`c3a"M8"S7z pD]Yp%!v-`ˬҝ#-3Yט0da'Yn'1 ƪ~z2÷8{p{u0e;@D̈́R+BP&#|b_rtHQ/vx W2mtmsL:ǖԟ}ެ=  endstream endobj 231 0 obj <> stream xYmo6b.  4/6$hf؇bTGvӮ~wdS)@֠%{x1d\^!l8$W7ׄiHQ.4UJPIY.&ozo2)etWzwE& Np1UâwhF! RN8]|o{ Z婧sDXEEܗѤ( :!jtCD_-抲sFR*ف,Fq_Ew`=yDۊY"NaG۠&H6.YhRCԁlj ]?dj:O|ە jPcK?b_⾉6btj0*[LnmIT#ig>qe:\~n_'t:9׾R׿}{9PTQƀOڶvIuظ |TtBsPw٩(xJ=c '&:-ȗ^q ~) [*SJCr͢`I$hwV' C̜~ "_먅@!{0sM.3zh.þߜ %09o.`vana|VAԠM 2$h`m0G6dpv\R/Ȏcm/Ƴ YAeu@84K[OkmuE>Pgdmo wmݧ;KnBLcĖkINE0O}Ѐˤk(;IVt \2ț 6_O`UMTe=4pXAI zaրc[C goWƒAE ̲-J,$s̉s2l('LcPޅ0xPTK(ެjgXTأ ĒLH*I“vU|n%mu|F"~k\oڪ>l-oU/_6pdX (a71fJBG!#fL3 Zt?y^ecCB[1ƱӪZەnމ# 'n E0F{3ZHpXJN"\xJDEW7 $גK8< ]ۆڀ,VQddFVk hfbq3+˺=ߺ#%wĹSn\-!7s_(-n/V?Ľ9 TTŦ&`NM4"*GJQyk-P ;}[K^k~˟v^>)X5TBe_0 o=8]+o=-pM,8j`( >/F 4/A<>/StructParent 135>> endobj 233 0 obj <>/F 4/A<>/StructParent 136>> endobj 234 0 obj <>/F 4/A<>/StructParent 137>> endobj 235 0 obj <>/F 4/A<>/StructParent 138>> endobj 236 0 obj <>/F 4/A<>/StructParent 139>> endobj 237 0 obj <>/F 4/A<>/StructParent 140>> endobj 238 0 obj <>/F 4/A<>/StructParent 141>> endobj 239 0 obj <>/F 4/A<>/StructParent 142>> endobj 240 0 obj <>/F 4/A<>/StructParent 143>> endobj 241 0 obj <>/F 4/A<>/StructParent 144>> endobj 242 0 obj <>/F 4/A<>/StructParent 145>> endobj 243 0 obj <>/F 4/A<>/StructParent 146>> endobj 244 0 obj <> stream JFIFC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?}*M1AeXF|b6Ul,WFʱs)_m*6Q(SG0rmeOeAeMeC>Ps)]>]s)]6]C%MeBeMm)J].]\9H2 Qʪ!PCl֬8H  O$O&KA6Rmmy9vQF9e*mm9vQK` KF9Ðe*}mC66>B-*]hBj]hBj]hB-j]m|[ivTmG.6{ivԘsm.ړb`1NoB}0*3ǎ oū S2H8AN&.ѮRtaVHuw>:S䈽΀닳"Mԟۋ}V볟.=F!$oi?=Gq9M+ quDu;Bc4 5ԙ;tXǶ)C YdyqAxs sLj@ʧh Ic=G搓M:3ϥ>H% czcQ (5i OҚutߚIID>>jf~5Ǯ.C`z+j{^3:>RR\yա퍽N&H^༷ٝ?~4=W/e/MTҹ\9/er[o=V _Q/3/kRSTDǡ6jQukFbʥGpBg#4kToac=A;EsK pqJ _=GYQoI袸K4ߘn~!{VdeE-{U1Uc}K\Jܿk0˟ANΗ* OX_"K?SY Wޘ6MҧNY4^$o%hԕH@aF\zB^eeW$S54 !Y؂MW{ˢ+]CN3LY-hOAQ-čqWaýԻhT|ӞݢÎt&iwA•V=Oj ӐҬ5ԬN z5Z =;Ԣ}~:?)j{1Rr +X? { 9Tm,HO1@9 B7*8s>}MJ4ő̳~]@Z)<{拋K*,cPF̂S*.QU ${U&&t`q5z1T#wRTR R|AP8RT*h/56h ̌)³nu_K|dR˖~^j 'O^£<%u$DۥJJ|,U/;g݀SQ:2 sNx"R &N" =E7@~b};T.K)j}Zg4/Q^[ag##1UQ?1ڝj{!8,Q?,20cETI~ ݤX+1^fo`IKq ]ǩSlwǢ4F65?x~+KCUCl\ ȑҨI0d6wk-nň9~"^3HL';ݒ1{?ʞy)EW@rIE}Ve?KK#O# Anթ6[ȠrkW՚ݤ8-CJŒ6-e-YSբPoFڣn}zW=᳤]E.e,G'Z􄷞Hy Hmߡk'V +8 @WiVo﬚!-S]8t8SkeQFxu7纆K3#|Rhsic}'G1@NzW$ַL#fQW=kYbMNN5n*Vԓ2洟sESncץc6I5kc&ޢ,jNAc܎jCp2\޹͓X[[ RȝKDam'wi%rۜ*K[6wdq\lʱޝsLI3+Q#w.a=l|ϟuqt>$%91^Td+ESgڙU[Tb͋oܼv0ێxxY ;;$}+#:P{uIbլ.D*C:I1 XxFw5i׉`IO" 8V:3 C{;`mUcaJ]vaѩU)"R{jH4 +n9چ[a&z)l~ϸ|D,dHgHrѦYo8 I[$K *rNHϦ*֫fE{i)%!s݊Ltd?ADZVsq$ǥg:k Inxڕs;FQAv=s*oW`mGz5_g<70|Lw$< nEuml#0J;ƪ'ϠmHsGzBkVy駆o?9(@+ats=D'8j7:m#p8lus=vpY@ێGNhsj[8-o $cJj{=NWF[Lǟ,Ks?#a5( ciN4jd##S9?#PKy+Y wT.-KTx.^;O$sBO6svWHO;VYpv5xulm ,}+HU@WLd$Wbb2 _JԶ’6s*7]:P>Q|n/$NN[caB ZIw5'g(cfY9~x{M݄P"9n+`Mњw1hO!~b˸1j;a<5X4r9r:U+öF'^OjYP!BAqPsFNIOz\t8֚в!|ǞAN4v1{<9ʠ DIlaTڸ-\)ʱt 퇊omKaIb5b0(ShNyu-uH`khc_SQiX;,vLoMvu gh%T@Q?e9]l[S+l*D0/Ȝkd y䋤_,oUӒ_hf<~U_¶1.K8aYj!\rexzԾh#`?1+tF[ n^K0ʪz=*gWb>dO0qk'TO.PwnkM.>Zsw M<sTy m! @oe$6ժ :5kl3r@ƴKd4.TKJӼC<(!Wr9A},Zy^Xv+DɎ>ݢE'+8oVK# f8,뚷_cUS"{nZ>O]9gu9rnXP~i$ܻٙl;wִV@4ʨOvv)yc рqֹjɺ)2@8Tn\`jW>9ZZ͞WQޠgPTRɒ:kXFDm'Q2M[0%rMp![ebU[\aXhkqci!mdc%NkCJӧDrF8uZSs[w:+@[ J]%|p~ikq8 =Y] p3Ȝ. zSBn*q'+ٞ\(>~p@5rA1vv\cɤ1K%XWf$g*/\%HB i0ǨM37OXM -`hyvܻ6F0In21 O:6T@95^7s52ݣ b]\gw!`G4QN)\WX+})$HA"HnZG%J,c-袚J;o٤q+Z(1 pЖޗC,Dķj('cAZDTⱵ9x# y6EtL k[eQ fHCESqVA V QsE  dž),9Rt8Gr͊<=NoJ(w'8M2(KQJ <t%"30žn;T$$q׽V1lilpI*"#h=袶D endstream endobj 245 0 obj <> stream JFIFC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?%f ;"[ZP X]P~R88گI_SȥŸOƞ#r@VsPjf^?0jޫ6[ f͇ۜ\zE^ȢV]Ux{{Y#h^O=;UfEgVlTiO):< '9aLeP?'+e9;# ON;SC>|Ҫiq18' KZXy-"/$[("pNr1\ԅzTdl^U 7Hhxϯ]nRB͝>a31'֚H.7l03R6czI+|qQO$b\3'8帋pdÀ)0SFR9!'j6(Nz.VNk9 w`X۽Qp{PphBL( b?n*$z1R? E17n2ht 2i3$FFb zUlka5snX S\dWpFyzTcVաէU}qX#00D֞=2KH`56;׷ӥiX,}'m >xE/*#׊^8mⰻ b ?_]A=\E x]GqV; u_ϜzSḶ rۉ&j0$K*E<0>ȡ*cP$j 5.[C v"2-rw`#\mlfD >e ~|=@mT̒q1۶i6uNsxL #>,kI$R dSw@Zc8p*,R%bPG>ҫf}*dG >̃O|ԏ#tIJz7*0GJRĂ15nW&㚠.GhIJѡ\3T@*($Sʸ'i{d֠N#9Ò\zӷ `}Q*=S/̇$TzBĺRq^rw@[S6=`jVO2 o%횣qv;~jF[{֤5m! 5*\3@a7 ژn䔎Uq g3I4:91ۃ rqŸn,BDZčMqyGzRo9j%oʒ=jv$6L5s''Gi~0Hђ(,ڒE璭PFЌTZDC2H9ggmD6rALf dm})>7cV+9cp`'t X J#iͧ$`HtR)Žd2 Ym z71T),٣pD SYKgs \ԧ%b>**xܜxjh֛@<1ǡ(nUXEo/#ޫCw?.v"~zZcO;zcl+ s[,[F0IJw#V=fdgq`23ҫ;,{ <dś8zT(40==)Aϭ4X3;1e\uY0F6qZ`JTJ̄E;&BFlm|0]V}JoV(pOAX GN( ˖E;*t5-2jҋmfIL"1!+sqWMhA2z*ǹxLfM{TӚgߘvKxqU~lJb0sc4;vcR}#ޝ*$ cx<HQ)[ zZ8$FGAi ;0=z( qg)j73DF{)s]*\#hJ8}8U X `' [waGbJUxd񁚰eħ+$LJַ~ֱ&)A^pYkn̠{;9$QQҲؖ$I>P暼42Q*ej0 ]G;3kdUY{h}x֩4nxaҴ"E(*ޣe]Mw (OYf=O5aV @* A,Lz&Oߊ֣@4 Bz櫜F9oAgyR&rZ=[b:m֦18+F4@ݩg6Q@PSb<DGGS'e?CR`_{M[V^*o*dڲ|`U!UIqO9P 3QS0jK?F#'p,PFeHⳮl|}[ RG+#d`GtѯʹemmkIo [d=]~SO+2RW@WY:ci o .ITvK ̾*Au 0٤qOp,%$aa?̶laӥS zQ}'u'%WwjO7=5ǸrOҠdhGFXr} hVfmNX7> v%`9!T2}t(D ޣ&$D+VFQb (%9sL,Pq-$*i3QY=MvjReMΊОjBʣs ͥzOiؑ9oƁ&jeG 57c cgH{Բ,H>¢}Aޝ6(]"Θ“'ڜ-az *$%_n~:j/+g6iU=ATf`NR??ҡ}2FR:#E!:1ҁ#8# O2A I(qW\}Zl`"?p8WLjF[1H4uݺ#ܧ[h<{ъ~I(ր1OFxU4̼4s > stream JFIFC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?mQs+mOe Fڜ@m5>M mRlAڂ>6P}Se mQy%OX6KK]6]QڧKT)v{Qa\e(Je( -&E9`i` 瞿V]m8Uהhk)kiy\ݙ,ަIHRyuw1V3Kf(1 O4^_'WLY}?.˫W'E?.˫N)ԾOrJ#j_&Z='gԟdq\?'g}ڋoR}V=>}(\?'ϥm}ړ~\.c}Qj/\?gQ?j.1~}(9Jcsճ3K?j.1~Gkgҗ~\.bڗҶ~K?j.1~})ERڋj_V~EsԿgRڋoP-dZ{RڋoSZd' at_cc퍽9ϰQj=)~=(ڏ{WK1Gǥ/lɜ=tc}Q3/=؄aҕ`N=9j_j>ʹ}3RgQ]/ِw}=E=9j?*{QUۇg7G5}"Qس/="QEۇg7j_{WIEڏnŜ=teZ_J={sa5z O ={&sa>}zQ_j~=9߱{Q/j~G^ɍ[iYg 54M˟fQΎAs,i #9ҘfoaO\p{1]fZfH,MW )\K9'5J_jO2$O)i*OL效.ܞ[ j=H z@f$AGQMg͌Щ`QϷ UՇLT6WyLшG=*CAV#OzR(6dz7I.PzROMM4nrAn4nwX.Mލ4X}`)Qjb2ܓҺTNK9nsIʣ߁MGbf x#Vl#?U ɟe9:`CF9 uԨ0OI \S{U(tFƖV wku]Jp)@^\JgtߏB36v?2an[ S2Nh.;c7s,YsԌS\V8,JC"w=`8=ǥ@Rd6xu玴fSk)b3F^ gi#?SUnb7]q t Xvr|1Ie] .#0Frc u vzI8>ݾRHH^D@Ա*~zr2rGS)[bV{ib#|rq@ $pkUoc?މ$jYEE'=jTW*]DɥbDv3ͧd8xR'"aZ|GW$i\XHtҪ㑚m*Z13 nշFLqDmqWݎ[^I#%x真JFX0`N=Ýު5YG\zT|lt UcP=@GqVQ[oK.;95rQd/`OqOk t,.H1\~񁻧M!E$im¢T\HNrzsVmz!67A 6YH)23֠HUL Fd'U4$;Zk E0!N3=@R9$!Iɧ(@[jsRei%Grg +2&]c,5&/ےE$t\H3lb/Dp'#ds08yϵX1*Ȩy1Pg [$RMUӶ:-^I l.H*zt"m G5h+sgT*~ʱ>^tsf>&qE}O4#"$8dE1001=r) s(CcRJTlxf6lQE;'Z M?+R`ăh@2l?wۚmJ6> stream JFIFC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?BNmfPRI\q<µ|!i&d4]Ԝ kMbuIu*|T&R 3.b\-sa,iO"$0%dghF{渧X`Xhs|űF3zFjfHpF}Ӿ!h>Åixs?z״<U5csM0tյbKi(SwQg\ 몰[X}ΎVO*`j9O!{iv׏X|T `Lv]~UxMm6)Br3K[xGȷԭ\w֚ =E(ʹjMhH6#KF.>Q)qJR❊\R4 \SK.; .)ؠ W*R\v ?vwAX`HE% p O$PX'SV@۲~aŒ/⚹OB|Hz Q0*pv \r:YOUt1'7XPwsR Uq'RyL7/^@:OE(N SMuRRv B@ Z&JQ+)#)x"oz( mzR̆ 4=CcrCB򑆙S>+l+t)qQ|Su4++r 1wv~#[Ƴ\u#9?7\פ=ZDfk9&z1KU~((Q~(.a.)آLQv( F)QqLQZ(QZ.>4S<׾) zY Qu<ĖnK̄A]*'ykU`б a\Y=Wlyoq]h  RG<8M|n g LjRHd/,T}3Ԝf1kcֲ g|nTE!ؾg sO3w ˠb{.i?TIz`?v5# 0z {o,+]lc_M(+Ɗ1?+ ZΕqRK@WﲷͿҫm2>o>\WR-ޠ{W|O$'Rlxv6pJzN)z<ڠ;ΘXyMJȉ!kUeǜoOϚ2+U-j7 ѻ3DOPOC diBxEdyj@UԶ*ϞbI949>A!s}S RObjnUB [EWrʰVŇ?ʥ/Tc^O4:d>4]&ͱ*N.xYqS;U4Hi mu#~?bwdv TV{csP*9bul>?֛m8qAE5eP a5]U[3HA#|[h˚8J2=#0(YמJ!Yኑ¾L.WQ $Bܟ3 |`3Ke[Y;S;QH>"S"ka*71C"=vsH (겓*(;KM>L#~$Co6O2dvVv$R<Ag0舟qA-"9eVLR5ϖQ Qgm2% }W4kJV&cESܭs.B qR0M":olS 2a{V*Gt8yG*K~&UJ)G>441USӀZ;c+{۟ƚ/eY %y񕁩L`fݰ` :Q,- {NQ!1_4Rǩ66?RV)$1ހy*:bt,fL[MXYWJA"ؓ7< *mf,;aC8j}{2K+>᠘0i@suC,'G;a^ dC;+w('CB*NHOS>1:UcW^JmUoߟ`nr!>IOʞ1IJi _o/?}d R; CMI6u4=| }8ѯ HsrϏVZ.Ӈ{ E:ئ) ,_PiU[_TdfPL6,G]  +Ђ?QJ ylq$~x8\ݘ#h!Sjh{}xa^u#SzyM<"+q֌S,ҿ[x%SH6$, !ϙo_1G#zoO6\r}+=G;}'49hؠSX7T^'Ǯ){vx-j*|>Hlg2S eSbU2H xo&6K$PɞCQ53ݖC6d|M_=YFj:}% 4hpL-"vHz([IlvzF{ȿS7A|EH͐Iɧlht}Fj^xp}&sr ~t'c> Qij9 "tL_HQo{`{kA?Lz54wWVI.黚AcA-i>}E;:Ǜ7сSݟvx V[ִ"/lH?93؊m'zW |bBR\[R r*$F  DI+y2Ha8/uܖpxBlyS(h̸$R=kNSU]!3ZjP\J0֓L6~I@'[Ou1Tt"'W[\qmJxx3\ F5;w{*d T[<\U9,n$d}jhHeUtɿF}cEx`٨dFRc<MP̜!3EcBeR>b*0ćԎŏrnR-'b(֜O&3A"g뺆.=&Bz2ՈDTONqh ?,.jd޼*K LTDCwjFaDoBjaQgo!e"ĐILKcosRC4gf^MI.$E'סe"k ̫*^ SJ_i+4k~%Bp12s(t4*L <4yC 1E@οWPoJ `y&+ZN1%-7*:e zEvFtҕ"}QTtwq/Wɓ=Tt*\6jo4  (e mQT֜5Xa_QEC(GI<Ӄ)*Xv9-߭Re"ӌ+j].dTE`B3Un7QLd122(e"i19p߅<[ۃ#QPEDhv88(tDqT1 endstream endobj 248 0 obj <> stream xYoF ~7btYݐ {(يcԶR+i~$OeKmN:QGGdoߞ}:xĻw9l: .5Ʋ(.,[}tXeyv-,ʗq57ɤb7Ád%3sόPhvjr8_vpGzIK=u*PiLR{njt\HD1i3ێ_gffFʮ}G:G*c-%^3㈀[]e&08çFH_Kx&gV͖DK>8@X$kv,[Ozؕ%D)lI-[.qYBAC$hfH݉ ـt>ⱔZ.YWCqXڤ]֋97ibdo*yYyK-U,IB6%=r:,[_=0)ܒ1*!o|dj>Ż9.{yȽV´%`'LMvHQ%hC¨e >ݲZ+ښ*k/!TAZu}Iuh S)X%ϭkLDK9mxR" vQ$pZXhh%Ui;mEϹ[)(v/*N/Rͻ@P'AˡaѶƤ endstream endobj 249 0 obj <>/F 4/A<>/StructParent 147>> endobj 250 0 obj <> stream JFIF``:ExifMM*QQQC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?(((((((($IkXx~!VpVΨXd2Xc98nF.RQ]L+&553M"ȟ p9g^[Eм3In$m9;U|f\77ekEz_2-(ȟH]T Tla?W-,n,t"+iC@Uۅ,yW1jkg)ђ5E"yQ0 p3NRj[ex;kIsgkn-SiNdL:|+ "KWVcJY!%@iwֈnb2eO0ʤUkb[/-zym/w*D qVNէY-g&K~:(h\XͤlM,V6GJa0Koc7#,4@_WH6[XadP`c`13kj\w\#FdHue %FO8SFvqmiSjC,;B/t[9/Ix/ 0O' $ՐdQs˃s1`#3AcM7a%R0Z'b|:l7;<׎bVrv팙I pVUxI  vezG|s!Q@8\|]:|He:Йei,ǎ@$5KZ4č>İDxv 8'v^5{5ϭa#:Ϋ[(Ű:ʒX˨;S#+bӼdDYT%K2! @zMakYݼ$o-@sܐ 4j<:>y||?"`x bf['K`PI%յƣ$R2.YeQBV2 @e%odV8uqnuG,2-f;74t7\`{"#z<rU$gR mJNm7Plh/273d,3R N:ct/o(tE4K׋x28A㌂f bzUa9X-HAPJ\\nsTQE2B(((+MtϲȿyQhh'''43IX፤5{A52*$qœ8&d//J1:{vF߉ ?2AWuO_΃na#n($~P'SQR]sXzelm`e%Q)nSd^/ZL"C1,'\B@MSЮwHhi;dU*+ ̤+6ZnIkE-O|Dq"H`c-u\w-{晧GZj8icTk:}}Xǧ+<YvNTۜ)G{=oIpqi읅 (],~u!F*Ӡױ~O^(J?'i$O{t4Ӌj}CJZ{H"e}љX3gw@]G'zm6Mwo|&Y0y۝LBb/>PC.%ݬ֐ } B]F|!j61^hlgb4""P"K#s(U=F.⑧]ً"k +c7cbDTp R@uKCQh7}:a9 _Ϻt5.SJ!\ArQD=xڀ odi㑠$1l#uRI[ӱ[6[dh->t$ ˿d0{%Z_Oo{IbdaJrȒKElg{GFIbT|xsɣRι?eRt:psIʮF~lj<]n?^}K)vTef WPj=~;cE2 ;T[ stwFWrɻS{fShϘ|ǚ-xgL 6g[Iy*`[2iumisb©F\/.R 0A#V|9RIo_D^@iGJ6p_*FA*TX>\7 ӾHm)qWGe,G8nbk{Lj8UiܴeUBpᔠی㑜a*O1ϦGOǧLn1Hbag o]n I=S3δ]>p/tURYnH?.X8V-Nƻδ?2kō&(-p{ ȵPEܓh8MĀV#? +Ս$߮I_в+y>-"kx-H\M>妟?ٯȖ Vxt~s_],qTc&~NKSf$mFqr0mEyo{ӢEY -7@qٔj1pOFPdi< ynDH!{6mIp뚷=J -Ry[Gj4QmDA󜍸'A6 -ܛi&'8!Ly%TɓNoyS,R Î(.6.tX/쭖|_hI< "qI~9X8$gn'巾:m@6’vO@-d׶v2]G]2E4 ~<.^@~vFP]JIsXGRF6#o bNtڂz;]/~Ǚ5;6!U`e$. SWy{Key+a.FA"7#B0FGj7v\E,-ɔd'!_'jljM֗F&b&p<szZng.[ ^j6~|b{i lc͒ܡ[k:KGfH4Z$cϼ 3u#$pڕ!܉^)y$$*F dsX0xVIUen%/# Sn$*fʾȗ,is[n{1H)LI2K0=8 JN8/!he9T׬'}n2!rHh˵yq=ԉ-M#.Kʼn4{IIkE-ח1M!ڨI2"VZu2in0:+cok3}umjp|l(c+jwJ\IkC$ ߺ'vI#O^dn^ghTx#Ino %l`6@z2yan>/G  H;Y~V4Gw$N"#7s?/R8iPO&{!YCé8گcdv6uyho]yXhQ]&k$p %|0mbTL0UOKO ]%Ē>yhv ƻ݂2@^Yn}]4ؠXh"ie` 8p]O/١#aDL0rY~REG268➒DkFMj>*ӮY۟q5ceV'RHY{k-ݤR$R" q !'#m\nVAjMP*_1z@\9DN&C4ڇYFd-s%9$ `S]4[;;RU'ki 9Q(d, 0m [T|Qxe,&k㐳Džd61d0jwvQI9!m!^ۗԊ4R\]ZS E%v0!w: Sh~Rj75>Ҳڬ3&P˒ P00pQq_Ǧa/t [MJH/ OjXj1:ɹFusG+d$>4<5i5廭ݚ]]H1[f@GF c$N*M&vn,sqiF<0.т@$m}Vk@Β(@o">rc-q=݌\iaL+Rq:$p[.+ZR̞`Phم;ŭѩ#U-e5o|d|9 q?ji6$ad 2B GQiUFeXgyh(KaXk[ϕ RA,䵴{I$Jyv%s*[,JIotΆ6)F䃐+V店z)u[Qkj;pPY]xrMj{l&TUԫ$q= tg&ZǙd }6sŹ]p?M ]XT5+^3@o/4Mbأ|~~8 c$cOզZkYF1(SX,LhB튬w&S (v45.D҄0N㜱!8 LtM֙kˍ:MJo7$M%B2:8jرҼ5.ngg#T$  ;Qh]A򺑵k)Sqm>;xrla $m,c̄- $r2T(-S9$ia]YY\)SQѵK >6.%oEɓX۰y5Zv eqx6:T՗3VW'7ـղf13yJ1%pCp39sG=/ߦf]ۙU`7TYBuNSKHɘno9r;ƴyu'j D$+2n yI?%JM]jj1V]كk,1 Re21ژT ~|xu_Sv Ha$lA}\3rixRK^sn%d ˞@#$tf7ZG 5CnY`YT(q&^)pBz]s*\܌HX%kMFX#Xʁ|Z#D۰+b^~PG_H$mizGu]F[@g  0Bs"oLV~4͍I Xc,9l|:FgnKJ̚➋Nn귐ZwPJ[]XAR F~pZTp(+$Q]ʔ?/$H\2?.YK[㕞E !Q^N<Vtڲ[f֣;gh84OTT(Y+3tU d~ѧW 1@NNYme;%YU5KT$Be6Q n:.GP%ۑf+ma}*Y/H9n˱{g6rƋ# 96DHg,$rORhQhzz}U'G3@`ߴ7VpNⳬM8#Iwwon#X`'#;U ؔq4b1%8-;~ndX~D,rYH6dak4V9j MhX<ONkYo#͟W(=":=i?4kϱhm?: Fc9 f9?$)Xl}8qQ/{(Ӹ5~)ţpS*N?%#5zlZU 2_ʲRz$~A(Mj(1ٱ&C6^r;cUGP:J+q(( {#g$ ӎ-~?g=|33@ntԭ̐ȑQpFFXN o}6wp~ss8JG^_cpAn<Pܟ0 A#&)KXɒV2TRT y$P)9;vtk oWBG,# q޵~{{n ";CF^s1K]9-.a,K1;c9ƅ&gkmI +J63J˲7RI҇^nCuOdȖ$`IM9 ]ӚD[.Yڐ#3#| zy%4[3`5;(H+ %J+Qg#>-@ $JP lI?"i: &֛c*#VPE F~al3 .aa;;f傅'z*$κQjK$m2+ ln&aC:$j06w+98I?P+Ҍov8g+0ZO%t]2&(TG2-SNkJX@d6j52FK4N㊳6:JFe@r-f,'Qugq,Vh: >fm0H θmBe4 x,_ !Q]鱽- 1 '\.S?/]hJS5ϣA pE'4(: pSx?:[4yżS<e G pJ/ )$hD dNCoa*ێ3r[yXY FnS!Rs!펜 x"lWq%#2E"^+Kl79 F-z44[$0)L9`°5Q<*6ZWC#t0985=ALZK+)l%0.)>ew_M jWsj: :Uxz`?zAT{QßfTMfp19q?"B5αq(/K$@^O=S$pǫ;'&,-,#&ќ\Xpc3ހ4}nH+XsQG᚝4zO&G Z[d2=*F6<ݯHԃ b,Ў(57n~?j.ۨ-Xgoi)V{Yj罭*ˎil Tsy#2*=; V_mOI7JX%5#mǓ{e7c۟4ˁ!i3uV 47b7pD&?cL#I^An6_/N[ &猋&>I]5_i:7edC$N m.MO?/ԪLj+.oHwBֱgXq95jĐ"̮E'W#~Lc`9. *鶗H)&S|0Fdumi֩hrD(xO2 ƫcm~g.)iarA$5[uy#,An'#'ɦ4vU֨rۃjeT1vP@r3Rko}to-vikj%euC2g#з夝˜9ZWO4Z{),lLBU 48#+c0}Yɯn-I<)YP.SUO K?sX]B u Onv~Vl1sһ{MNjSGjmFލN3Wi$fDke&ҺNO8ZdolⲺ{f[`rfA[S{]Z4U'tA.hnͫ'{ysHj[I$iqwby[aܠФ9Vv JQY48] U+pz ͣæ]]<[6o8*w^NIcצu [Gɂ0}Q+FN;wֵhQ`m?|U o#ٳ5ux-9f7E;_1h$HVv"LҪɆt^s@M+Xd,0q -v(BuvG!w뫨]iP-̑Ӡ* `x6PԧҚOyLc mw99WW[bwHfԞj 'ԕ6]b{dqieZžM6 *UcsP+":p2,mP+^]KIV['+RGŽ[y>YbDz̆7C9E82Fd}Z\LFd'Kّi嵝Qru2H%j%[mt$D ШxlϨ3(C&u|$M#qj(Anjfyؑ|)N4$eR# 8#9sYP:yn|x5r7dm#$=@H]]b0 9pFs'捎 M [Z_JU1H00;!rj{$]>o/|!|H$3<1:OIiwD-dAܱO%H[J?&.k, W9fYN:mK-Ɋ Buh-YɈ3 ,'h98'r`rh 7s ɀI؈scv$5_j[YiBK(msv; IGK+bYOv1p1,m; :ESGs-ʭfHB`V#<ëiWm%qc\:234eU0g{*F8*T/,lu)}#XNH,Y8FўIҋ6ռ[n*O"!A䌞pM],]ǍI1O7D~x',23#үXxɼ+$:LvYpު1+0cN~\j-d.[[Cj\yU#uP0T4^]g4WuMF)N9 BbXzVl"UC8)PHT;zzAͯ`8<.ٓG'xOB,Zva,o1JOBB1$| i(gk,q[h"xR{1׿$ ~\FtJ4yc08ԠC2Ff"282 O͒sGpJ!N?$Ot r\4[:!~)DK#(qJ\KN'd!er~{-= FbGKoe\_e"8N}XRŌp[$pdcU } =6%ǝɎǏ\A6Y?狷?]ſLP򼥎~II=H[Ɲ .>6N&k'Ȋ,u"ɟWV[dM<*Vo:?-\P *֩*|ٹq}()mW;EdPZ*ho_]wV~m4;\3@QV`$@$3IH= U49{m\+c#)gط(Iʤ`{[[]xI$s"{n|?s+kI -3G!\dgunsulPvM! fpSaR0Zck]KlI ԮkOǒ~_"huZ\X@lI3J3p;kkfxj+5IȩP"0 PA^9jnEy, gbz2I'94^FXH2=?rm+pj2*w%:$w v!Kc01d<4X ;AI,M+K+,rIS3 ( ( ( ( ( ( r'b4(MNTՠG!`J OMOʲhO"FP/X1#`VRG$QO袀*EБPjv&s$ f(fԧ2%hjԖۈyao+g;H:QEtz/L . #>E F3E( ( ( ( ( ( ( ( Ь UL( endstream endobj 251 0 obj <> stream xyfmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm; endstream endobj 252 0 obj <> stream x흁v*œ>Y>p6ml4ŀa4N#^e/{^e/{_g{~mufGd˭bxbWe0~8ۿ/+bZW:3Tb/ D\ld[G_ֹ%kɗ6!Yw}YxohY[ ;/2A2CG;5uΗmR*y-HVG{AV %c[ml Gי> M/[E{=ZY,/{yӱLY,JCL?RW<,+ElcJ- ;[7OStdG⟲| WO!zw%|ew92=oyVO1U΢} `Vb # d|d79n*Vr2-k -cKU9(,B:G 77W$d7#?{g["^u͑q~.w^[9fSP؃⥂u?AP( %̘,zTW Ϗ1)@gnf!hEBX4eeWvlfCA4N(ur԰Ks EiAjkly՗6KG؀I51wR"3&O&HXw}&nӘjS8ArɮET 8 >a=G|6=gzX?pٵp` M238/nQ\CH,;)WFW[T 0&M]t"g3a\O={fTOI(42VEN boK]MȺ]zDao9%<AԢcDlVMߖ0ܧY8D#_ 2b嫂*7*ZXA2a=oK=a̜VgLN,HL rނi)DϞɽ^CټBZ ϱD󱎞3ՆupK\/Y ߘ62jp"!8KbCKƨ0TcIXF?Ȗ7i\0P%O{bbvFg C`1"g$I3`.Epn;%-\EŴD]*"S2i:Y5;mɎ(Jdb#n A\F|\a+g{6LS0 3t%m ~=/e $VՓlQE?"zoQdLh·\bXIwID:+U|T  pc䲹ʱ ά8jq .Dfj;,he<odJCA0[,f!R$;rSMzWi*yE]RyŪ9QDH%$3 Z@H27]IY pt~yA+#\,'. /;Cbm#G|-Q\vlb>oE_/@EĿogJQj<6>dR~Uf&Ê 0Q1i%;ѻ~dA+K5BI"R$PY! !c v,`3۱m:1vR~ƐJԺ=vH;odbK0sޯ_bWu; \ _<+ULE%B2h=0`f|J" W ft~Oo4x貆K$ɪLNىo^X2<7͸#S\vO^A\Lf8NblP,'rg( %/@TT|V8_4ijzHA(7j/. 4 "ϦS׌:3Sp83}$F& Si*;`[~B\؝qrՁ2J_.IM$CR#$DSk?y&)z[FN&$=\zY태>1i9BkH쌴.PF%R@"#V%V"nK[ +c96G֖"YW #[^.QZMj. 7dy9q q_:gU8,'?3k٤XU 1?niB-i9Vh!!5nsNȀ>:.|ʙmi@>p=lo0<PHœ+9L/)ņRg$ܞfj GGF 3ـd4aq,l9}E}$7ү)&7lN}{T ٿ JJrPג?auȢ=Ұ_gQW̵݃ı-[@ U1!Ng+Qr"DBςWv!Z@r2[uAk٢h:CwH~7;:1Xnߤf6\*)|j9ckXGpf}r)Q@Uy]BcgW҉-p ).9_fauа_Bwy7șJ&N [-]`\uCz\u+O%)0S p2[QK`BI&O512Jw*dD3ǭ,@g7Zë I*+lk}ɑg^$vvi5m؆SpnGBlZ|ɥ\/F>*߷:G)^ijg9D p+)^U}oTFkHڲb4z "m0ZG{3mo OpJiƴ&&CMo*-Ihp0.!djvv>䬐[~ lUUq؍\%qU<.71}{r[:cs:)|q$788&G(|rժF֐Kq2m@Vckx)@kNDbL AFma%^= 2[Yy)UaFLH*7(}. kvfލC'R !H&4"gT,,U*4sy- o&f|mlE JZ+YloC4qx9ݍU99Sx#F!? PxjrO\l@odSd?Zs~k'?^ k3!*1챡!$O!.Wp4_BbK =^)/k-ȩNPS@$%!Gm$7DX[KLhڎDNQd4LqY!Kox+4$dRD - [F7Z7j0 P=Yy[mHQyP+jh؃[ZMƽ)!>'Ypq>J)Α<1Kd:J?Gy7#uGJ֊fji*T֌xq0s&?gYx(eyvU$ J,&5KSHO.ŖjY2^grt"'UK+ч{+\h4>=d˩ ن-dt UpQLo:0b:A[͈5GjLۨѝkV'}n~ ȹ5bJcr*;ըʒmTp*%.vec60- &hoP"_`#%p3E3IhUÆ 5K<+F5nQk2e/Y-\O6넕}?B9GBQʎ#u S@mCKLQ:4<962+[XMLU 7uQV]n}C$Ӡ+ 㬖r2 ]!Rg洢Zod GrAT캵l'hqkAK[FQzH> ]GAQ6U«K,/yoS*9DVG:$~e B E.cQ#Gab-B"h{pS6&~mkoQ|,/sd91_#FK0J'cy\Me*eu.#UyG (c8+݄({UtRIdOl+~.ydbFk RYKI&qJ;om "9&NDzX|~\V H1#W `o-~ң%2d+c*'5F|jBJnVG.9cz_F)L*>|PxOU9!F6rӤ5*cT0+^.)f E@DbNNci ́^!!>fOd7nQv4X6d/`gHDgxzX d!Sb5Y 7FoYX=Sy2𛢨M3HL+S(٢~eq;h&TQKLՁEy%񙼠%]٪]yR ֖:-rf:uC\14%T,-Cx/[cpP-JYVpݖ%bKa&õ*3$W8:ŌqyAAEU i&~d<83xpFeEy7˒/]y\f*6DqKR+w$DOFO?ҔQ- 3T:>޳,m~,\x}8gAP*2Ա q/#|2%gwpEA,P eVfa>r9k>PN<2Fl/<5dxeam*D8/-c-%Z6Jjyovް2YI?G_X%řV Čq|Abk.TӍSm3*7Wżi'Z-r9в2Q-\^26\&)0/,WY,]VYJ8&j]f[3)t\,wePشr.іѮpE+ zƧ_m-/$%?XѱB`f}zvxOsw޼2g V`iv̀i9b2pqx-j+m ,{!Nkw2Ga"ZN=ƯG䱆ljq- "FlR$@(4V%̻#i _ɴ_'k1:55&#`klDxu͸XގPe! 剻L5{ygå Z4V3E|M<,)vɇ1;[#sXTq; Y3}p/{6W{Y#uqف匈>5s(;p"}νX[S j>?\b5K&.*ʪvj Z ^^bQd50Ո5:JxrYskۡ{~X86FJ wpcCqvv^1 uؿP>y0S="w,їYhpѝV8!޶,`ÌڎL=CM>?N% Qh* ޵|</Sg|N$s//ڻ-WDKd[$)̶?OJq8DgOTR:DN>$Y0b i7!/&8̄дg'>0,!{r ?UQv#JOIc(:a3:aL«[>PRLQS@4X ۻ?|,fn0r۫&{ d?BNo)ڒG39&qB icg`yUEmx^ŚmkbLnގ=j&E4C}r^mk4' U@y~|-1Gbԍ[4끽\@E2%Y9)Wg![ư\>r"Vl<G+aQe3_BBj,2 4/̠gI9zjt:gE.}4#+5-GvQ5gfdnI`5a6TJ`U$yVUbFJR߱_[ Q[{Z?( }W!Lu'- l8xoҧℊ g!]-qioO~`ƟQqο/|Odež"p2S.<]ҭ"Qu.`;C|k?QWOā7vd>.:qHK=Vߖ{*\-m ϘJ'r~ݬʟ;v:B`S[\Ւ(܃x I:$1}@g*B}7ItKš}ig~Vkug>TnE쫨ps"6Rq3&U hP:#GZ7(<̛5o$9`W=Kx?<sq=[Y@.f821<8Y~w (b8r0(uE|ݞ;gXUTx@iHe,>-=R%zrHK@h#ـٹ/bpcnl"d޷|.=۵.jɣa|&nCb$E~f_/D8|BEJ)h^lxVߨphyʣoi66Ȫ$-'*,ocH2\SzV#|GٿbӬfgc~GH^?Q[FMUI]Bu۶'ʿHm=u2݋2J un_{|N8۱$jb1k &B=[+"g+P=sxhs⿧ݎmli+YqR8IO|{N_1Eۆ[vPÁǓ-屁!p%_Q)bM%s?g OsZ=_o}1͵1Y*5]F&Ķ a|{vS.kŚ gYRc'˵"5qÁHﳪ굁В$}3om-kx¹LW5Ag sVʜL1B҅9瑓$Spz>]s3 gczv93{,,JOU mw~矦_Vje=ρzY/[l\;حÿ)lo$YDλ|?n󊇞1vevS-5oUMzqu[ig93rF7ayvCLt;jPcEko[URuG}yj8Yuz>QB&[offeD,oLG#n<ޗ#MPR>'-+s~F滉Eaжj.SWH^ Z?-xcg n{lT|d ~}@ms޾7U_Oi{28Wm~?P͵>_ߵ='Bns;ΣoC|{g5 mw{ߡ̿}}>qOe^#.~1y\7oĒhM|7]C]cF?uz{C endstream endobj 253 0 obj <> stream x 7 .N2Zۜe~mo6m~mo6m~mo6m~mo6m~mo6m~mo6m~mo6m~mo6m~mo6m~mo6m~mo6m~.Cm endstream endobj 254 0 obj <> stream JFIF``:ExifMM*QQQC    $.' ",#(7),01444'9=82<.342C  2!!222222222222222222222222222222222222222222222222226" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?(( i^II$ lqXZ^o$nZo,K"H9D*a4ROL+=-fR򬣅Yʹ!Y'Ǯ3PˬtwElMOVsUFhĠ,CѹJWsŤ[Q@(((((((((wz񥽼Ώ2B]#,7A88N 7QE)\\prx}*y)7I[-7_J((5kl5+t-ZK d5.jW ,O* [F[ TOAC tXZ(kh#uSںIuV0Ǚ o a2&Y ː "=6iL='Vv]Մ-kQ-c/ G~Gizo4HEufCn]ݹy4[ `4$ B$bmWCKr@@-jwWc%ճH7(ʮa>m~ZՋonk9m'Úw5İ5Yb~n"~=)d./Hd1Cr#]O(#.+fK BfLO%O|.u]cCuhnmEvLdoPn1 $5%-l̩ԠHm{/6֯i0d| PU{WmO?EѮYꗰs-g#Xy+U5 B2ӬE8X&'dnJc9SW pQw],+ԑ^^L¤M(ꊄ+H^x~\#JYHcò .2O495}-ݵ˻8Z+Ҽ*5l-u Qߝwy=~~]+l3|gk`HsBBJ&N漌 +jm7NM+Źvی zTNc$ܜ"0vqO\QTG?E\KkuX.%2$ x9F^S=,j!vM)nqѻ9֩;Wu9 +[ ^Z.id jy*! cmZcx^;M{6'- >c mw(Fn[~'OArFgb3cњ1 0WD“kեު#k?^Rn_\7^4LD-?Pg ( iQ\]۽ն>oj6vj7VbFw#SRX ws%[02E;mR\+ }}o&xb{ǚXd` `* >>rETxg@e)~ګ-ݠ;/V 9G,RoSmF5e(z$H9#4Ow2lasG!f<ϼCmw-v9BŠ(@QEx[6-lňAnU\&8b6y㢚~P_j];Nm&'wR1$SGgYhI'*Yڬ撽:TQo{QiwKtfɶYjOʮ'  ޝ[ݣl); $*7rztⶵOXEy"'MK}N,f$/F@p<$sg>Po%ޝij7 %)#CxU$4i+Rl$ү jn\r#޸=G֏ΌQ嵟v8:$>bj^ɬh1\7 `"9(, CN1Bⓤo״tKXHMí͊-|ʔi{*\5uku86)rHF9r+Ru5+o}zGvN ,_u'噛=7ga]SOur\Ȅ{n4poM+i5"b<%}eVl{[lo9 'IfO# 8R<#prp+o$tƵU{]Bg"l2 ߸Aryyj:.o$B[Z\C,{#9N]P^[_Mt(ڇ6%jlAn(V'w6.UF֒aG $p5To|eua-qw/ 64uĆZZe)%3@eypFX \6&'Ng_?/smVZGAq r qh]bĚvd@ ,RHPIS k8?iyLYe`^͠p9kK7SZ]O6k;[EmEInTV Yv3+=?*TTv{s6xt][I ޯnkhD np~n3 Shme9 yݹĭ<㊷u6`f6RrꥀA֦k]GCэyv2++u(CU۴#܌sψϋɸ&!Z&BYh S3].oXIpR[Jtq\[$Amrx;J/2_O?jz.㻻1ȗݠZ`*6m2@gXeӯ`l?N/m.>EAXuisȩ|+ xĊ:qnsKjWKLl+FEۀ0 -&H2RXi{i^ռ˨#-HB]=COj>=~(+90@8' @Zm̫-B Α',F0uz ֙iVZAc$X̶  +~dn*woyM4NWM{#Ү95%J[',d bHp`f_MJ5 KR]@CݸeKKWUuf`6.sI䓁p9>%Үt),%%f\t=vߐuN RmkO_x|yq5d0I"ux,-mBET1Xl K -X^"]Ԟ8=bY|6~AؿA# v9iZeܲg&oktqG8Vt=GV2ۛU&?eY|O1ĶOk"_ޡ  nN<* ]]+[kuk4J F\X  |\xf&ii ~ZIvܼ#ץo'ZK[;yTdcF;JR}.hM]q 嬩+([TpdXeO-7fCxdU#o%X.8nnZi^*PA>5H!Dr|u=Lд{k5(QZ yQ,D]u^Gk1 '$; ~V *^j`;=Q&d$˰98' h9ĥs%[޻kgZK5ua5m /,jUwɵ)I`Fa_i^Ѽ=*x.L~Yx{+4F5o}I5 XRlfn{l`v~RXy{;F;9[`9w%Y8%mkyֺ&[x\ڵbIV^ mnj#1Q%nfp[/#?`u{y7|jXwgRTw_yȑϫ1F-uJ('?7ݹx]g;Ql;ג1dY[?۲ co\: 6bLj,jh1$ƬQ؎$]ApKV}N/D-ԅe@/,Bgί1s%6pYp3UQ߭GG^]FUI/%ՑH AҫwMdӵ Xe+!vpʧ'(4+w{'u۽FV9&OGv,Q.x <֘,xBLҽetf$TOJok5-y-"I[@3:2{.~$tǚ+ Hxvď6q4(Y!J"NU$ލNw˟=(Bʫ EpbKm#ʮp0+zզzno IM_|.#'ͭKWVqa\]K,vC;(F=p^A ヂ|[7Kq^G̨K LdEoP殥kkhI}CCsx;0NK< jvSXPq,Kkj҅SAopӼ7E_kZԑ;šu7v;ؑd['Y }_MFydP|ݞ*0)Kﮆh}4 ]mwGԓSӯ\l%qtF l>;Ef'ugTd ܅pI> Ѭm}j[<xc 8g26d H m#\O$OZ[t9JW.^ZeΙZE%Z˄`s ydxgOZ} 71Iq[;֖ಭg]cGXMGmơn2Ƕ+gCo%O+-GU d=Lgh*/-KI[+Wϝ}8h`MKQycG&[Ji#CXOtbd%tXV2@a0l䃋Q&BWqRNӍ@1%͝e74կ0BrmLVZHF։Xfkl/u:y$ dm,KzYLҡWsGّq9#4$LP8[zu>&k5i{ qG$o~Ps.9 \vm;Gy^ {4!GlAyNs}NyyWSҴIEQHP@U9fm8 sO޺FrX\GaQ#UAlwI'N}Ȫmc=#kq$kKAr?x 'f;. F Ѱ9w*lX{`MiHR( 2ǜCd @ qNRKcHѣ)5ek2VfDRGbI!]r: td戮mcY͒Y[Ք~;Sg=ۅΓK$JTD[~#Б3>3s4^{yˌm^ť={.5M;PY#.$$op>h}G5vjtHdH+;Щ}HxVx/'gG)roHq|o<n/t_O+ MːєYq\YGDتte9%ΕݷCޣ{y"e7+H.'}%+YYe9 rbc^w"9fA9#unu/i[jeQEF!EPEPcqgkhܬ0v>r3,y|I+Y[sfm+xϥ}93Aw`xlw6A;t#QOq%7wMsepp@ޠL zMgS<x`KVyKr2#DX:z+&Њ8jWV}45tM^ Z{x"dK`>P0R?(4h5BVi%)X1 I7~+oSE]K{7QC.ǎ)Xd,FFe'AZյTNX06;銈Y/N%Λ4Kӛ>t;2G-[V!>@~ycjocm_^%-C!IPm{P :fٳFk-䕈FHͳq!x9)xXY`RLl FUHw`z[]yj)=^u4V?k4ee'|0SWrKyzh~"Rk{.,0:0wP:8-tW+}e :o.JJpqmKk9#%l&#U#R_o WuGihi'D]fNJ%L^4A $'֬t{Wm.HśX (̭ВĂpxP_X-%;=VBy3vc#/i\b1U &6cpz {ٙN.fׯf-.[u->i|/N~=jSEӯu9# Py2wS'ͷ sa"I֭bHoFNcC)iR<aj-Y Z=$Om9 㝜w27lߧboZg|73م@ǜZh6 rb,XSkkT`⡿nk}ZEdP|RK*A9,XS0@~3c*sxѹYI}uXeUcsݜDx^mM6vnaNT4$mJ0o_DiG+3?.WnӗR&&[9TYu Cgۼ6bG?xcj y{)T XHnv3lR}Px'e.F<AvY]vioIQ2 0%I  s%8hks4-6gX-Y!Xy+'R"k{[;i#CY%%1V>&ix}, PB(9'i;xڹ?0/ _G%3#lDBnP퓩-8{ ApSV]mz6u.=.XMubB;n%mҭtďY,qNOAZ=W/co7͇Q,T/RIL(ck*Y76A )D_8ڭ !!qCB.hJwZ[K۽嶎hq,"i (rCEc'$GcaeOou{;$ '`;rW׎n+B3m{P*(cpLIO'T1rFzi%vz?NŧڴGF, lT!XԜZд?V^^\Zݺ^Ug#o>*1}N̗kKG;Yz$@R$Nsv-Y(pdSA2ryAҵӹEmv]]z2ȳEi,i+'< ĸ yI=usey)~|gh@lFE@9+r]{FHs8]A1$`0aCKxPtfikmroV1 t5>{2NGُLD{$PB(O1%Ym"C51k=06R2X2(sc殏Dԭ5ԭB"YV7OPv=qQL&+Edk+sIwa.1lp*Ytb?i}kZ\dxH1>G /r3T.{{= [총Bñ3bLb́@\zE+"Q=#ڎpjAYi^^4 [ `! ci>\`vz]u{31Eh>t?k eGu߿b·sxSXq,h`AW>Y^kjer&Y*@C?yONH -f5iSYxGPc+Dr'~_2EWK]IA"d%XKc8xlhE]i{wY*Ӊs z8'ռO_mZ8-Y[q ;A<ٲeau 7\_-.6y\"Lޠ༬\Ҵ[i{hqw7Ӌ- Ydd $wr~]ƒI]v ?M4O!"]㪲$`tb*)u`K&֌ݤ0[&vʐ3x?:}VCeϯ=}|ֶ칹n,4֑^Kqr KaIC{V u#xd,1b?ttמ R1NXsp1TmsZ1R/b:yz5-SUykRD2*$yNA+k3Am.űB )Vb0d8ԴKkE\mE{$|%0+o^6A跟׶E"  c?1WT=vPomrl~_^Xb3YQ ֓c!\k7H}bM;9+9!+ JzHzf Bvo:Y4biء)$y2 z渼tvSI)J08yETS&'m[+|#U״ɞ 6MHQ_pcnTdxhn:k)1P$ G T=wz:2ku ;T3VPg tB'u{hIo&t{à )qqx AeTۤ2nk{u^ͦhZ>}}pL>FNP_׮3T4-!luhfyr佼I"+8KN㷱=Pak4ދ^\8b%xxXBlB*Ebh' Nzt̯B}N׿bkQtT5 yf{ -V >Y8Y b^Hw$+#9T]mĖ]O[EӡҠ][ MkmvVwyorw 'zKOR֣0!cY(EVU31qkx|]*ӊ ]O[_ [VM6hcH!n260]A,V3S\GlO^Ln`x[YH#FHCNkY}DlIS5imvk@Eh a2m'9$bIt% NN[nן̯{ N'Ѵ-g Օ6s[MT`ӵKhd7O+F_20R58px's}-*f6cv-0SF"*ojhzqSL`R? koW7sk[_Y?X@>`+[jXuN5i˙w(#J]Kkx.%Q L ipňf-3 }@^i[?ftGu2=jٿLy:W*숱uOQ<9ʀ:cMtu嶷}=5(a#$G<'9IMJW]oLJ$ִeҵ8.aDLZ=pOsZv=BMZf~0pT$qqe}2{w2C$7q\q09kjWj67bW,83@^x(r@xӔyϹ66i?"QnI6~Oޣ0 FEt. b9ůH9$9kң6.$d q@5xw:nji b28Ts]LKZ_q :浓-\{kkKwOXxcWb-<\cCPC\k7f]:I" Iجݲ:{ykM"#lSsg/~ZmͫhYKKKqFx`zױ ǝl} W1|Z{#}lMfO8#bpQøN 6ӶO98ey#,[~Pd}V2/ؠ߽āӐ|dq9&vxZ`Kжj;H‘]̕DrLC.u[C<Ϝg`18<|n!KqL(~@z.^xE+h" Ʌq\{9u-3Kح6$Ӆ`ۆb36w+I'= N7Qwm[}߉W]/u{n丕w,I88<j[ky\,W~ =ɧL܁]hHn":FHC㪰vKkk0tM9kIwmoLqϷOL(ӥ f 2Yd~%jabǍ 鞙t=GjAa8tŻLT-vs6T9{ }.{;> 8C^IQH4IE,0mwVҪI{8TI۾nJ6;fk)V'd瞹u^/|9{N˺K73* Ÿv`1kM-O]8* ec^}n짝$ɼ38dۃ 9/]Ғ^n3vDԧKx{zO`T2J21wl;&=v9Cut$eq9.I$MH{w'6Z9!q{5Xoy [Nf=;FĂ YѹּL-+s*"iIhնכG=iɫX-t݅c,c ٵc M#kx$JJg 16mqhZ|ҙVkkeظc ru #XVP$H6ėSGp۷ZɶKoVeN;(ͫmb[mFGM:ͮa CVmv9t9nfЎXY!i(˅pYT @9947sx}"m6GYnlv;ە?/Vf} ^lHm] N+T:c*Z%emmW6 NֶwۥxD<ѶZFu'ixb+asktsq3ɟ`2r@9j.tdJDlm[cƤec$c9Ȟ\'=eko<0ͻH6t=N:Lb9K{5=5j5o~ Hoorb8KE1wy觃qfcEʫw0+?\P΍g_5͚8̄Sl:=i%ŧ ށ(_)[BuxsB=_818L=Z_h_|Snk]vWM$v D?1?>G $3\us*Ѹwu$E}6y-JGtk 0:WiWV6[Cuw5.c )r9|az;h:4>5+򶫷yiN<:leiC8`wm-9};*N4{ٴ[Ag1HKF&UddSCO7w2̂Fv.>8ɨVaeAq崃l|Al8Fk܍XT> 9V*h)HVϫ,7pFJ*.68`jmZ_ LtE&ۄJu%Ÿ[3.;| On1Q%SH6ˎ1?3&Hm/toBPץ94-4Z?$'ckҸwioeV>Ųuo 闷KgEae"GEPgqO<x15v3z6:JOhԧ'#ma.a&+cH''*>T'G#|+7␉YvoTvf啱0oy+ҝkJ_x?}5\HѪn#,h Pq|חPѕTrW=FjPju=Rziz$,?i!"J;D?fgP$Í"D߾_tVUZJSI+ڿuvG𙖒CsR80&7x YԊm]2a.ۃ |`IRO"G<{Km!& ü##p<uzi0Cm)̅bYU9${w> " Q_9kas I k( l0W}/Naq/4&v3sv`۱{jY/漂$hG '%X9'9ugi5Iu[){g(7 rrNHM]mS+ww]^l]h_Zm-_) gC&ERAsrk־lgKi0fv+/S l67E T98灑hMk R8moićbgBc @R9$t0?OY]"b'4Ks"Jxfe`G5x*G +p9ڶ۳Ed#:M֗7ȢO:HᑢQT6Qn AFi2M)'?t6%^'_BÖVz){mڋ{o5avY v}g]dMhY7a[G5} ]ROfZRj^9K KkOݥ˵c])\%[hIYS$':}W:e圳s 3%qʹ@, zϊ['(.2~U0>]YgS}/ΏV1pc6C@FsWk&ۦy Rm^>ff0єDN?' K_:O 2c p:wcԑO4 ^3G %VVF ǽvZxLҬeԮ7+wBoD8 'joubebclJ4"H?SOP7ZEb$pw6F*Wt=d;musgzeށokz6.7z(7\ƌ 07sï by//$±ǵB2pr>/l^m~K{{ZL&F#OI 8.uoܘ,!i|_3zy_9ؑ6y^g5:֟_  z2^F7!!/0~!&Ѭ'X@#!<%] IŹ/5/ mlr,~jI!h¶Gr;[j߆$]5'H`iHU`MU9)5/ )FW{Zk{P~YɢEpG,֖QH@Y7Aӡoj9lbH%#zFGO@H}ֈiWyR 6daZOǂI[pxY{x–Vp+.Q>[1HB_qzޜJy#utTԮܭQ+#j;L+s/әmo<;iqgpNeIgQ AݐqprX_ %-ŏ n<Pz.En>E[Yl@qiem0c89 V5`I{ݟ]ot<NPS"KoghٲRm]c3XWp`G$sE/bD6Dd7/hHCO$(`p>kVky{qAj",I'#~a*>qygjuiYO˵I /@AQ8Ҕc5i/>yb0ҭFK}~֭-ّۜE{Tdr}2@:G(p݌ p@+* G|Q6͔EA>eq$p:WC욁Utv r4csu^rGOK2D;Y˽nm ϟ덡8_ջ[t\:[?O$KjjPY-R%W+,nWRTzWvM`f kw, "BU߆xm,ȚVcۂ&d-mu`aH`1k1]Yv^\Z,S"L *$QB5˳뵵vovG_Esqci%3FcE\cO%fyV擤gh&ka ҅w^ͱ{[TN_OeBӄҲz o)R"Ggc >@t|7u|Egt;[pVF9 y{Kۖ{dq3ߵ Smn*ҡOHK^}.({;\Dn#Ii<2ݮ,,I]bAFO Ji9)ޭ~Hn>o=k*sa[2tňywjQ<saWS>WU5jzmyqDp w3rEIg #nm홣ml",-lm-92S7+ nE 1cG}?+t'N)JVME}^v1!]t>k+MDBqx8' 憣rZ%WHInI(]J;l͠5jג妡 EPqܡ#9ǽY,Z}ȑ.~q#.9b$Z ]tOG [UVrQ|kU׻z~Fd4os[-<˹K ,ʐ=AU/kz m YAJFaU*;)HA$S^.\ ^ U*mp62.xϡƬu "/$so2p@2<|4o@MuaΣeaؚkb) WZi7[Y-?\wӢ=ܐ2&WR!c󍨃b<;imbu9aKCgr6JnާyY]Y6,rKuGSsWVe8 +sVH xaH&"q JK?ZcC*>*k<{[ʸ8ʶ$zi}FxnA2لPg.0F{L:snon.O-; oVy/{TAܸ]MÌFVxRaGCw`|`gNo~;˴s$ I=A^*-7Lc<ږ%YN v?6򧜀98{sEUmRKⰋN֬oWsg\Fȁc\#i繩?i..4q5r7??w#=)mwzձJea,eDV2HGAjj_1lnaV@#Įal,~Pxyzhgjn|ww^C?H5+Ot;WH;w=*->T^%0,WW %s05bmefK- 2t0j÷洵;gh&&HKS`ʗhӺ-)pqouN|웯qΝ~g=] I,܀dm-euH|w"(Ĩ- q)u톣`otKvFQ l\ G8IPAe6m哻I'GS<qYeRv4[TDՒ w&O1vNy"n}\k >\SO][CA0#Nms~&MFmE'b9PhZ\YZ DͅfTg"!Vڿ)SEm:Rj|"omuhI涻tvi1!'gr@xcϷuj{9mmg7(a՘nq֛+j{o%WGw12*#8pq?KY\݈۫6cR1j4AS"7=oumX٭paL|s{ԢUd`+9-ʎ9=u %h>3Z%%ƣ @[`''MI.,]AP6Ҏ+"W^dD]"\֫SH$Y"vGSpEZmFIY/cns 3}YpOh`\ At#wBo8fEXxt)*vOYopNF*}XOQ1hZpY:*FyFTg \U%xL*[@z 7ԒK~$:ؖJrenymw-=j|匱%CG; RC4ȧ!\Ȇ0jLF8 6)<,#~Hc'-OПåRI'Em1VZ Uu zl>~~">iCl[q[=tkV^uוjUl`G;#˞x8x\ ׹"F_L9eyZY]G$1&-X^w;g~jj$W-rNv߼/nxUKDO`4XB(*{㨣T ^zze鷞5-<}-dYI0|n09'Oq [O[b1'q$l' КtzxMȺH(c+M.FsIUm^]}b& ,2Q%Ip_8s[,>tmIa$PaMrpWdBGl#؎qBB+K6  K Ηq4*1[j9ѥi;'_Cc_m.|'\Yj6ZsvWV]۾f irnEׇ&hefI@;}lf&k7Zd6PVŀnBK2Vrik=Z\2]Ĭ΢D#rbvgY:Kig:A:2Z˿2Bq:<0;N+7"' :ydJ iwrNO'xvZvhz$,'u"jlU%60x:-䚇+DabD`3)'5}rj4%;k"2 %aP~OY}߅G5!^;d@zEhqtxhVWSV mZ. ÕɆQOlqN%y>ВZSy?@H4G`>K)dpNdB!C-<[4 IReQЯ`;QKh&f0]0q Oҭ6dlӕnv7aɴ >( QEL?t)=rz.sgUK-sw8=2N#ڀ(V)A*)3X&']FAGGEYi E)2Vi~T u Ǡ֤ ei>BB iHJoo-Ԣ(WsR5?`4>d.xnK]JFe) 䌟]V vd!"C +o0^3W7S2IhWw ~jdv@B dr9 Uj 4H:(W~ J쫙#lDr7ϵI 5n2\-O~ cZX&귡ɸ{tb i1/zEtg,ZnM Oǡ]5α@ X#=1L\*q%qp@Q^gV+:Q-ͬr Y=:Q(BYs'W5ΗqmQ-m,6F+;CXrAǞ]سI5Z'TA'Q~qk6[{q5ˌUڳ3%>h[})QZŭm)\XJW<ڻO,='٪1*c+ēJV w8K@'`qii㶄H3̠{m\|$9M$Gg 2zڙ@K<+!ğԫp$5ڢu=0Q@Q@Q@mVP(w\ ®ji٧R^(ǭ]!WrS : ; cYl (((Z}ض\6\0XQ@--ڑX ږ]bx)2B(ؿ0cPcs`!rr~NfF&* #>٢EPEPHwi4Q[F0bPAIQ@.*epB*Up?P4 .[$2gqPex` ܮ}ՏڍCLNW,ɰ:ER( endstream endobj 255 0 obj <> stream xyfmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm;akW endstream endobj 256 0 obj <> stream xyt}{fLP<%^:"q7X/eI<@1q_}03qq[QK~IJ1E=5;? |Vۈ˴KI wjl SuE.2oc( ^@喢իn2&mMN>qϐ9 0X5tP9VPWSS&_ܲJ3$"%h?J +] Ü5N'o:PD4jbjdmn\(4l^lsHմ::Avvv8_gW\14OpQf)k NGN/^][WWq}ժN"\KB7ayD:166]cc֭KKK7RR`Q$ oWwųj;gGFfQ,b/ 81qadMŸ,]Ű:xb )))2=cjQ ~!IBO xz==]okGkn4h}hӜ8zg6ߙ = lp cwQ<y_sZgjU {f^GW6j?^C'ʜ,$סY~<Sٱv׬Yr9 v? H?3έcS׃ AS0y^0%,33\c0;ve5KKsS ({@f}llr,b%"o|S8ʲ>@k Ei"#9} H!X\3wbjI4lZZ*+_ON;}Zb -.)))@`_lwAMEnlxvZ-hy0J<ˬrސ: lcͥ.6Mh4<0ԫ7^g=tAlF=̑~W<둦|I )2Ì©u++g]BhQu]z߲WYsM3찁dbCumwP X~=Ysi[bY3!Mֻ噐sI%TWǝ`PXfͬyZ s`?3J]F{bby& MMå5VV1gRR<s"X[մ@Ma7fmlkZ ^y3Ї^QKMM ١7WT[s~ww YBNwb@5_RB3zsd|g ::Ls I:(˱h4":;qa1Z~cGWXcT77U,v-N{9IdzPMlBǏeet ZlnR(: ˡ B o'%ݓq| ' x6LϸiO4 _:]Fb3i66be6ͷ_(hiP#3 ͐R"{\y׃mMt| Q2s;xOյv'gü!ҨG K1uCѼ j-=cߥm֮_Ǯ;IN-T_\\;]g>Q#wW\|x.ѯ>5UU,7Ünd7G,}C0#\p6H=s<0v;w^a D|:/x0fO eQ,@0ʵVgA͸dfn^MCMEj$/|%$77wk9і{ DAW7xKۣjaf(E4('N1 < c%S(͸ V@gQ &<@fii$yqq1\>.*0l[ymoUKKg(d"8ɘ]$-4lZrBP1 nc89GʥȠF 7h1E;3 hk믷nir O\[( |JRhN, &̜guxzxx  6nܛN|_fqgA|0Dg81g<5/(=Žgm#BQF6= ̨VD׭ q3p+kkgZ_%*w|0ճB+DiqsP 8F0~׻R6x-ZoiEٳ2IWZu~_?>83k<B8`Ro@]d45䆢|ظ҆6TCЫo&<^0rh3!~x^y乶(e$ |7l@w*h$\۾=ߏ2]Ͻ I:D'**u6ΆݲeK^ےDq6hrrR<>f9ox6 B}))WpwivviZ?e[[%cfanSM l'LI2I ,qW6f˖DfPm j#=6s$Shol(|eƤ=7p:-9<nG=ڕlb<, ,T'n?łށ]o_۶-XW'x:P[`+8юgZ"ٳ|-9/笮#P[˻j?:%#ge=epE‘a&l<رCsl꼼Z [r9cV i3ʮrҲG[yÁ@n"o }I( Li$Ÿ~b3 F <'ZU'lA.H3l7x$ iio8%ob4l%# F]x>ydIIIEEE~~>'Ir .-uI^Lf<׿Ղ | íPक़WȪ#)`jD 99̍us/QYo]-997/ B=MMls" b,a~ ?rHN~nC _6sNJV3\!Yi8 NQ v0/9k"6@_ *33Qםέ{K. &&&Q20ya%G7:[vi8EF ʺc1|ÑRH֏mvxSG 6OÑ&\6=v?Qt SZCII6Sl<z:Qq$ryT&v0/9~ϴR6Ec ̔<Ҷn g>۹={{zW:'""ܖ[vO2ㅺF-Wjў|u*5Vd2W%LAN0\#j}]g4|)Jr(_|bC%]={x&v0N8Q\\v3j.fsPd7o˭(lGnx 9}4}*f$顡zjcY ,d]B+ 켕4VY|v8|& Z]]mH[Ū74p ik~{KŦf3b `;j3Dy6 -^.Gy< S,x"xy&+ H6pÉv/ZPP@!fY$Aݪlqq^iiSD,g(zrrrnCjD #\nX#nbĤ$DL֌gxbAeR`0fūiy4`Ն_m- Ҷ$<:r- ܾv_hݺGtxmF=E$"h@\5ye~jk },oru~~Xđ x)=E<ԝÖ< |ϳGE$ h-l6iະP{y9 DX dg+X˺4Es48Zd8<I> ߎV}65귏 GψI${mȸ#y۶mal"q2 m쐧Acކt55vI椕lqfy8#ԫz?!aqZum槏9s; ju''b1A!%wŒg'%in{}}R߼9}={N+0tHI[O] ĐēHNgC0(>Q34({3bW9 T zٵ[Qwthrr޽[x|˖Y-U~ L/ gKKխΧns4#WnIFua'!hTh60 e ;,_n9!oilk3x "\ y~E+!Ey*q 9fH)_Μ:nò0ZX1o8|ӹo挌t&ed DRq=}ovV2?VK%i-Y ֵn~CaꨪR|6myޛه?E=K噩=~8!O卲ë_")n*,qG'(?|Ɛ$΄=S5F+eKb.:3j*TtBIzW_͝P>~W{oo{]6 cq:lٲYܪM7OMUCl\q޽3Oҏ3G[/u t3|-cOtIN{@uW0::vM ux977zMY]W1{M;Ж[9S[7d$}|xRz4\}<'ĉYLǙ<⋖o())i0Cox Y3jP,um8N拲j蝅`$˵c׮;w}ڜzc`Б>7::62rv޽smMLO餷2:x3asH/D'2֫23X;;utL;rOr培(o 6oJ,7I3e(V38^R O3ȡU9@nbrr3e_g-hMG-y$t65;$7[σl,*uhzv!b3hw;IxV<݀n= Ykx7๨̼\5oT8 "^`3}}.];Tk{AF͒g͔Hz<9C <LSҼQM M`0>`_(θe"]3Albv(,luO;xFĄeKT,gff*)y>'GBEË́{g/$T_I?= hsf\H̩SR:5/-vń7:O;Ӎ(sOO0Dlp3$%27fvÌv?{~/=]Ѵ$}Y:;ݶ6tDZ[%Usf!ժD<"Κ+%38#v,_Խr+2u(vKOIz&]'_qlgHZ~r0mHT0!4ݱk L5%סMA,75(=55\Wc|c/zII7\vMaA]N9'u}p.ʔ-G"~zZQї?Ίt?~x>zs̙34Fj>wk_3ֆI%۝})K>vhj|K/htTTt)+듒_K嬬sCڀQ##]?A-B5Pɓ'ʪ`[l%&hCrܾ˯J Nͽ(ҥ+_ʕ+Wx)yjj fwcԠ2O$%X qg{Ul=vn2zlL|p]?0HfP7ijj^c>f-\6{m7nddpv0!.kg"8 F̌D\Ivt%ϠN\|g06v713.o|i{O˸c&6"-3% .a_` OԶͣmHKnwAffQQ W\^'B3v.B$r 6<+kVQf}O^dyh(:1XHPhQYl>|XB=ϰBn.NِK/sn ^8R3'\B x$j}>{ efE=oTiAG~%'gJb,˖]s>w3C=Q4 s3pSl<45(O|߿Ĥ$˜[fڤΉ{O0V>x( <9?D Qe!Cn$&菽QueWW U ?f^W@@! !D9JBB*+9=Q!@R3`mkzͬ5NTU|ló]=Py*{wwogJG'=,41-Kx&H"n+tlBJ``K@1&eLQ=:##$]qηXɔ:ufRSJ"yN˄`(ty`vvrpptvX^^ӀniXt1p<<81Fض-88qcg$/gb~~Ik_ܑIgSXł:Ԟ8T7:gMNWEOTWR[ƍEeb͛|U$񱯯Y+:z1=a9`hȁj}`#Nn,,54c|NOkpyPZQi uthh犫 br\d`IHb.䥗6F^~_0[Ar3gN:uIsEI2:ǬfP+{z>f.k6dhVwϞ9`sKimu7U1Ҭ,zx/]D!)f.I ~l?vzs<ㆮ:9fg!ii%eeiż<{LBhk+!>?g"]mLΑh::_{]L[SiiǗH]]_*-]8{"8y~NkFC NNrV ůԽ}$ڧh\\\ <ћ$teD}@t6[Zq1h7xc~~=F]ݽEig\v YqQ)p"a7oޔwhkK2I87W9-F# {ϵʬF:?… rք>?3Kڵ iWX;7XXN [+jUTd  f:Um&!7wf-FYSg`"6JW*+?X/}Ο?EkO2܂I#C%%ID^JuxF*HPI{A2gKjX^w\ xϾ@lzZQًی_#Jn;skd76_?A5O w6qyvkrd(i|4Vpl~&3R) V8gDSՉ'&:g _ tZ^ ɇlY%Y6oUUe >ZZlˋoۀgy 2O'م i166D_t:CCC$NQ<<&y׻jvM 60Ԉ Cq>I/JSNi "! 6`6?\U o` HʹɑS>Sxdh G(b5 `jg˖`2fzN3@rz8?88( lyylénl࠹-[0ã1<1ֲZ9ys}2ܼyl+@H/llXVaF^M`$:'4[h~g=#}z(cUgf=Pz蚘0$s63D`%2h6dǹ"]d{%^:^HC๰PsEQQ_LLǾ}o tbbrr2߉[(ql/8Y}x`} orh@#]|e>uͦ_[&<[w .C5*))l:!ws /ey5S5z^aIomb؁.'GeGWR\, <033>9ljF<@Ng+H !NYwZ| ^@LFz<ïJA- Qvthj;:X͛՗):̶lKʩSiRSSSRR0BMJzu֭mڴ͛C7nRV'a'N`m(9 mݴI~B>,).(-E!VZ4n(rVTT=뚂X/ 6YX\\wuHH9Q7kLsfWj>.@pE314 ױ#26*ewӧ{Ftdgsk?FrIoY,Euٹ%%3ԅ!̾|2Imn[955$&.IJ$wػw9gF.90{H9̉$d1Rıd3'aS`Rg8ަ&QTFvnBFΕ&@j~~x:h8x9ZT驊rt}mytZUU^Www<=GqK. W#bN{woz^\\}ӉOͧ(<Kil@XCNQflJc<uq:s\FG_7}]{fWU5-1 iFrns3ṓiKvKM`֓&&';YjNJ:u#{^6kLoqѐhgIg $ي`F^|#W# :8֪Kx`I@fԝUq#Ҋⱘ_vV;;q9%,2.#VC{M?Aɓ'#[ȮbVvǟ)jG3=z*Rt*hN̸{qSv㳉g+kzݬmzU;:HX#"ݻE UFw<<CBhS|Ѯ]R;,8gOq>*U'N)Hxvb͌nog YqE;}-oo|K/m ڊ8!! /',o2jӪǠ9Ϊř]vd6–VF3;g{>yI'dg Gݦ!tAR? "jVZ1NYYHSQVM7Y%5t2:̈"p;,=i

a"C&iObGx{nɱȰI[s0 6p֊q>ѣGG>]#*3}mHk% ̚ɖQ_suիqNpKˇg߈:XS6 f&khhԎozz~kvV8ߠ2knvvbj:9qa<;ݿ~004$A"=2b+n"Rv{M}}UC՚=<^zꆆ_ۺ5jn{ 655quAJ|2qs\1xgSSSSy fP2"\z[/ ^4L S#0ӊp4GLS?aQ:77Z!jʙ :Ξ=K7e#cEz,xwDglk 6nܵq#^W{cUIIIAAA~~ϟ?O:47E_Df^T 9WImSy5>4 $$&9+,J!a EU5ιf5522f\tw7S4,<|az‚Ui\ނwmڿ?8"b{;p<6@~w~~qh'۷Lz8kk*++/3m//).SeΝ,PݽnZ:=11j\ܬ,VOiS},x.YH@g|/+ug4ԍ7hlzJlfۻv_sb$3U0<穩6[y#(پ6>0&6>:Ě3|DDĞPά{\ìXs **/yz-*Kɱ ZJ čdgU=Gu(44,"AǨdt(_?Y I?}3Y\EUwqVMz,,#@52ZPjc3?0ψ(E銒k]()W^()(*Z ՝*+xI2OMM`^oqv:~=CCCHFGG!1O`C3&d\oÇk\,x$SߒJx633k*fglYbo2lE@8|PS=954cܥk7 X'Nh3U:gssBB8 VKF2wgBar#x&B^~6L6߷NYY3j}LƝJOOG^wJ3-9qdw׷`@v25u!-p*>1/}BNPPn'"Meձ麢|h"`?d'&&n׮%n//(niLtg3HÑVXPЄA||0<36zaaa~~a?8?|6;78g8|R%K4}˜ <#.67%bzk.4Q&Ew 3@.e0Zh86v߁s:[^RF1ō'NP30S/!I 2/AA/_y”̯VVV,+.dqV D |С7xxnTTlDٹQ'M3fB^jg(҅(Ulmi֦L_d)Jzzv8=]\F2Gw~(gOT! XgU0Ilޙuuozy޴bm⫯>N^Q+r7t\;ࠣjkE&ED(oJ   6Thx^<(o{ƞ;ȝ>|x嚔h^*rrRxZZ^bͶ+*95׵9C`[P |f>gHza;t:WTr~nr@OI">}/-mvj H՚ˤ b9ZJ_"W t\*6a"Ɇﬦͅk~;5;z .m.{3f*FȘFQOXb""GG`in ;?|D͂g_VE//^K$ǎ̿kf鞻,#?VcCj-3 +ܯ͖[TYT z孛6=ܴI 7Tx"##准ձ'Ά(:j2s6sy ɕ+W:?Jծ*kF=f`l_LF ψ_=rj[?3 m6[.\UE'}(:<766Rv'VFǐQkG^d ?X?rGQ|X,-+Q'JyD)2Vj6U/S Q֡L!p]e4).  %H\^^QYQ] ?ǖ$.9dz0>d>Epá-ILF}$[:==a"`/wݾmPaNHP-E N ♴Vݏ"HlMusU ^`n]]x<#...`G兄E.u~2ȓjChQP BLL8btĵF(g588յ>5EiXHF$ftvwwLMݒ:gEG _7;g7?;xޠ.\8s\FM͙jLm#dzz]nvL8b\sMB\ ETk9r2>.>hozr=2ꚱ9bÇODEK`CDtLMcݻCC%u1dhbNGOl;rХW4Z,`TP@]i+o8~PPSËh~~%3?0>۫ Hf6q<Lz_cǒ͆^Ÿ%Ke*v8ziK%O|bHBU)cҳ-P|||\\\l||ʾ}߽8qQixzEmoffᐟVkʃguuuʉ|:Ɋ.^CU3f:|xP-Y]Fz\4[vc`&Dӵ+{f&2-MVjs!6D>[,>$Iá%O.=9&̛{Mv{jxFlc ^E{`{XؒURRXP\0<_xQTx6"vM_pj( n܇?IJL9r#t朜OȰs<r4Ap"HLAz>.66je  ̿ó[}پ} +/ _]p7 @ eeeDIgΜ)8_P! _aq5wE8n&G&:g3ӴI`4 FQeʸ;v ͌IJ:~Ԕf{ wV*K*tL01,]sSQc m߱#fؼC=㹸taǎ}oZ,?UAnh߈ H.:gSR-.|aC9{Q芵?{GGť c?xۙmnԦ0f&&&gaI 7Ṫ ۪^-Wų>'UU44}NY[˱}V>Vv[Xڙyѓ$ (% +cx||Jh1ibuٻ7&))6!СCEa@K*_}UhblpI{gh왝./WƵ[-ED5`^msUbF[zVEmDbƯ27⢏C-%%e1`R<|<2RO}13(??1/pׇ&'{d nyzv"ϯ9b^RV3:a'IOU\]T(8xvVruJ56syyyuuAzE ae[kkGgL⸮_nhmv2sqƶ,! * b fihhv&EH jv!)gd8'cŎ,oL'^d˖w=TR]@KN#^UW}w#Gt O!@jXXBtt]6?p=RZ`3-Lj01 o[Q4"J_S"afE\(<3l3EJRll8A^x..-V(2JKRY1 ر3Φks}}=L󌋝=m@=C*0,JeXX"##`ӱvנfL^I-Ϧ=*5Y"WA1tS}S}* PW4b]>?>%DI"Mξz#9G ӱDy4pg m8<>0xu"d:9F{Vy ;pU@NDÍз{  zU/W^YyR.7-bijE}{y^^_ +*NUUIo-mxZ6Pc[y5O7<]nn(AƣĐ .0NR*Gs=s>tA!v@X?<;4KYJ_IxHl3,y撆c,___5+XؘM|>c4"? ÿf ʚ\ww_z9W0B +%yy=`n[[[s̓5m݊nGCyQ>Kƽ735}qZ??p@OfoiTvW hHU1ndn g6p {{#gnGҺpEqyO⪪.AT4|SwEV[בG:_vz `r{~!jZPH uvuU 3###l.`ϝ=QEވ՝ױ/GRPc*FG/u>^w%%%2**rX@&V~3>0"9 0q1\ÇcO&vK<KX"b\``cU޽YEEFlyƭ+-ͭ,,Ԧ֦o}W7fxܦ!{BMSbf,28Ϻ.df@ӯ|.Yo[ MVS*t2 k9z)EDҩ9La/pz*niEm3(ڻwoppUHdj$`~qEGo|  'Duu4ϥzQQQ\^U\SwkvDle3RNc>\塾Co3;>od]/gzgPk y/E<HǨ)FQ/xn|;"b|yzן3;=zY0?E5)%-,p- @;s0ooo/$x6{0p,N%1< z V  bcɉ2+;M2L]鏛J/W!}.rу>+RXDIy0F55zCWv$B4.cV~06JoBB. ڊKLIIy@|>F<9qBޱ< 1~2qQvx6WGG. {nF?ZZZemm%e#ck~k)D!õ75:ߣhg#GRSn%eFݰn|x\56Q_vj&)JQ+v˧l99gvtVF-ੂBM͉==r,|wI6x- 6G*Q;Goܳgqݺ2Fgx˻'@>>R\Xʸe.>|z)"x~kS\?ٳ7.]oH@ :BbmL|'0bV_GIu-Z kDP\;\Vlu@~}}E/> nɾ0% 6pZCđd#`@5^6¾m8<5#nÓ gWW\kk<qsDΡo]*+]z= kZ:CbH?ި9VS5 ,-:6rCp2^'_Vi#c;Koo ᝝cHk0$l{ff&PZCCC c3̛/od d cZw76, xVWөJb׳͊bB-n! bCk8zc;o[' aka鱁"L& FV<۷')] ϤP1Ae)jߒA;-WoEE4xcEl^^^̏Y47Osi,.U464ɌʩR9.KETyh]Yal&(h(`BhooommTlTZT7(p %K;y+B4 s_ǏOyI29=1bnj;y\KkH7bll`z:~yT4_&,/46SQ<7I+GE]9p@ ml4L3haU*Gc_ЂAeou+*ɓystyq #h0?@ x=-JɳC+EE'ɐ~4y !YK.qlwuw٦ osct Dq nވMԨftoeP&TY[94OAA8a॔'S:u׮`v~8G-^ ϴS(m5J '%%է(8MXdj4rhDE(E( ݋Q~zDry]]ݙ3?\obqsCCGWنW~ܨ#h< !9.^QO N/S~212NJu1:{, NT-o8 Ŷ? =K0MU9:CX`^#ϦJ")㞤+66vOޢ՘MZP/@<xE!MGFJ7b3݄UU|ϛAQq.i;s bڣAWCRH8 uNtJ>\鹢~wk@5x el,5\Tdj{eN˻G^~}jj gR$ AZ G9WC1(-ϴ`Iz:::ܩ_Y"sk;^؈ 8PᣖxlrFI Xs'( srr-T {zٙL _2&}Ȉ7t]J|91fO7 IcJl~T^%.Cϋ݁?C݄hjGj7R g8ѶG:A 9s_ۿaugVe wZRSS$eHЅlim}wg`` O jY| ק:[aav 13-ͅwΕ:pAޤi2˖/,RONUjJQi c<4ԇI֑/y/G'fycdF6;~2'.XC3ax <==RQo .1cféiF}}L5654FG L/jJOxƕd,^K DL>s'0X6sp8=uajxxx =aLߌFӎuBrF==RAsR'qxƓ@qD9DYu5N|TWPsӛΪȦDͨ2uL4mg:m%Pw--ONZ$ 7 "%GJmɳ%l)T ̰/Zb~ݺj<8::RÌ9 %izz6idI@2aJm;gLfLJo.S([Q"\K<!ό?<ۂfɡ]xBVgv| ayh /8f8M F3_A&V`}p4IdBCC#?1}vgCx3{8F"Qe 1`昳Y 20Οٵd%UUdgPgg'K-dnVމ *<{u.L:E Mz֏\ⴰ`PaAX ~hPZMiҥ}Ǖ!p6'~rk!}||g[xUU[/1R1Ze#הg3YYTR}DxxYMMCC]P[k4^egMy&%(\>[~{clJyWGGo8qIg%fWª  Me.@Tfn5=={n'i3$64 !S&;){TN,84I*FEE׷76j#"$fOgFVg|LL\}/ -=AXMISIzpP,;>?00Ҥ³J+4ܜմu4>H6$<9bc?z(l-!C"#ӛC'NOVRc"'Y㹤( j#y˒7߃nC_)#&qX9 Œy沀eE9޵kgKK XrKlW'h7qoC?dMM;ܼmh犂gEO=cᙠڒ755P{;و}ǎŪW G7:^ :+Kzevvڵ= a9G _gjccY'O350wuu 払괴4 Ɲ԰ 2L}uTW 6נxg`PlҢP\ggxF̹s=uuWLK(33sxxXGFYty֢6 V`xx́B _NNNҟ`f \ϴL{ed#bEFF½F6'KKb\BͭIy.yy\]A7 \ynmmm;{mhHA3¸&W&˲7%^^UPc[60Iy*=ǏÅ)((ѣDz}}}3` PR55pbΝzgr=lmmCEō[G)>#WX,0ώ(^Oe?''aI$A$LJ"_du#-vT&} `%><%"QTy6*<cT[TkfBB}G0cqAQN@ݻ/fecHo߾}۶m;RPRd LVpSvvygk3C*k ȁL/!eep PriC$j//in޺kǖ-ЎHTH<_p ϴqf xw[{lez|laàu|q0-/*m?dRW±fZn3)yv{2}YG) (x111xB~-[Z;h- L&Ea[xZdZ7rnammfI .? bzaKJJ}vOjPOǣm`Ϟm>3prEsd=}׳ΝYi0#l3~ e_Tz^B9duw<=҄hFN9?15?/;Ƙ(Ti4CZ 1v?~|u#rm|G6)F}.w׳\YSssןzJz1y3+]eY_eY2Yqe??:8 m>-_!xe7384tvhe#4ʽgpZhx҄#σ6Rn6"徾!V:+h˹\JT>};}boGN̵5P<2Μۋ=T)zSh.U(V3$σ.\plt@Ѹ"1\4Zvg;ps3fd|!.M eպrÇ_6>>x\2y"to@\SSt 蠥t-Q- 'X;gZTTT嵅F\EE̥aǰaNNNczr~Z@"9"Aw1Z]ʑgd8YN^?>å/;6VO">>>8-ћ>> 6lOs⩧2u?]_7- ÅDyy R)}߰s &4yIi V#`!Y=1aǏo:r\,Rrxj?빌Y>:񆇇>)=3Ŝ_Cٞ swd D>ن0|YYY Xf쇸/$vf= 347/OPM̳73(*o;%%I K< Y@޿߹\ͼ򺜜/зbb[nwSl(%o22p1+xf\4 ˀZcx} DfaQ,Du Sϯ z'$KKU,9PHKMF1"xWh ߿),EQ kJ{P! ZkkȔ֬A~%&-mmBP%G" />R/avդR{q\0A:-?V1򕃀,`qqpmj&KE \]_F.vv`u-536-RN.,D<7?n-N7'fd=j? Z+FÏ}s<38lggg[pp$0x'|WZ]]VZ "XrU-Oikkk=pXI+99<ǧqq< C"\ԩX! C(x;v,$o4ǒ_yvq+͏*a]d4mZZ:Q& r 8UNz M *<{Ǫ+ gp:}:4x B˛֭{xjx{˧aA,-\D7| KAzzZY_ىhQ:&>?ߣX}sPٳ\RWUUX[+,Й7b[l% gˠx'gfncDʊ:O$ (Fպ:=aXQL2r: wŇON%#VY*\FlLw9^X[[1Ǭ*'&'{Wbo,G?Q6q8gWgR Zw:v{F+|=⊊ڜ;:tgAaB`d]T ,l5i賟Ո*(YH?0e2Ugg'n`.ϳ%=ZOƟz,UVYY7c1FwedV`p͉]D/a"gIM-Js=\4Ǐ߱X-(==$gee-MoSئ_?b1-/VWgRoRS7 wOaWJ[<70;Ìjqb_gѣs#d\~=0pY ([AA\^]'B"X/_V^ER0Xg5܂ūg>nٱ\b.3q?LIi(쌰Y2ȉhh{÷|wR˹;|P!"gy3l"rKHZZƮ].l lc昚z\[}iƚFoIJ<a]P3WN>4~ sD<4>~ R>uUUC>ʙj ]ˬ'`a, SñZRWOY4lA_axq333wmd#"1GG#:(u˳b!heF6@~4_VC'U'}YKJ(+f>\k(8uJ#JzM‚Nܧ>uwA!guOhp,xQ/ddj +jzZm;y; m B`B<1xaxxJfc*n輞Xϰ%`H=7;aowV:,젅;VpSO4771iii+;9EQx^5ZZ\X\zw5g<IR1"\RRQ.N̑3ٳ< ]<)pHtE /˻ͳP}F;_ pf޽##jG2+ y즵##==/%uFr/??F3ϱ|x)o)ͪ9].<?]fa+?K<<<XXQ` Wjb/)X(؂"Tlh1ϒ,YEE0Pddkii&1Gh.`]w{袢N[[S JaૻW.^-x lPR,wxx|fFM ]74T/(`fx%M3\?4rcnɋ}ȑdB%Y k Kk O{Bzgauyy7?dJ<+ F #";tҾ}f OWMfBB\.KMV7|<=YY=Sa; =m[P(g9!lA$III0e%MQ$(kں򦦒<|ursofO9쳝:$p&I{X' h/w;"7o0ξ>ht0D^rScvv`hHf R3zɰ10>U [ce l9I\+JХiiiњUHH ƖPP_?Y^\,M"e'B|b^i繤Lp.]B>y`b) `lv/&/ GO>z_X^TӵCX${ /ϣP#z<776v}z4&Bo7r)L5.8zO ;t萚KD5ޗD^oqܗ9޽h1( VkiYYqu5kn^ daCLaaBzmۄ덋y&T3&FwZd Ԍ Dhgg**1>`f'"zp # b8j)ii7ʟnM𤦦&<9ޜ攕C]?)[ZZ_X}O>yeeŽ:RW/0¾}ee<Ӎɹcii^b֋L<Ąt8 Nm?CCPn^@ǒoqgllɀNje6\FY^J͐g9ٿsΟ?fz $V  %YP5>1)i͟h :ݩ\"~"?cccKKK_sϘ]xm,xE+Z,WPʻ+ee*62mHxVp~c׮ӿվ,WI@ 9vQ&Ѝ0-$J{ec }r PUUUQQ^F݂L=TǝN/Ҡk j(/r^Ώ) c0z0&fQpzml5pYDoyUU<_\NVؑI3LsM|9@Z|s QQ&ڏ7,Y!x(2{M{>`2q)e)Z^mҒ$.0/9;UEEw)uYyyQeevA) B@Q +湣ŋ>1=HK.Ӡ%)%DzbqΒDB3,yN0‡ 0gt|ñpozgΌ9,6C34 6L$هDE:tkQx&Ob܉EG՘p mvI7<#KM <a 8d2zPe?}e6pY2'ódRBկaQ`(`)2RTb,<2&Bh]iڂĸ""*KK=;;;m1s_&'/lO͍dgޚ4Re O{ai>/%W>a&[-iiiǏ_+" E d o{[vT?qdoA,;usnndJ/Osɹe6ØOx #ܨ3iJJ& `ǰS riO!AJP0xV0B1z“d97zT;qDVH&yV#V^䫅dЂ;w&2 >y8YB09##$kG7!Lko9ƆFl4,j1}9nsIBN;nnTNhp ƲRO?ݞie1!̛75۴ȯm6UW6(<ǰsѼ6G@;v`Ppr0;cjxpa00{}y>{+W8=ؤ\ =knٞXvs\$tACv \BH&"|xxW=|hYee^UI_d,J2亠uɄ[i#LҦ熇ɝFF642innϻ/NLXElg{+.NǓ` `niSwT B:)(@^^TuMC&Y̏={ędgO(> 1 II[M\ewzpmFdP0(ە*GL% ǽZT.3 l e#<_ 3)*Ϛ^z8+  cnI)))Pz+B2Z֒8цF`~ Bw3nu{el~LuА^7ٹ9L bM{wq*d eN~]YH`C6M,uiLqlƫdZ<@9}kHN O$8~ޱmۻ##9ʬGcg)~f<08CZ) Ekjhm Wv?zn_)6Cyah<(Gb-xЃnfsϭIռ/zIZ)&i0|j67eKsJJh{\ǬV_2ЦYgvMNv hHrz%J%,v~w:sǎw!QZ u~"V4HZ)ԩSSxY@o~~>?OQT|$z)e^H/p:=bm8iτza 6<އV>z0VQT^f1fsbFگ.8-zq}pi[QdSyV^il,˛kcw/N~r #?JQ]{fff3\eSKzFG=yi~qn_\L:Ҷ1[_DI(([1l{;9s% `CֱFc5WT!ItL[ jmCy;8ǧ;M36295E̥nAG89sL(X'\ܜEU. OeUE#f^_!9o|xj #D2f)+"[Q-1PS[۵(f, -湫KII,[}W2=};2[%&/]zapk =ccj 9.^%`bqfgAI%e'p YYY>wd~ B`ţ%e.1E3l!gZsݖhPsbINK۲u+̰M6IJD HD\?TaÊia4dk5"p?2/NgW_*, -yzr | gYFN)))s{;0|=|0ktD\\ܑ#GBkZ ?ߕƗꮴM3نٟ~Vr *a9nvxx9MlmӦ'Aֽ< ;ybC`Z@)4=\^ӏ9naG-`0i> /v()ir?e9+:N+1rm6w8Ř&w)re` ^S@1>Z0 r} 9L `L ?OA O۷o$K-]aXrBD1= xҥrM#P^ jpTgI"1-B~jW$ְe?a%hfiZLUU 7#LLƍU o<{BWCFW*+o(LULu#-[;A-xƔ<Ȭtd6lmq+Xky}K/;vTa!#^:ISgY~f%~Ν^YTo =! "ы'.I#N VVREBU6.YϺ^PkӢnwR'&.;3Hi#[)։x G֯_uV`F[=AzQYVU]$OsJc0e)vс)fj~ [~ԅ"&Վj\Q~R]V[ (z{wPPqTG}O_߰]V|+X2s*yvt".:Wf1YN}N_ ">5Y<=QT"wwUID|ly9fyZYn0%SH&,xZ8]"`j -L;J}T#Tqq1LPSAW9eC}PxS.(_Ȇ$;'B H[Wdjuck\\jEc [YZ^})؟mܸiz ,)}0i2dw:9GF0@L5*ja6mZ0 /hzx=2=>].M.&(yWAK0s8&'g.\ٔ//2層DĶr'n޼0. egh2/-ٌ-x!{LSUUp:t(` F%TCuZ;HDQ:j^|'.C-ű,v ǔ aXmzyuj5/o :B-AmBTH ȱ,~DܛB!xB[-T>TkNdܔ~_:~OTBHA[EzLM/CAPA;ٟl۝oUEQ Mu'&Դ'$$,[U"ht4 XruG_9BF* bɽ^)o),,?y$|(go59=˫@oذa-X#0M Zؽ"qhk_٧_4~ O8+$B/CqySV%1QG @f >SPYtOWVjyMgt7~QB()_)=as_>`,͛P6l"4WhùkM$@WPYWs}QM6>|8SWD5KTx>7 endstream endobj 257 0 obj <> stream xyfmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm;akW endstream endobj 258 0 obj <> stream JFIFC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?_x\ڴP:q%ʈ.Cx]YEH]9Q5F5/?=Ggq.`q4ѭjMojض2m]C #Ȯ69m\݋]U[Z Uq3\ 8,mnoeh,iT.QX@qT6mڔ7}s 0jگ}NkVg nGS *}E~ѦTi9=EaSNg4zIu6^5+Mgyq_0TQ;zYo$BG]B}sk<#[0(ݸO>30F7cjJ.'<"SNePA ʒO\ׂ["h33v VGAɌ}  }ZeDH2y Gw=y1ߧau6]JtڂW^f&U^@K6oeRD  FZ9㺙oqK06%&VH )##z& %Z2oG.x[WL課0#_]esε'η\KkxM+_P>x n&|Cyx6G]͛@\9V+\(JږqT5 ~dW,Rir6h7t[Ե-StS\z,n|MMsnnb_XYvfT_VO,5v5du_ʡQ{<:E6oWd8&)\tyI5|ыf݅zh|5F53|GHz-·O?MY;G}Upݑ%x{Yp9EreHjؿլO? ɐqYX3kCڬ>kF'uQF~D8Mz/˜];A8cE=fbɊFRj뱽(M$F{x#U|TG${ѹ!X8#pGz.Um׊u' mpyuB^VNS{[4u{6O%U lv{z|pBqy*ҮE7^[1RYVU5]Qw~![[/P}l\Itx 8^~\ݺªp8+ҹ$`a.bu-旈#O],A bO`>FUK᧓9aO#@ǓՋi.Tz )(lbԒA^XX 2p02ĺuj1}TDiשחP6k?7j϶5F5g_ _ ;Icrr^UԖIU|Qo1GHp~JsWm.-g{y)b`pޠכYIŨ;> %+zt y5-Mn@?Túuqvbe$nr) W|/mr4A|T~X>x=ҺK bIׁWTԢZab@玿b^J`0>eoC iXJG8̀3' ƚI_F<}Ų4D?ĹdQ3~+G)VkeoTaospwƽtPu$Ur98^Ozn%|\S6eH]!O'kPt uC)̅H6+ċgᤚphQw`NA:]Hi&8RV=)s*F3ݏE6BҨH\0!xꍜcC:[OAyN)ڼCJoNMt-3[0lg0Hʫ8R2N'ҫح̠9PzVwIM/^o(Jv~Gjqz=O3G`ӴmPaF@f!=N?5Ƙ rV$U]v)-{'W|!ETjAz:CE#u- Dp}i#Ю㻌Yh#K1f09bǩCm>Q.$ۅ2 ޟMҴt> X&`H?sM>u'(]lc8{תגj$+,6FgэT-/_?MYnP;VCW:ɞzvgt_jB%Jyk=K(VEQ\{Xp"B{U્j 0~>+ (=:z CS`iMӃG=#Svٳ A+)B6۷S]1I [b ^_&yנEjLX'qt+RSZ-Nd);uA7o,%9Q>jmAF??sKH6UT\YÁ_I+é7ʍ5g\8 ۞޿Oz eOİ[]B(8`v}sJRiy&dqnQw=; SڐbTWFoX(5 "hKvf]c9' p{'H~Xbذ_9גKgI6t6\(0DdOzMzSYy ZaݜN69U[ 2./Q*sIiљb!tŽ<|WO@ Ǿ9c|=9vG ~Wx&#b cHKFPpށOcWXI``."v'䓁kXݫ[FxUhFw໋k(Rѹ*[%Gii_٠B-Omi=R@v{ ŝ"HZޤҊRwg=ݙFe7oj}^K&%S,aӵrZ3zPK2O W%%tFܡ}m뷍wvҔU~U-Nk֧hhv|5F5g[?suZ>'YcVlKd_S·Y_k)=1]N K26@qԓԓk< xgKҶipspӡXmzO@+ϖȧ)Y#:5э`RS,\gQiHbչ?ROxrwMY 0osU"Vܛ- Y<_Vv褞Vܹ_~iV-^pZ"r%f;@`ﻯr1^wnЮ g$(<*˸؊2SQ!Gv #]xZΜ֧eZ~nnjƑTX=OSߞӧ!>\@#v9?u"Бn 69&,v _G eo#ǔeiF.:+Ub FztMF @.Hj^nom^,pgG^^tUrG>nuƱCJt%SJ˩7ֶYDcrɵZOo+b xi"pUYOϱ;{շ\}{խ)IOVzъU"I2!dVn v_u<%T`d&}"ݯeR`q*aX9-j>x#Pv朓,Y<= 03 ^%ŇgQϊTL :&#I {W]{EњdC;UQNDžVqn v奞AxUL8&Zg[߳ĕS5ͨiې[WXXi,ıGspY:H99#$vr;F_Ƽ'/d_=,$%OQ\u̫%kI7KSȫ^l2j $)U wYk1 WVЫ+ P@ڇ'(OfWK#G5P2"[4*8R#)}Vo|A7bsnCNՊR%+UZ0ݭ:e33F^G`QF{5ާ3Aqt-cBϿ_4%y.֑X$D)gW\6|+*qN7WܽסoP{KǍbN{ע~4 [5iv?9(d?> +q-d 5V[nrlpkigI5Z 6SS&Kl+lΊf##AZ0t$\5i<$0'F2vh\GtWk_>hs<:Oǭ}J*MFDr|5F5R 튻5F5EMYZۅ3M2pOJ%= V,4VcJW?E_?w:wEmBHGT~-tW7^ %彤hR6eRQ^]\jM]-h{[o/^;f񂻛`:c˜n Y2-{kKȯ" 8xۃ\ y-J{-ݾ} x$Nx$j5q5虜wxnpJ[[v}+Uch=͍g桤$:|kUɌJ}9p5^,8-Ia@t=l>ƺ4EVm~5թN2JN<0|1$zWD YR;W;I}u$3 շqk᫢YYw(EtmeB麅+ߕdԺԆ4KO絕⾃>岯e=fHZ孏|O#f_ƪE͆iuf7\(h7c6k?7joo!GܹH!]v8^sux .%*Õ6%혰|+??"O+͌EYC8Mw_ ڤ$NUY<7A!PoMY+8dլΐXI \RL-{5ʅ*MsxkCŚ3C E9R1zDc'-b(}SxUM͵mFXN 3KR=͠ʧg89 u}"XO.Um !Rm9v5єx(ʨO=r{~yRk'oNHmi~ ZU6 ٞ:('pk"ek+TWO Fo%ہlzRWė,ELnݸc`ctU/@J\^?e?ɿµtK{uxUfxnp1W.>αKq;1ɒ眎OSMp2c56qNrfۀ֗X+WEuDTreA^W Z)mexHx1E-=YfF?īa5$6 ,LhWE4n|Mre{y`3kTRWk[z9ϥ^ܤEncA/3O8IV nO^ ϯ'R_IjuzŇTfI`qU:Q@V6?W ?( ?)Jƪ_dUXX\8 ++'W}ZAϬFz6FgэYU5F5eWqVͧa3XbA`h(躞pm>U\r>Fѿm.;2Bp +>NY%Ҿ)]Agyj,;+Xd+MT 8]_1SE%S,;2ʣ$Ԟ|[ݮ,uwf$l|}sSx7UյmWP"?0M6N00p15ZxgSm&Ѣ5 ,-~#79*zes<-ሼ9eX\*C Z]EWq*`{5CgҤ[=.-)̶|(V*IO 4wǺbt&)ܵ$;'ZH^-7Va%\cin#dS$sZ7u;dy~v8I,I8c­bͤ(f?bR2?ąjׁ3>t$\b *§P:wJ{ı>0Z) zkc} _A[kVv3,Ki Ș̄dscpo&kw[p,@U| p^d]|Jg/N-̷_[icq:u2ISD:MZmIG@%2NGy}7tZާ{5BHb}K6s܎-w=ݭGi[jm4@]_~ võե׉ RmceBO;c"+Mh$gK@2m8IQ06FgэQ/4@**Ƞ;*O٬1:[K`rB"0e ϡ&uKSmtMZHHe_0"d d4.5m {حpgh#.h^p25Huq)*JSNPzȨ%d:-ZGeH4UrEe=TF/u$lnRU؀B`mn8I&wcg}cu,zM8z 9=#sm֋}5̷SYoⶔD~+m98M=槥i][6 $ML$$n0B@ Fv&MBA,1d(B4fssTͭ^__ͥXEh𥩉fҫ6F1\>֗'Q"۵W&O%qBv 0+OEwo7:PGo9¦p 27^SzOz-nMkm3Ao!ybYBn5x_6|WW vcl-ªP=h܌u/&56fK(4*"P ۝ 8YR:]LoZ_{Y#Imv#\rWz{k%ulQ#Pɨ|e 3[rF4KD$*Jnq@t~5h4RQG{[- p~9>֚&u}4R5ҋvUdR0cg5MoOYj J.lU",aT)Yw|I_ˬUn1DQQQ]ۃހ;x/Hm>U6:χ.mUP5*#30!P7 ?﮵Fw [%Iyg-.NX@< b-<2K" pY#u5M>5EmrC>3!XqrsөDKHX(goxoi ٮ =ռI:[APXlc2O4=I!ڈ98[ONݶ&V_[&[yۖ~bRXai]drG(RodQ[V[fU T(psێNr0{tS\n~'9arGEhcash 4_OO߉}y*Yr2 ޘu9ܔUX&7t8#?!?Ə@ 4s]P{tј&[ǠG)Fx$M%R%]T @9Z_x|hĿKtXN"B)dU=8L Q)};cc^1Ҵ?/''?!?ƛ'}૥xc/ ]x^_̲8gU ɭ@ 4_OONwM}uVl樮ςBx|j>tsTWK?!?Ə@ 4{Z}Q]/ %?/''_x{_@ 4_OOj/''?!?ƏkOa}O_>_OO񯠩{0dMO';ky'fpd*yu^PLs##m8;HVwyw!RA[ScAVQ&g5; 7rHGg;V%pYRvq<;貫F H~`H)=ϭ;CLu6D =?sӚmνi"r~~^qiW4% Sa6XۖV.s3ŷd1{zS^ϭXt Z:}h ( ( P2zRR+i wbU,~p9;NpqX,nDehW<7#aVZR-eb9sJQnh-e"Y۸N3D6ʑYJUs(` =Mq -+H؍+8N:vTq5`@dgg5M?wav27`gh|g{qr8ГsO6O. NKyq}?81T9! ~\qj4":͞$mv <8kVZi {$fˆ+?TXxg2@Qۊ*()JI+qkjkjSّ;ϒy'QS-؞?'QRHf?O6P0͇~Gl?ߓ (6ٰ~O('f?O?aQ?Š(͇~Gl?ߓ ( ͇~Gl?ߓ (a?'QH6ٰ~O('5WE/֞ endstream endobj 259 0 obj <> stream x\[s۸~݈!Nn}AvhIJI NgIsaW^^۬89^}lq|4+YJ\d%y!M}|tQMQU"Y#+T.xv:>*Evv|t5yd))&ǩ_G/G^L"dRtlC;U^zJy%O=g0ϻC#hU>CT.O$QA"# JJ?#܉T?bG6 LgJ1 W1S0v6e*/:ImyM(7|>ʦkF'lSnFss~ylJ9o l\[2ͧf?pt&o%-(l/D{3ieXH甖Bu&=-[WŅw?$ !FyY~E_l8'!ct^Mrȳ Et C; ] Or- \k:q8f)a϶2ζX4j?ba0:upKZV)%o%w`°!"͔}yon ¾-:t2Mq1};۠Z47߶Ц6-ZlUc, N- *<̋.vּX}~;g0% t#-D2$c^W{i&zU9W !/yW%Of>W~?^ɐ`p@| {\),$xs22Axؙg<57!{b1T[Su$5"zPi3z8{D͠UDDd8 s8BЀ `d@ܱc|42.A ~̽ i3Q@u:f 7䄣--+ߟ3=49 L`see̱ͱ FCG8WV۹/^s@h-avejh",E.\Cf VxI}/C`SdZiitJ[zκ#T6N<۩ J]!h|etAKdA+qZaePl7s&xG l~qIە)/&e&Oz璫Θ["FS/SDɧrA2_!>+67/nvv sQBؤBP.Et̗J,t,B3lyToo;OtxP8n|]Νfob L_JPLUUL(V! bEy퓪Ԭ'V3mXFT # ]hO}ZZg"^*cu;tV̳bFn*ҟӊЛgoMbeh{]Bd߬l]=`!?X?{ĎXcر"qzT*m*lts"l?a*>՝|U[)\{Տ#Y-Q: r!½adыhO\u' gRiSƷ* +}U+axiA rhD2D$l\\&4;T}]>>aqy,SW3(Υ 嬁<^((}URe4閒5BM!֖/qO_h^ʐte3V9i Db` kq4@$&ck\\Ⱥ5[Pĸ]nI!0ԟd[ ]ra=8w=k^Հ-AsA ='ЃW@uberPK #\sJQfbXrBSbMF1+V,H"FFlRSFGi |oyZb}s[˙nwd<ء!җڐU~E.AJA TB4XYTMݫI.u`g.OX VY݃-1#h@xPK @$/HTճK/;гO+ >5FwQvM}')̣E%kV,S"Ä%m.9i׷l蔗:3p}\۵3lMmYӡu[n seUG[L]Y]dqm.)p.}s 0W;.x΀aV Hd:e #b HY@ĘިMA:dukrlPD /hH(N\h6$X),xf*qhJjIJt=:8#ˈ>*j!?FhBj_[aDaH.vR>z &өTw4byKm3#Y5TvB_]@dAݳ].G Xl%ńMKh!H@r (؀Nޅ. rlD+6T:Pyo[D],B?=Kx-^`jTh}gcgeȶ ,FCLyœ8W¸c:{$ۈ%d,ٳ@=Z"řC| Fվ sU|9]ۈ|nM>1 |#VpXhDE'۬YMPzt"1km J*$>_'vog*i QJ;Az].(G Xfw AwTN>c5N֐hJ'υ0|mZ4Ѱ)'&| 3hY{KK^}YΞtXY[k ǷX1x4zXȑ1 :cM%6qXGc kWrX?͗VM}՛v"uSxz^ tD'E` 8w./Q !훋ҼO`AĞүYw l2` Q3u?oJ endstream endobj 260 0 obj <>/F 4/A<>/StructParent 148>> endobj 261 0 obj <>/F 4/A<>/StructParent 149>> endobj 262 0 obj <>/F 4/A<>/StructParent 150>> endobj 263 0 obj <>/F 4/A<>/StructParent 151>> endobj 264 0 obj <>/F 4/A<>/StructParent 152>> endobj 265 0 obj <>/F 4/A<>/StructParent 153>> endobj 266 0 obj <>/F 4/A<>/StructParent 154>> endobj 267 0 obj <>/F 4/A<>/StructParent 155>> endobj 268 0 obj <>/F 4/A<>/StructParent 156>> endobj 269 0 obj <>/F 4/A<>/StructParent 157>> endobj 270 0 obj <>/F 4/A<>/StructParent 158>> endobj 271 0 obj <>/F 4/A<>/StructParent 159>> endobj 272 0 obj <>/F 4/A<>/StructParent 160>> endobj 273 0 obj <>/F 4/A<>/StructParent 161>> endobj 274 0 obj <>/F 4/A<>/StructParent 162>> endobj 275 0 obj <>/F 4/A<>/StructParent 163>> endobj 276 0 obj <>/F 4/A<>/StructParent 164>> endobj 277 0 obj <>/F 4/A<>/StructParent 165>> endobj 278 0 obj <>/F 4/A<>/StructParent 166>> endobj 279 0 obj <>/F 4/A<>/StructParent 167>> endobj 280 0 obj <>/F 4/A<>/StructParent 168>> endobj 281 0 obj <>/F 4/A<>/StructParent 169>> endobj 282 0 obj <>/F 4/A<>/StructParent 170>> endobj 283 0 obj <>/F 4/A<>/StructParent 171>> endobj 284 0 obj <>/F 4/A<>/StructParent 172>> endobj 285 0 obj <>/F 4/A<>/StructParent 173>> endobj 286 0 obj <> stream xZmo8 AMS:Z H t(q~ZizpH-+"M C3P~4{w1xxz2aل\f֥YDtmNOzzeY4nOO.yEvpz3xV Y]NO²ӓOv=LF,YZgClG꩘ȼ)|]LT>/&:_, @ Cm !HHD]d5 OP貮2LYٌC\VG&RDnO>tp?ם3Taҫ|yp+sH{h;7dfxF%`7 -tٸMw$ ܸWyl?˥ !@QkNpnAtwC@֩l`̶GI"9fķE(ʪnReʔb':H*cn;P  &Τ~Ϙdsƙ`P=ϋi?N )13n;rG Ӥu .&*?Ѻˠh?5Ƞ᝱&R\pzhם?]X&s#-IQOݻKLu` =K5 L5|Tҏ~pɗtubs>B> `XLpFro8ZcQS Y3;G~H84.id_z>h]ˣa".Moȥw\"ZY`"A/ǚ+ȁʗWǚE]AzXmP'$ k gQV%"eɫT|MY'v)0[F)Bqgw۸?7=3צ[V|cFHIlߘ m$ p2Y2t8G/ԨNqHu^B[@eڰ#s:6f>`UyfY 7GSE(GLwm".o? 黌=Uׇ%HL"K! .TMQkrtOHHJeDuby~arwCy6  (QMP/ͬm"]y>c7 t$ڬ)eײ&w  .'}ꊎ#%OOi`L(Ry!dN.]V:U=ɪɉ&7p M螈5?p+W?N҈T;=mZ" :JHAx=|Nk|%FU*H!R&ps] endstream endobj 287 0 obj <>/F 4/A<>/StructParent 174>> endobj 288 0 obj <>/F 4/A<>/StructParent 175>> endobj 289 0 obj <>/F 4/A<>/StructParent 176>> endobj 290 0 obj <>/F 4/A<>/StructParent 177>> endobj 291 0 obj <>/F 4/A<>/StructParent 178>> endobj 292 0 obj <> endobj 299 0 obj <> stream x]M,qeH^H0+ 8Yel$ys8b/[onWYWaa<f3oVl%9JP`#DkĈ3ͨ[0 8+?A+G0L-Pe[P` 2x0P1ꔡ^9A0Xe!2f%XHITaV9+, !0"D0p ;@Db0Zð0KaX[X6ðbXB0JdD53F GN\KQX %"*GωjXD[fe` F.pf&@MԎeʁjrF8lR`} +B͒7BA >AMs@ST0XX".ܨ pQz, Fk7 ͐- jK)+ 2 &Be%0[3b`FPu7X.4XFR`eA@F0-[adhŰ,(ha24LE:1ɢ\w a /:pb,2]Vw,p dm̶BUMDVR[M`P D @Vh#0G` qh- ,W_+"wQM ~$$ R GHwҌw-- -'(,AB+-'FfR ?- (*D@ ֆ@2!POX8Pfh>Y!BőL4/EzBBU(Gi @)Rj&F WCd$@D!HWL-RJBe-Úe@r裐>X*1-#q!UJD@eJR ! <TH }RE\Q }f>*G-$RvZFaQz:$ZF2|XOH C.KWhyĂJ >N> ;}XVqPmo+%Zˀm#!2WE3|y,-@ygUh"ZFVV2(5VЇb<2BoQhyQzy2å)5BbCn"!zvSJJS2sXϑdܶum}sZYؕ:No N;f*3ٸSqxc}V+L6WƜQfJUq{dc]T>_o&J;%`O _02%3WK3)sU"e[jH>u`9.q@(l}2α0k[Uf| F >j[Uj=3r#NC," ,)s2ە\B|r_eJa!e֢܃Gq$ 7&?#(ɢ=W;+# !d0cT@bt+-g*}4Uઐq0ð*6JQ8 gH2>~./7p UJx%s.J}0WT"}D@Bŏ*t1SH]Ew/R?#!0D4K|4` p|3}pl>*8 4p>g Un(R8wrRwmAN]Rx2+x.LĞ~H*s v8V̺܄-OKGZ)`xDe%υCb;{YXl胕fJBoAo'a&+4 GE@Łef|͖_;~m?W'I7t 7tNSoZ韾/zJw`(QpFaQ 8T嬽0hx9o(;̗|_d h1RJ2Rxzn|̦5nuΚ;k'ZVC2qB2@䫐tw"ީqNw\4pq .JwJcU:JRIusxrC;)WbWyO?q(ugnv.4ua9|Rih8Bc^ײ]WhR&Q')jrGM@MvVB;j5FM9)MQ;j5ٍq&B#nԄ5tl V#7͐ōpbbG:p8NXbQ'rt#:Evrԏ%2֎u" GΉuȱ 9Kt9Dΰ9'>)r#.c~,u9yX͍x"d":rr̍D֑S|jU;!)rJGN@Nq#'.r)N U#DeґS/SY"ґSȑQp9'BSԎzG!׎D GΉ9~B`?r1YWpFTp0'ry2B}N<8/FN'rxm 0fe{gM\r0 99BsjqgT5ENȉ ~rS(+8RyXNZSĎxG !9OM3V2<r"_ڑtFN^"ؑV+8y<<񛕹%Bcqvet񉐧cch}?a)󉐧 d dh wAa)w󉐧-d-dh!CQ{]=d9,,=de{Y=drYN-{Ȧ')rzY/z! !9qgTCrҚ"rSFWpFˉ=d=d!\C.Rr-MWoZzezZڗn+# :qhz\<W[aqq\V8ޗ?ނ>m=XΑǑ8cwloJ~*:XivԷV|~upR:@2l>Z}|]^<>Y?cF;^~< +N \/].N><42 Q#')jz6\FܨѕHG8QиQc')j:\Fܨ)K'j(4FM=)MQ9W5Fh:aSq)nz!RqX;p~ :R'.)tzyVD֡c>}X͏;}ӢvcgcǼرQt;'F.S ?v(t/v\9rbop\`Ht/v\9}@;}ۯ;տ=^bڱS CV3Z9C;Տ%V;Չ0beؑ ;֏fe{cNZ3X?8>ΛVsjF0 ~Փa`magkC Lrt yk9piJhVW8ϩ}?/:osfm؉nsj߅Ψۼ[Z'FSFf/C}ֶX8{Xg'{vv{.;youљ}OP>Nؙ_K^~-ݲ;ýGvct;c'_`g~/{t^ ecyyؑ /?}/[t/vF?vN,-SHǎ\`g~3{t/v c2ŎvvWӟI,rnp7nnN;z%VwMIÊn윮Nc;v%V͜IÚe~X٦رv+f^ު5c6N)ؙ_O^b~=݊;>AceұS.3~%Vӭ+>vn?zGWrqN;N$ecpȣwdc_EwV'Z^#v~/8Hķ{a:0{9n*{n_++(wRݏ`{T\rKM1pwk+j'Vc;%e+ڎ/F4\+/!]^i08RN<>*K0륮/XcjaL2%@Qm{1a{ -̫ 敇.ͫ(^?>;}/ 4Mo1:6aSP¼;>Hn=ޮqm endstream endobj 839 0 obj <> stream x][5q}??Z;?$8afBl3'1~ȿZ>wK:ҥI6mܾH6nYLel6<>fsg ɥ{o^-~6[t|]_l!݇-n3@ 7c .Dr&mFրFڝ(;zEgt 3;3 -bE0x$*1"1S`hiG2Mi"%T@@ˡ RH/`2m>RI- D̉z&9O3`mo zY OY'*{L~o(\g{2g@KFUIIA)*l"$1[҇wr8lB4GRPI 'i}l im>\9#U[IiDG0l #H1*R}aHao"::ʘC+ ᗭ2Ȱ+IiAG%;JIIJc挀idH !1$$JcyUqAF3Iƫ\?IuOfYg !(S86P0VSΪ>h:C T80]'c*>R#N9$ͪ^M 'EW8rb4 Ljҽ=`  6$WYSrHENΞ(Q$%*Ӟ(-$J:C aN^j2L`w%#IdRf|֫4r հPJ 𝺏Nh$!*|Q7(kƑ1 ,($0,P: Vglgg M C}!sԌn&&>9ǤbhIg>H~JL0l:[TKA|  -ї I%IP@2볔~.NY9ЗdquTYЗ R Qfv> >ԱA%YoToIG&"KWȻ%IgG[2:0d:Y6>WG1ߊYkNR-kK@R3YgȮpH n]G2YҾUA5' F(cijhD<U2dJOA|Y$HT&CL„/ՁжTc*e}G$UD&4S"Na&*ѐoXI|FmudB ruhtAՌ > ix>XkT&3G_~Tj#@6fm U:Ie6!IJmDEg8Nm"I,VH&: tO&%lYEs+_ƒ$1/ iHK@* yj HG:do7ouPY{GLdM>Fj F$ vѰAzO5o|LhAc=u#8HN&t ~XFoI*XIa@Twlc&Ԩl͑clNֹ& ,;jx }I<$H_} /їD 跔$@ӉŤ!][Ҝ[,BNhILAʑZ:t6̩$ Cg?JA Fg&EZ.G`nҺ&GY9D@d l B!t֐Tit6.= 1W҂*} ~Kiȍ)M* -k)-8h(ZJ:mfpҸҸ _|ӷ_ӿ׿of۾}NIx;]Bo~ß__~ n\P-:Rښcᅢzڂ!.0`%lN97ݗPf %1*+UǧQ3bcEB=KĤi\G%RO%{7Zp_. ~ncq_EaL+=VoˀE}lʹ`@ٽ-\_P\P^} 5R6jI)̒V%0Kza,iYR 2ҍK[RYRi+nC8ggT[K#dgmͽ䍕D{pFp%/弹Q"sm=9K%%%d/2* bT?=܅{z.4P#Hl}C2 %$mj#>qCn|^hC---p~CB۱sNyR%ӗP>c+#Oi)ci2.E3*_4@mWR;ښ-ni5Y%\.eqڬ:5ק7.s`O g'xlbՇ㘛ODZ$|8^`A}fEE6ٷd}C0<ƃ0ƣ0<%m<%˒.g6ݠֽmdrݮg:gl{_#w5 M¦xaSIX^qӔO ?)O ?9{ޫ>fof\g:b.x~0Ѳs7[bB{fLg۳ѪLhNBgn+yS\ǘPv($xcyd+~q8 .# P;Dm =kai%9lV~-a?ALfO]N;_-E+˪u.ֹl EVu?r$>SΌa2@e}.HW/KpdK`WgDk  KbI-G^ Z,a*YbY +`P`OL>X vCq$$$dXx,n<~_,b5bR.[?yگ鱫E؀uiYA꽣#<秙/çW3MfIюG&\kУzoӣ֢XS;Lelz@yҮ w9x{IFuzbc޽7`e<{z3JxTH*^$/I+rJx\Ro\|iu:urѮnh>̿\5 ?XG'x;ݹ^/{81jg츠c{u`^f_{ "rE"_yyD!,KYCW)d,Sh ^6]u.=-DDD.ı=BH%l%\%*gS9TΦrY*g9kjЎuVE{$6vkKybo^TkxVkp޸[bQK5;jI.byo~"U̵+Y~lznYM]->k5G}f_E mVg6}f\^%B'I0R#ck5l].[cVζr]*gW9Uή_[5 m[@SwedW@n } vjzYZ)F!uė\Cnȕ;>zݥ㍗:&`Q۽DK~ΜLoԩ؂]vb lW`5^Sx|}ԙ3osμ=uCpqIXZB奀#TOpj-vL_l[E=%S7LD0;e|le6F#] u"3ʼ?/%<Nv|asv~4pbOɣnF;P5κlr{Lhk˚S_93'3>w܊9ThN^}u ]C?L]6uڜZu7JĆe=㞳56`#:r,qy}iIi 4\U3rՌ|҉{ s~daԟ5͡R;Ze4-X[ץ؇,zb )׻o'&}]H_OY\+ֽSJL+1‚ B?Q;~Ȃq'i=KF񯭵F9$zIl;cqs {:;^=m'΂߮RN5zQi)jJR)Tc d4Jb_0Im(IuK}Q1hZN"~Z+)E66`gYx |قYpI{Qjduԭk$|s5컦/7G|;@/҂}b/{!Y5NO),ܹi%"R [ W _PXtvvVbg/}K8̶m*Ikx~s"rΛjkE+~/J5"ֈ[#RoH#ֈ[{)VSzl5bD)+*n;!LZ;6/?<ԃ'W.ᮯLd~)ryvL{MKLU΂^rq՗zT_Ꞗ=-G՗zT_Q}9ڊK,}sj.`s/v૰ijYBkβx!^9}HmOWQR\/H#B 1R/H#uEꮋ]9tڜAv,~d6=w_9;MyjnʼVv2+VgY|!oٸ(2#O7>Ĩ&Y|^wx]dtz rat#_ݟĨnbIĒ%uK&M,XR7$T/-%O[f]sX, P;m|=jKKK{iNⲄj:oy*5^~ZYk s(pszkAgWľWR䈭svls sXV63UM9la9t f?(*QZpKWdzw_sh@v{6 (li ({5؅iȮzFrs=[+:f]{[m[hPnq >Ab} endstream endobj 1338 0 obj <> stream x]ˮ-m?ғ`x$Ap۳ ;hN0A>\6쇴7y)%ꄔd۷RJ- n1ti_ ?Ul V"鴭Hзq73IJy)&@/yLKٺi[(ew~!3$tЪ:!T'`NtO p1(ʣ& /j' \Q1* ǂ\я;'[(+sfRu#+ qi?1&+۶oP((4@X"(|Xjʣ&̷)zPQRHEy@*ʣa++AE6R<9UWAG^?NWDɪ+U3 aU@[VUG+ м+HEyF*}S, tWU9@Y)*:fPi?!ƟnXTdtRQCeU(*pu2q8se1fF١`Y$ *ҕsӱ4PmNdC0K5R ! J$tUAYвt֛NUP{_UJTXA W(pUI Uj)Z#WHΟ)m1D!wLr@-^B%ɱB:HBSI(Kɔ.TGVzDE(]bڹ4[VG/KYrrg QR Q3Rk %%D:Ȗ97V`PBUvVTJ_ Ǭo#P!F;RӁ*7n=dRCk*k*:NWU{L*zካ@{US .6hDQK VVt c ;Aq4=#%3@÷:@W3Nx]AkV @8E e8\+:_jR`;~P:5E!$$;AHh,$п8aFԊH,P((eu=`'ۄZ ,"! G![ n QT5b!eЙ V:V$B"A?Ŭ4h,m 2c| 0UӱXH R tDBڱc ,n&zo̍nq\AzJȉژ 5cd~,8L ,wLъ9DR+gAm0_Q ÷\CS1!zF6 r Sj!ȑFǘrLd!bL&UEȧ"2(3@V2ZJ!b-d[f  $y'ff GLҩp6R+kVa"oſa. 3WCsarZ UcXa2 ~_59 ⧈oq<:&岍9kVǾsuzFlTڕ"S0VrOӁoH@EwtN'P1~`Bpz*:*fbw. 4){Tb#Q))DD3,4%޹U'`᷍I;QĽa j \TI55ܫt<(`{칪qD& Z8r!;Yd"SqagUn4*On"rGTEkj~M[Ď"V[ 24td7@P& ;Fv*4aT mS}IL LDpaU\ALSWM4"`4@҄wU~ƺnX.$U*q)̍1/|$vN Vn舔Ef\@nEݓoQS" A"1 SQS0~4{Ԯ<6l3ݞrӄh*&U g,LT$aI?/)vt{hܬK¦96OQ&+ԐR\uKApxPv\mM+tK`L2I h&%)Kkэ6ɜf ap+@t dEp |0EECUtK;jD [W1n9b~ر|Xt8i Lp6[HhLlI4VF3tЅi  ҸݴNK&HîQ _13XlG:a_X:Fn,N0 |Iߩ,OM'3D`g5F gZ,\E/\3O**:< *\Eo0WvӼimifv&FPؙ96+ם>~[.0 Z[S'(|V Ip,4uP00IP\! ?!GBQi'vTGQ$SpCS}1Dpkp -۱::2)U-0I"1;Q[MSԖZBq M;>\97;6/~Hs۷o?oWl~/3_[ KaupCJWT&[V7چx\kXhmpWsoqlӈPqsYMuV3}.EJ.}H?RR$8RZ V_  ]+Y=HAj=H|f9y:{XRuO<w:KKJ>_qJ 52!a޿"5{r ;leH5絛&麏>%9ڥl8z1}>op 8dֳnJ]Îaz6 Wװk5T]XFA~ˮagװkY\Xm}+NE 5vq 4VհոմռUUuնÎ"DyKIĵZm46؁kiE ܰxbkC.,Wt.7W2d7 )xϿ W[aa} ů9*|⋘ GɇY}ȓz cz!+]D4oʅDXqE#~\ Y>̯0ÿF]8.ROaEB}FiӑoqQoWlo@4  (TĀf@(gr6(gr6(g\r1(R-b8^c7ujOitѯ_.!1:ӿO=S19[bZQL+'8,OgέOg}":gx=F ڢFW?h5˯fU *'Uzrnhz7ng1;ߘ.n-<_OHfPzS2Zo-V|'%K5yJ}]9*&y! O)EyЙL!Y,hb4sa\X3,L5 >h L)&̱?GD>_5R3=G_Ɯu{ydy!n#p˛2@.i"r۱/M]Twhj>#C>5r_pɀl@1SЕ鬺Y}%7!cVb;!~8PMR="e=ۭtFbq`v̎C5@ h-FOm6[f精<8,f˂i%&؉6!-qvh? v}Ʋлh:Mf/B<|JqU[;%fh3*>cs}-*qL豵h^Bb uJrJrIoLIQ:Q4 \{|Z8K]K^Ouj}7{ͥ=X]A+z[ԊQ3i:vfP̠y ɶ?ɫ:qwEYXҧ4›Cqamh _)q!b9Oy.%,$^>ywGX|@qϜR, Y Ŏ<u= + Sc}&s >fT#p$i';)u. >)x^9>*.dҼ݆6XKl,b&9eb; (흏9G>a5Lrl~㾬v=eYYE./em;.*,k0"kTJopY>vbW9f[1k#bJkZPVU6m$ }b?.?Qݗ3ovcTQ_aOYEI*>zxz訨?W}*Wqu-<%4;]9ڈgwJk*3zjSjvN^ 7Vn@0~2E6{/=M|ީ4 |e7Ͷpr=N>{ {Z!!}oָ֜$~ #ZHnB >7(\T^ ޫ{/T_бڡcCjJ5*UkT֨TQsy.ex̲9Gױvh=gjGyHL#z$_>_?ӷYm|8y{y[Fhcy/Ι_{j}EB+t]av x%y|u|x!5v`[EjQlE, TjGSՎMUK|_ ;BuDž~6VuЙNUt!ޕ1ʎWʎW^┓Yz3*ݣ}w2|-+n<Ӎe9=SK#3z2U뭫[WI]j'uNꪝU;vRW| -N?m-l{%X?l?\^ OUv*Vu?k0a,sB{u'F#sNd+>o;;M/{Α0Bd#G"n]$1Jb=~L>LE S>[nW1o,>|ܹa{K"-8F]$Xxsuޟz uQ9U 88U"kokokokokoko;;;;;hQFٚĚ$e{0KKKK^1j4*sLoU>dڋq85VŪzXU.Vg%OڜW|o[OYp<_5{%,hL4؎hܗcri2<\Yf'|mrv$gK1; ; ;;z86/EOg3ٍ:hLsQU&G?1 rJȌF`A,>fq´.Lũ̲Y1c4vC6nOm2Ѡd'rx]ӻ`Nv#v#o]7"} Gsg4#7\'+z^FL*-t5n\45>J56jw|w˨Mq*4>woz%4z.鮒yr{z*w7P;k:.x -\,rjvwSI{V-/fZN ^/ȯS endstream endobj 1842 0 obj <> stream x}]%q޽o$D, ȅ46Z`TUs=n6M~>"Y,EH%в.T(,9/>n ^ބ K,IPT".9VGS\JR(#S#], yP(,DKI\%F4'IsML>hΚ(^MG%EG-EP]*(y]g,UIKy)Za\p%'FEˋKYߕetɜGqo<~W8[/Ow]\]Z\I}>WreIKXKK dKp[+N j%diRA Έ,W Ȩ;'+ #M[q%zΒj]ֲ#f#$ܨ1;͗STLMJW.FZc%'b)NT\DhsKµ<߅%⒢i95b)knEޱH%;8Jjz5wi"#-)#;WT_W_q(HIDsUYsR <;C{E%CFR4a$ܨ/~LȌ,*ܿ;fqZF:~Rlp/wL%Wf*7-Pf"iFLf))xnY`IqdGbeF?*7sS,EH,\ Wro%_NIeYr߯8E߉Zd#XW<엯VKW(w"& vj*TTE״[VSekBAzњPn,d-äxkզv[/PY*iJ`} '|QbM)O4kU$ Q4*ݚ)鷒[V}+Y)C)0!gV͍)2dRRGQ!g) 3  ".l87$)\ȲW(UPqd]I3KnNFU ѡĐoqL PUJ1[.O B7hgA )amWh dH&Ee3В;qU Io5uӷjL+'6D:W*#⭢hoEUU WiT]\54/}XJTDUBTo&QL~o{i壊 j2U!#êo5Q "B!m1MĀbqVjV}J)hU(Tʓ[V⢕I˟&_.!~U4&@G ZO0C&fⶢ԰ nY$'SЍBm\D-AJ&ڇ`oI2JnuLV&EYx&'&;C:k$^(#oIVRM'[u>qCH8{'3a} N:ivb ?j{=M 心 RDΦfQjɤ5o僨# xz5TSqYXnݪê;d>nYp]‰ZjՅ|ӏO?.*Ҍ""ۿ1o~=j2z@(<@e(;PAكe=({PA9z2ʁQtɥwYꏿS??D_>B@l<˅ ²|Yy"FSQ-؁bxrIJbdH5Zhnjt^/ A A,hyA۪|HB!OnSW8..odX~fN%e|eutWN`%ed9G'x&iȗ'0dYbyv%[l$>cx`[O`K4٘YǠŘ]l7$$a]ԅEsuEp=Nq,!qىթK=;)o-:Y"zEݓF]oQzQcV)ũbQ牸ܤEB7"qE.dy̞g )qc{usuoq;k9񟊏W\h⬼W_ySļ)b1o7%̛ S?a@9r3(gPΠA9r 3(P.\@r (P.\Ar +(WPJ^gsxw=SO~ux,MȚeA\)1+n+r*;}~?N/8k9Tb [u<g,Wz8*]g ,zNC+~\ۧ[.}`>r>W*SSusNOK];\Tײ<;7zS*'8\ֱZ *IAsNb?Χ U=H{Z}6N=nwzGqG%tTv=]}ݭb iٵs֐򽵤04Lt#moN՝KIxO F=/Sa׉u̳#z=I:Id=9IVMN:5 ΃9uI:? sDkP⧖Rzzw;ݪh~A(k&aLɎW*4Sגs:|Nv4ozPX%p0 7CzigXl5s?B#L<9ɰmUAUχJT5^*&̓yhEd܁jQ:to^0ȥtH?mސҡ<7?qgCA ;5 +#:|z{:3zy.UΪbJ U@ʡ ]FT2BfVhC* YjLֽbpUEB槜/|ZE\sŠP{UA/RXAR=+`U( B*D.XLW&uTF x^-M]㧽Cʠޢu%, {sPw:&/Up;Mv5\4A1bt6"O'<ȧb9GR8a5\4A1LrF۠g+ 4;j8[,c\Bg4r6b=y .Up|F+бrF~׆W>\'82^ D'cr"Q2){B+Vyy8.T0^P7Xw ;P8z'>sSMzݵ?qX}yhxhN]Aj:BT⡠qM;[s6L相^8CJǷQE0u$.g)XW*8%Q[PihlawK?ؓ: i_5R+}&~,7ihsI=bZ~/4ϲJͻ>d:7O :^r0>߽ ~yT ^]0fL#'x T'BQd:tr0C{R pRS=t]^Ns*U=t?Πn (7\ݟMqXsp:ȲT񹃃 y˪$%; xU% szi.t.@ ՗|K3u'ﰲ`5ޮ뤿7)TfM޶qw,&zS9wt>uh%VV٦|=n=ܯw;+GصJ0maۺr5ֵOr[~Nwj8x |"i%ߒcnBy]:}vӇ܅!wgkVYP?Ҷ8ȁ333=7fzͼ f2ocUXz MazS彭cy"ޖ}ָ<Żٞtoaoao`o`ojoۀm]W[oeO][Xo+E֛A|oM!MMMl666c &!k`s ֮^9X;k`;X`l UMJN`goIm I<]I,ܸ߭!w'Fe)&p`P@0  l1b &Y!bYYT)מ}ĕAX7 LX^-cZku98yB+Yq]Ί0BO8o@N+ "vhӊh+=ƴ"66Ҋ+<8흄흄"36vxvx!*  D!mJ` l, Z1BXR",)(p\mWFpBDZIaF^C7s:lAbV9rCAq@$Ar$Ar$8Ł-lq$Ar{!CpR uRp^A `!X,`B0[v p!X.Ӆ`B0_ !X0e>h~X5<yt:+FPF@X y&H!^"L`2 `>'E&"Q!0"XT`SG~XWO v";yP1+s{O䳗vsO|?bƻ??/foŴQzW_~#O>J~7o?o??aI_>}ǏRLy~` ?}>2пϟ?sͿӧ67?ݏ/w~?=}ßǏ`V_̓6Y0_p ~l ,Z`&ލJy]NK򰎗fqioZᛗf薥Y[[`ӺMXr#;vn wAXrs;v?n;W Qwp\_`x2`qi[V\k\o\BgR.| fcdaoV rnTV0 x(V{ycM0{*r_j!*+)Lj ]x[5WXDWoInr;[2-fucn&ZxHn<,G^97NV7֗MducKV7 v aLmȞlDR a#Y(r\'8^ճxI&YS.]\ۼCsf61gu}I< mņ]nL~[9siV(?\/\}}&7ۼ<=a4UK}ς)+\ cR`*)Mq;i$[Xɴ JJ \rGt94o!1G ZA 1-l܄[S3>Kv UDܕX;b뤖 n6\v|3tLކ=+hgC/>gov{b>xv&Vn4qh MvLǒW@*8q%0t?1YL핳(؊ d8ӂ 4#i` ~9yg c>u]F[–1al% >88ufz0)^X`[!(/3p p}=@v {r>54! ޠA F{Ұsz0|=\ 6D+ wi>(}`m@0>+ A 0hC:p Pc7_>}nX+m<nAA!-hSȯmI p}Fx{ 2j  su l0!́灱1t'#q^Ax#U~|x# @"^A q0b/vG?@w} #jʄ+ dlb ; !r^GH2 krYGQQncaP dz=B`QD\=Gs4A/ zpK/ i )Pv,=@}^0 H Aun>`*{ I} @=P^@-${ p}@j| %y7W)S@9,V7HN|b6Eޠ-Fp=hA`"R"|@-/,ঀ=t@v]H@{`p={،&2@@rj6; (W@Z+H/ (}P/->O}[4@*R a=ݴa!`JmE"b9 stOs P@yw>}>H}_@:r pSA=M ePX#{{~>}|>]#">pS_H}2jVt CD@APz }@rs) H A>p} \ޭ(7"pULp}!?!?!2>!( K q  ԟoF6;@HlDWromnFh@!"=;uvP!C䱛ƕJQ2E۶uܿPAsB:Duv!CZص!kc[f㊏!5,$Gf8u!ثCWGvW9P CSGcd! 49ё*T(XD-")c2y:t|:Rq[ǹ}ʏ ؑ /47B<:htvxڝ* #j GãS"p5/@[<.X , endstream endobj 2243 0 obj <> stream x}O0| )q)QӞ8)R!|y4H ϛ춻Xuش*Դna"e>x k]Zy܍`?WW[״'=}מm;(sVۣ_s)ϖfwŏ[o 0Suee]ٞlU$47jt(<đ铋xLfyahNxM8}2)6O,8K<?q'DuuH4yд>?QVH endstream endobj 2244 0 obj <> stream x|\TW90ff(3 ],Qe (w&&d7IQ#{6=l6M4A,ɚo}?g1ȉ4 xjƯ,Pn?1 +~oByn>x71.Z[?nMʆ_nU?˘>yY~a~YudoG{3W̜:#5s:{F]áeASP>`6 Y/H'cJc/Νѹ-Й6!*-_687ךּy3^~[-hqmx X0F.v&bUo46{dd"8#[6G7aJ[mk26cSHc0ܨdI1Sst4\~[UmBVwҲl[Ǽ_J}l&G+SK]ZsQO^O~ڽҩtV<.'k~l3{kdTv , pؐS3N[lJG>ǮQS[{Si2Nup1̊>;SgL3uԙ:SgL3uԙ:SgL3&5d- o>CԉLſg2ӱ((+KgVͦUl vOُ>/ɗ+lkzEfWwBdo} ^yc~vg?#IzP~uznzzV];M JLuz@=~RVQUSWOW'ŲDɲXeP6"VNgUs*k`"`+:ps7O]D^k~&ϗ| oK|'OgkCqD>_OB_ 00{`Ɠ>bߜbM'5epmoLȆiSkL VN0~ؒ1G,.*,1&/ju(0c:GTD,"7F xd n4xW1+o"-)VWjO;2K*QyB, 2`g{c#|{vqţe/)o#2V]9/f1v7q/ƺE>C=X*xV[Ų^R1GM~~AiS_P^]Θʰ•UM]PVX@**"S2FgwZN3hf4Q8oVf66M$<1"_x٣݀9#Z?)LJ4Uѥ2%ρ4L)@ue(:{>c ydh}} VUCTFёPXk##j#Z_7SMg{c>FU>R0e/(ccd UQ ޏZc괗PUErG*#HDEX}>*>.)mfeYĠ (Y3FafXyQHj[w5.G_dݘجxChrvVfnl4ZOހe0`,swD'1 9RbkX#j)VIRR,bKX"b)Iq /YR̓L)Jqs-,)fJ1C)꥘.ERLb5RLbRTIQ)RL"(ERIQ*D)&H1^qRD1Rb#(HB) !p)RK1LӤ*)K1H<)J1@R}-E/)r)E)rȖݤ*ERdHE RI+E)R$K-ER$H/K qRJ.M)RX0Ka"Z )KBBK"I*E?KqDR$ŏRS^VoZCR|%A)H_Hw)&ŗRU/KS)>c)>C)>})ޓOR+;R-[R)R.kR*+R,KR( RѦt^5t.ưk&h9aW>fׅ]@kPnʰ/'ZFh bEBj~6т4:;j#:h.DslY4|Qլ'NTGTK4h*9]C#B4FDp'эKQ9QQiM ;&bz;7ƅ=@cJ ј>rF8\ * ;@azЈpl1h8Q(hX8w~円U!D15#AÎJЀԟ ;r@}fC8+k3'5Aw!ʦκuκeee"J]g:F/Q*K!J&Pb>ODqDA dY,TL5Md&2jȨ)Dlӽzo30l?O{;ؿA`eGo_/bfy39gS> ||?Zz߱ ~zMk u׬WWQl/Zy_~9ggx>m}:˻mDO>< 8qy%[KcFGoW,,ٞKVb1#zyO<<: yzXVْx$>?i]%I-D%-ؖJ _% zx{/^u Uk_Hܻxfm.K)8s|8P]_+6lJo".m1j bkUĥͪ,+mfY '98`ѫ9vj.o1xx7Ugg4YYI8qr_(@iu( VOl&T7Z-[؈PJye攪zm,)ʞhɢSqhq_"r(-F^|-,WUM[Xz?51!mʹAl뀵`5 X ˀ`18Xgs39l`04tS` 0Jt`*r (&8`,PF@1P`8aiP`0@z@Od݁n@W 2.HR n Hx88 pvV 6\U@8X-0#O{;[kp8%W /gOO?oooo////OO''ǁc#!`7 v;@hB}6`+p/pp7pp'pp;pp+p p3pp#pp=pp-p p5pp%pp9pG%"`3\\lc sϱ9?Xcsϱ9?Xcs8=c8=c8=c8=c8=c8=c8=c8=cXcs}ϱ9>Xkcs}{S=)qT 72z1`z|mb[e1>6B]nfw{X=ΞcOԺB?Y],1v@@>2t6{l[/k6G2֪뷼0ޯȷ y|hkÍu\ JY5̦VdDf.;cgiP6 יȉc/Z`![̖Z(egk%lkz_V52Ͳ%+r`-['s۠)deᩝ.`jv6/frLR|rv]yq8UZv# sF]MNv?{=ŲQȸb1X 7v1oY{w[cobi$FԤ^9^KQ ֎Q5"sx/+ X**ԭФntGuoxwiJ2Yݍ}/ʶgiO.ĚXmg;$dXfٷGvnۃ(ۋ |I#=l=E3ءg/+)^֮"*{Vpma?g1lT|+-R_.2Ʊl̊}<wt{ū\a>MXw]ͼǎ|s[>jy9r?S/;O{4gb08=Y3L/ӟh~SIUT SD\NhR'էmNk^IN14^>9chjRFCׁ#K,JHqŧ)}}o1G tg\2%zɨ袢SI=gיx!aZ8e+YrQ_-aZSv.m_XsDd6a0KaʰUZk+9f>?3;ْ7Yy,v1+~o[bSb Ϗ4(7Ƒ0k?ϮW!ΈB1?=3s@NqN04#gxqѺ-_)6na5)+[?OѩK4\5Zm--ߎmٕʲY{6&8&.V\-q@+r˜#*9r#*< Yޝ,/"5"ln֛{͊ٝ]ކ.ڿJk&C?An $' M34Qm&P"Q<=+{,YYj---mlo%6sӎAp&-::5]Iht%}Ncv$1Ĥ4QE(7)g1*ZZT-(#W"~.6qW~„T !EB"!d'B$L2]پf v%$uQ1r7^> ǥˢ>19.}݅E-F%ڹH?O._;͋ǭmsX,x%m6G "׏/p˺]B"6E\3E\3E\3E\3jqe2s^|`J'He<>^Ls ]M({B3Xc[Cʣ&Ym10X -m-׺"oxfv398888mefy-ܗsj_"b{.%e_Bv'^'.oPHlYm{k^ S<ڥbI#&>bO$%N$1G (5'&Xs{v-6z_8*ϙ8ەci}S|U3<xZ|NoRBZQi])NWӬ3s<}$Fezf&ͳy,G#LUC~L~g.wWϧwvO2Gǥ"{Z۞e9#aƇD0`:`z#'&.n U*vWfi%7!ZDN]nȔHam]'W7ìҭց,:794qޤx_q?Sd) Z3dԕc~}5ݔlښ ['(&Qm;R-+"N1EٗQy֫RխVKKZeɶdKml &a 1dN2]35L8N.G@}Ւ&#[R}J(q5hؔT^,u[f[T-3}& f ~EY50Z+Ve#=؛=xӑkkWk|ǧىuO}znwvx߲vӅW>C3hN,r" QȄ(dS& Q p.bh U.4zq!T(4LIӨ*]'{dUNL- >*5v`ơ閉o|uٶ 'v*vEM[ ko>$ڷIpu7pk ETDQ$(r 9 )L9; gZfNZfNZrZrZfNmbNYVF$j-K yyW|}9QTsr5KE`4 ޣ_TքX{MqGԨ,bšVwS}Ofkݕh ?oي^ELR $uc nkTBRE7".6"5Br+pWy < љ]KԛӾQŚJqUH@^-"RG\Hflp$.j1jr)ѾeOY`ihY t{qNY^n+dvNt0PAX(fUQ=XhPi|gWǶf.޺AquZQ,>o b{1)= :duȬ=t̪V gaE?@a ž1Mp&Ԛ 5$,9o#h0ġ)"5rVr;Tl콠pNǧ+,2X _..Ħߚ9bQdN,=4L]ڱLuO $N(Դ:=՜[W\p5_ؔ6{֐i4n\i\Ri_{dxBoԜ; *gJurZәC5ߏm9kPm!B_.Q]84_2%{4L?8{1^)ˑ'r8*b+Q9  Ewa|qZ^d^d^:^1y֠;u򂚆e2f`LY&΢ghOPK01v17b9&LfҀ̾{T+E`ewzf?(?96]}atл] v rl cւZیl r{ :xdڬgJR= $C@bSS`jj*>#R\*eL ?Klg44QT>wx pJ7yJyVjOD:m0~ ؊m;n0X},t!AThXq%Vt$A"AƱ@JMT0+@pB̘(-&s!uܞSG>D1֩'JU. 4 1v*p"`q(t+%,vӋdZ Cӟ- sj-m-Sc,* L-ݍfFG#!}-} zf?f@cT NU*򡍠ʛMbVXv/Z|i_vxH>BZc"RroϦ(WZ zG, ә$*KV9E~6\lE~#;>tX$ǀCk#~\5i.\)9O,[.dl]G p'] F3Lb2,ŒST^Ɨ0-RdX5T%9WHR6#8(Nݣkyxoh}﷯;h_oP(aE;:Ƿf7ܳ2ݛ;=;vY5X!hzC[;v zK6=2Ԯ}EK]щ+(r J1pUj7vXdʞ^|̀)2uc\(&YI3 31Ifu& u5VtI05BQ :Z>U@jӄMEp@l$95_hzFуtJT_uA [Y9q}=]@xPs ԥzĭ)ȭű,Pr;sYC_-EjƱ.|r;dG-ڲ|ckx0_ $ Ig7utNST>do%eǢ**2-T>ɉ ]bRCNna75뿸>q~#[LvZ^Y ܶ={pcuC[Q ?F3ϛYd9d({+29Mũ"!Jb՜FRb2uL2]]5RMRA1G(f!&נ<IJ 8 j`Ω7XtJfF7Ҝ~;63a v{de}JHr5Lfپ3=OC#R"24uA“Dv8LD<ɫѯXeᏭ jx S44ϚL뛈ZkjW=[vI?k >J9^ucY 3EF&:n6'~,& Y4Dtנ#LO^ָ[:r5V7Xt̮c(,ǕJ[R}I˖kFƬ7niw{Dr-+j]f6ҾkU}Hڛ26Pmphs W`6oS1:?;\D,jrڑ~y7adNc*dA|XVαIaڀbCPnCcˆr61 S*&)hB/ћWM%/\k]1~r({Vg\?<\jJu,mww RĪ#,x *hx|kQ-Uݘ3}^Ff A;S6(+qʑe]P Abj[hR5<ϽZzlvHR<;Tvh BOk0J}lXXi<0D+rL9ϕR (BTa٣nas7a6AhEKuexPoio>2dE31_$w5;$;8 }Qr V ez9#5Q eăCӰ D2_ME^l" -1!VY *j5.*aXV*y&V_zЪE*ǒj3ӪTU+[zLg&L;;ҥ뼎O1lHKw¯l[wA sG]cqz),%*5zܪI+6;-u)~تr-ozHUGɲ@Lc7TL ٪_p8:/7呷o&zYr.Yg͵]uϪ,6Mv`_pg|+QJܿjĞw* (4$h>g n5˖8R5>>+&&1Pc ˬGYAx2Ta◇LxZ(Ƞ(:jM!,@1aa +A5"ڶD%(Yw'TQ ۨ/ McûlU2˒TuI7G뻽w;6yqܘϮsx 07]3r .lϙLK'Y# Fob\[L%CdP7՜ `Nq$fJu%L;J6")} xJ"p"`_~}89 ItRNZDgr؈Ln2P._>'>#Zze+n}fohߡ LDWIk-j_4fNI R3jY;g 0̽z=e6*:xV6?|#))=F 2.-1a#yQ$HFg,ّddχdvw*C3<MlkdDH7}[Wdwl^#{Z3 }n_[ +Vn>(b[O:&8 <8r6qFSGC Lj}yֺ<]f*C} 0ʗ𬁓PY>wP!1ұb(uޞ4otrUCTSR,З.̺ ꪗ<;n:R͏aʥNjj!-PB*>֛E&J1YWy)'-*WJ+h]t9. IbͩT*nqW;#P2J'N]_Mr082xhAq0A{E e ~#x7F*&788ŠR#@^yNkhd~-s8BjuJXi)j!0Rfe!Q7^oN;"UB$6v`,3,ʟ+&k)*Z!Dg;f z 0wwx|  g}aCVÛXr66̆@iz5+,|so$bHKiTR*gu*Ehp2\'3Ǣ^3NŨ(H|(uiPiPM#b >9#YGG <~,&:9)v"GQTD1lER@ieEJ5s42Y\bKbDΒO衍hM_u۽q:gȺUQ&@bz hg y[:qLI>KWcЈk`FƁ GBN >A/>C3j}OC,z$CנqhѧC8[iJ̺)uzcAȪaHM@7N8.Z{td%B#{W"K$)|o*FC&:*8k44JW`}vr{S$ &Ј:= a8A14fВ/!0+C/(0P]Y/QlѲ(~bfawXxs?)ՂZ^-ܿv-W-C*W'. '%~Ϗ H҇hED/S(I>"Sc/ss{"Uįpgj8x W|v 6煂?RHPBʟTPBZx` W2H^1hP^I92C7hVgP ,o0@gZ195P{QiVקbEԯ/rKHV&0J[%|KixwBPk#%0D!/L2 IΠZM-Ai :p<3hIBХ`D&{F}iy bc0Y*VtxD($7ہ 1"~r LUM[_M|^W(uL!ր844Z+O)*EN_g6Xz_:3Y-vvK4!q 3af!ht-SYs?Vx~i $/]VoutR9fVA!i-zz8(}V}3! 5 S ӝBa&p\t4 PNGԩlQ'-x6Wί4Rh8ͧy_ܡV;>_¦V"J!1w =*IJQ4'R(IyE,vAVnw)gnW ,׉ۇ@ ❼cm6t6O1aWȁnT"@nHQ t{m:'ls[lJX%'LX_5b@S!W(xQ:74bS 9 Kӂ| =ĪuR[V߬d4PTɲ0}˻3PDB,]7n~nK W<[%6sh3QYfu7I{*⁻^RA.rBy(C0gT`), EތܓMj.Ǔ |&XZ=Vz=^azLw WH ݒ wh}.ѤJ<c>=[10IQbZLHs2fc8r^wGtUz'u@i nB ɣ +$Icv Xʔ nj5йlݠ!rcMNO~,Tlq8^/NM %_{o~mBށ;as/#\Ϣi3^Wx2] 9!Gxe1ghݥigSo򕭔RS0X#x?W ܝT/c#K 0_~"LJ h+.+W~(5Aƴ8!`+ ^0ty.Aw!(2: 6oY&5fc,cYjT:X̱U{e!BBXY~q@% ՏO>R6֢fZVlz(L>HH(9)E_w^M3侩<_Pvƍ(C&O@TDoA)3; v#|P@v.ړD9DcTgH &V96 od:EaiSƁLmNhY.sF)b>b+Sիy-eim:ڂ6fT8VIl:$?.^Q̰>t¥^b6G`:Vo2@k_J X#1lVb׊J LqO}m 1ˆc1}~(Nwo_SD>e!N4̣BZ&N:Q6FCWψ2l[Go¶b4bkvG'5z#݉ax5YnL 5S*^? l')njuzI@֮ز>ݶ~2MSC=p禮kI&LD=cAZN뵶ۦ[+6[(u:sbl$pGS[o<#AWCHFY6n q+sZ-TK|J'wfB}ƚhXWYWazo=˗Қ#u~._L(4ʊg W^|^~Vɼ,ʉƁG(GY0(Z_!Ffw'iF ?ͅ`/ޙ ZiMCޖ\Α0 dS]44M?z7Ԙ헿Uy"(T]&eKۯ4Mz<'f^N̪5Tpl!EAZk;o=٨|u:nvbEwje'Ю'q[80Fnǿ񕻷4ݝ6 $ܒrKh\$˒ de@R#+b"UP}j"ъJ xyD9ߙ>}x^O̜9{{337-k^S3K]Q4vK/YdzڳW\HxX7|s}U_$h1/\4{zy _w'#=V0籂);~ ȧdR}9x)Gp CT4ӹ4ާf\b{p׵L}9΋FߎOI39sLvߛ\&D4 ٷE_VpN]*a!Fǧ1R|ڬXL!cݥ=.{5aPy▌qιysb,2w*_wsؗ|yn Ϛ3xF&?g(@O̡Fa:늳ZlN;>9]mCN*wSG{nLs͕>|XHV5q8_W˚ųfC}"FeFYӘG@-"C΋M4ML;|?9uj-E䥩Ϊɝ]/3fC1Jg(h܀dzc>/vtf~KxsKs^b^Iѣ,5%ԨqwU.?qxj|lbZRDu4pGǦ$٧nZfxMIh#,˙8_r?1g13'#tߵg/˸1M{̽hs|%'|`LȎNl_!ߛ?ux/bMǧ<4g L0ɼ@q_XS9քaic3-6~&'[˱!16eҨClC8ؒFy%=O|yl!;yBhNL2Thۅ8IF5Ms.*&MSh8X|Ƃb\[ ص@K|fyk DF/gǻi}=. r^l\e^N;/YgR~थ &V=ɖW~X5;CK/sg%?v\V0r첅E[-^۫ b\IIӆ[yk.[qky\܋}3 "?TYv]t O4zwu3:}]/YƞE G)\13Ǐ;k+y܌G\U:-ges+ΚY޴hQ#g/]X>cHz2":C~Ke&]%^J tۿc)#Sb2bȐBUPc5&)1 xWkmf))e+b[J6y, V\ČtӞ$;ٯm?q=lsƫ#JDLVQ)ksb|'v΂PF$_D.a"Ϻgx7-k?I!R)M_d=֟&"mKξG񅑜O<3L)vJ=).3nGozc0Ž#ҏϔf&UjzJlϐ>)y7dJiL_gNO22['镯K֙҈[G{(17u4}ҫ2iSoL{Cό4feҽcL;7񅙗R֨Cّ L|cImnn46Ҕ4`Li0 4`Li0 4`LWfɿ`\˘LaI',|6 Z-%髡ahX63B;WLKǠYBzCJdԧ? B#{FInex6NNX&Anz!>dI(B+dA>׏@}u*yяAסMd46?zڎ@PH#Fy$oPG4X2ffʷ֝NpxEv<2Iu&D~-|)i&vf’X&,yJK2at vZߡ2,h~6Tr$"?@sh4Y`˂oBz'|%y.z 4 7}ZJZA[Q\76%sїWiߡ\P}ZHi} ii[)!W{iM~+K |Xx?gáERR|yk:h^êAhڭa1r/P*z|^E߷>]ͣ"|)Br&\ڟBbD9h abdF0D~h0v+iWנM𙕨MAR'hh헡ٲ6v+N-X%PveIe_KNh| EBƐ ̇Pu&],9AHè<0jCQ>b1@L[HhM;J}t/;;]ϠЃz09ЕzD#Èz(o`a5z"4s}5+ c.0z.4!^ -%o,^_UH]-4hZm mF/6ZNR 2ߍyFcaX@CW꿂ӡlCw@C$BjShKIE7"#PԅXA/Abz}?T"BrM;JXA/ds3<"E6tӠ,! F ͂5Z/%AqlU_@avںF.t"R5sF$i$oo$?oD&&鿁f"qh)<4 KBfh: Qbxf_h ~m mo7fmjJmЋCнS5j>? &m Tq ЕZh -giPi@&3h|{KlBOF6IEO?*.&#h:oB/ބN̩MUh7}`CC_S ߀vǠhM* +TR TB%*Pڡݩ|eh7ouл i3i 4}ݩS=uh~zPˣF=@R J@g8τ-TC]fN?#ZohP>? QÆW )F JŰch1K6^1ZN[1Sx1bàlG(((((((B C~`kPԥ?MӟC_C[Hi}jϡ{wx=}ד%dI=YROԓ%dI=Y@%dl TJ6Pflڥ6cgЃf o2-TʴP*Bess1.N|^*. hlŔom!m58[vbdsbsžb(+C+p6c!!aS  ;;`(f. |vww 4 G՝Mj;ߩwm'Z;QPT) (IDB[Hikv d.n҃NBKh< AC 6UH]KF6h:i6fblyiC%t'NȆ.ؠB)ECE6t?/Pԥ ڌ}Jmh PiH-FCRht܍~9ŴַyMl_ԯnnW7U -q4E븖~uV*.Z RiafBN[;Q;Yk:ḥőPK ?.gb9PO4C#F65b9K| ZJAaAh^(JЯWŰDC.1h7’~9BP>߀(N@P6<ׯQM,NzB4NZ쐯b*ԯ_66S6ZN{m|~ t/;]8|h "A.fJ.WApUʡa6\IT!u黡ith~YBN[;`IZ_-$================ #|/B1*.tb5!R[H;? i귊rS&l'f6;ͼ#f^$3+ceamY#̫l;˱;yqo6Qfcǵf>_)f:߁%\q+z78y78y78y7846 WSY-a~VB9ȅXԋ5~jq,Kn#K.UoJ7@}(y 󣄟yul-XWKی@?/QC#6 A[L=j`}ۇFRgAMYBCMJkd뱾њY1Q-Z`diXдkjUNH? dAal4 .AY/ڏВqw< fF+^kخ}3z9G3jC9y3_E"oXk#uf0#1B %bm̀~xs%,Rf9h䖯ρz9~fYlxz'VA3ͽu_{KK5Fw.DJML';#HA#iS1kϕ#k%ckY/gR /i 0;co @ڨ1\C:-Gm1描͉ V%͙3k,˲zb1m4 ,*R9SNnl%GJzÚޖdUjj"dwD*G@e{ވUK=58{05f|F|=y^=/{S[,Ym#}s"s94VAmZԳ%P]nmD;. y#mA ]_W kTB Us_5VS jaomXvZmh6#Z~M$Pk}uaE#U5س֧UօjBmQD[[ԇZQkD^RS*Uւ:-F@k2k,.Z_jkbHvnfomVYvG~-E_B~t;zkl5Ú #uPW mI̕ \R> @~O+f̚>z$UxCe5}rue:^ \X_ O|UHu$ݰaCNM~9(i ֭ yՍuYTzzYHpArTjHO[Hf ~⯿2Pî 4 YC~DHv]-2?AY#wꫪ-1,H_iKoMz* h.+DH:nCmۿQ5,`,3`}ULuU xZXHz9ppcuvG ydfu\oY̫ Ƴ/b!An].Yv⻖OLw-՗BJDǒXKyH\d.Yu9bk5"u=6VnY==X`@>yѬŚ_-+|-OW4+g;y1|+T[]Q0`Wy%ׂ`~w}`? /[`~ׁw%|<<0_ +| ׀y_ `揀~0 `~R(q`>Gx0`̗̯ o|? /0/qLJ2k`>b0.\a`>̧0Wz0oM`~%ceg`qUͯ]`s`~̏ImIŖl0r0_ `淀0毁`+~@y>/sIz -`w`?C`*b3eءL?Rf|0/0̷` ws`w0̿RXcy8L<~G$0/ϱy90 { ̟$+J> q57| I0wۿd,1bM.ć4ćtK5׃y a0 G\"wD6oVq0̯v0o` 柂Wb+J1B <4P DHH4)2I`c`g0?!>#kؚ-ZgOcqZ->nY[f0̟<Q`E`^-n0w VUv. A0'90E,NhbM`C`m`~'?0 ?㫄6n^/. Elk&0 O`&»PFne ?,ǔXY-(!\"V(׃`~/0?&SlX;ďUV>0̟8fKm6U|f[̱-Sق8'Jߩvreg^yjpG֣rlTm\Un[l9者(]޶p6-`r/sUU0UьO'ڱsWGGj:\uw-Pmy[-HaFMTmuGԭ:VVN6XjT'l\Xr1L٢m"iQ ľ[. / PEFEX8.=iruvƌ% kne^EPF7 p幏lAcPO] ̀*4 Y=wu  m·nÇ42[GZeӧQjZU nSUK`3uخ0bXGu7W۬f5hF6؆-ŭj_1[6`=L;گ,J="R,%%Z\+VUu4n4ancӂ6JqiQfGR-rYs UhZwڥJ_]ukjL:.n$zgVF`#]4'-tޅ;Ni6[fMVF;-AWaUecC'L8ϊq7& Ѩ́CvOۑ @]%dQB% 9p@h)?،B"78*7(́rS7/8@1c w #Fd8|0B}8b8b#o#{¢aFI,Pf$AP1Cf &1Bnw&38d4d6Ƚ i}s,*Q i*2<%?-GF>cǮmv:Q挵B\3*٬,%Fls=MlRmH,\.J.\K[ UahY yhӰG*4Vdrl4Z|"UaUUbue=CվdhAuʪT^:e]n >札27Kgʘ!Ýi.ȘfD5ռҌ}neˍ"᯴tus%}r3R*V))5YKtgFAU0j>MA3¶kn9k *vX &` o H~6/;Is+¡[ܭ|$Jŋtuv!>ݯ]9&Y\D*2͉b\3R].CV9X4/қxnqi"8[gǀLK]1˔EWys;4w,Dvr}4iWkWt5WA$f,l\_Y#0݅j?FtR#9%*)W'VS[B*Rx4w`F0ck}68VNe:uv[IIkդUČ6s4D,j5[^IM6ìwSV6C47R(OI?KJL')W-f#ݚM1lKgس\Z<ot(ݮ-Xphޮ⊷|7r- #s } !1IBOeWs.i|jsVMc5\#rfP'A4u;ݚ3`efi?7. '$L*+ Xld\*W}^otz<"Geψh BB?Je5x&S)ZK<4N˯ؒWoE~#.z٪E=ES5t;s`@ݜ9{&VUUlxoC^7HUJ`ypWPwkY<Ĵ2zPAd+7JQR.2ZNA0P-n*֝BO6ZT͸P-?r8M]]536PPUPuc)9٦ r22r u'OO dd)_[ V5/yU+*+/84O-Z85KJ|D9q:@Q g `Jz]s|>_eJq jLTI"AI+s+Igꪪ*c[$Zr# gWI+/ yA[Yr =tPAWoU١卄s⏔DW^o(j{CճbX' !Ӎn}}FƬ-3 ~#L/ç}Rn^/_7CW Ѭgddӽ6 z,O} 7v}(6žIV͒A^d/p,_t\pEyY>= ,((Z)%CzM j6-~FK阩p~,|:TػXN7uAgIt@g5g0U r↌39bN!chvƬ9sBDO%Q%CP7U#˷ܰع[LœgG)M  KJW)V<ѰJoLTP3FI))EkܳNԴԬToC 56~%Y6gڂb"9oʤɿ$۳54Eu߼caU; Ie;'OdlG*:++OHKΛ α+&q"(zH:\Gc:Vuyuܮ; ڿytbI+6caBpgSvymY6-FqVd3mHf^{™&Bf~]c~<ڪԶ6ך:wWD)e@϶J/I\ڿ~O"@:!SGRtZ*=˦.SF.K/U;6cGYRD2k8ӹ_癝CK[rl۝c\KO|A=/rba4DKI{ "yxun^kjU:g*ooҀ}b=ocwrm@ʀ@8?puRz ob7&1doһC+VG:l##*m[7|-k#Ϩ3,,#_5oB:z#6#oaaZf 恖`oDW,W^EySr9cG_&3-Gb"Pzmf":=Jo5Z|sHk9;7>AnQ/g[oXTɌSuTLȿqp6sSY.thWgޭe2{Ti,Ae#K<=5Kz7ftY_w[3E͚y̙N ΓOfqɿ`>]>B~\ic}i5icɟwd_`:<*Qޑ+Y//ԊgZQVn;)]uWq,;K]q)GbZMd5ꌤiEj=GYRK&䏲(4K[ܾMI'|ږOZRh~pMy%rWl [-w!R:C=IGI =)Wp8hO}A#C0~ رؗ.߀y1OtwD_<96&x^79^+8gk8 :gLB On/{Bh,ϾTwזkmmmmwۦۼr`X,wʽ~c8IX'_{T?LZ?-?D+wߕ{ʝw^r]{)rVNJ*\C+si:ZVӊܥW+whT;JMW;fƟiϴG\G;`ڹvFdi:mV*~;}_NrWkq>~hR\k=iڏV iuBhܽU=0M$QbD)< k1X `=}7FT*C8A8PuWGShcǍ3hF;!!Jt 0BME֩3N!!>PG} 'o359@E0I^׈:n0wyL%3BLɛ|X#P ^ƧU?8s#)Οf)m990G99s 94'oSp35s\;G\# /x\W3U,g$~x+BnD3z!w :X? 8)41h(OHkD1'w@$Ytz 8^SOk5zzM=^SO^Njx.Z=ފ+xGzGzGjhFh+cVNJX^-G3̽bsGB6ʾ'#4<컌+7(aմ<<<<<<<<<<œnd\ً1[͘fV3f1fÌ0c6̘ 3f̧&lc1Ęb`1駌cOEo w D)hẉ];;;;;;;;;;;;M&bcfU3sMqYqYoYoYkY&,^&,5_Matt}>71f1e1e1engY=n<Ϗ≱xnb=Jڸhӕ)}Ru̘+N݃=]/u{Oj}Oc(YCjJW+g^V-O(_KpZZGt-}@K٪'jxT#¥ݵ0B̃3ӧ=rwkZm߱'әJi%wё5e9S 6U{*YUq"ɺ"YW$d]+uEHɺ"YWj\j\UCM5=PCM5=PCM5_,o\jԩSSNM:5ujc5jF{D?)5yӴ܃np)\\\\\rJB蘨Z_a\ :Ȇa;p# ]!FH^ 7͐ 8`"y0 s<[E^+x^װ^77&owւ|2k*/Pm^;L!+kD%{}B3jlC&)hLj#t l4ڟg؟7Nط/~96Qc?D:#FJ C&d='􂫡Q}/8c778sqi1VANHA@;HuNvDog D~';^p5FA ]9 s cVr, oB [+`% /S~q+_ kFM2z$w0N$g҇ͱhXG:Ѩa hXFxp:At';dB pKe~0l 07 ߅a0r`Qp p [a,0&m@~;L;N )={UJcrGM$<OO`3~?yx‹ ~//a;0j;W a'k5bxr?z;r]a^4eL3ݽsrxWg#وx6"g#وx6"g#وx6"m'(x;xŸ  POГ҄+p'u 2p7_lOp-gf[C/Cf;2ۑNn|f$ d{;vT=? o/UC8 t!ͻw;{->6ΫHyxN]Y!Y]Y]O,vY켳 t;o|H1rTH 㼣3t .U2@ so7ՌBwZi$oOA@;H4H+p9;@G@WDN'r:ә='+g0kV 9GC`(|=DosoT8o=>,ܥQ]'G`92:WQ{3[hx~/GWa8,ϒ5/P.>ӸUdgJĽ n{I9c/95#QzH5o(gum`6NZc,㌽ p򻌣.8buMnjÏ`xs=a< O ?- < ?<[Ez㤰"i2wCG0-Ì&[nsq̲w{ĵįk)u k6́P 1#nat [F0-nat [F0-nat [F0-nat [v7'D `1t!xʢhQvGr2uFȿ3rwt߁;=At{݃t;]a)GD r+\A "Wb4(v"yz9z9Iꐤzs).b߷(>+t7E]8Sb_WFyX#ka<>>>>>>>>>>>>>>>5FyX#ka<94x/Bt4\بT`ZlS+ڈ>_____QQQQX)4^$ޝZn'MBlb܃0hn91c׽8^a?P(b&6nb&6nb&.n⢛&.n⢛ .pdd?d3ƛM&&{{mb61vMF0=ad#{F0=ad#{F0=ad#{F0=ad#{.c]w%bS1o$t݇^Щ9?A}}>'얅u# K))O7ܽ`)5"BїK1=b155iy/, 1iyJ C&dAIfPA\!<X(Ű,7>G,O-鉩a!wr14X VC`Ycnyr&x-;bT`$ .pHv iW@{d@g]S6< OaS6< O!FH^ 7͐ 8ĈfÃ0C(y0#P asbCXe5}8K?9/B/D< {1f3NQf3L& a0D~G~G~G~G~G~G~G~G~G~G~G~G~__Y.,a0E"rf\FnFnFnFnFnFnFnFnFnFnFnFsr,.Ǧ+ݥ"kڍX(lA=8>nYrKj!z~!G5((((((((((((((((8>:8>: 1BB#$ 1BB#$ 1BB#$ 1BB#$8888kq >5|\kq >5|\kq >5Q`;ލOxox;NS_o Y~Ľ'_/x < ~M?^/~Cx1Cx1Cx1b^l‹Mx /6&;㿜NNŵ:.jiqtΌZ VTT(tѺ.T)* X46N@Lr8lϓ^;ǽ{x=~g}g1b+vb+vb+vb+vb+vb+vb+vb+vb+ŬRJ1+ŬRJ1+ŬRJ1+ŬRJ1+XJ%V*RJTb+R+R+R+R+R+R+R+R+R+R+R+Ed!V?[aXX<7Q}nu;D!QwCu;D!QwCu;D!QwCu;D>Q:}Nu#3'3'Ky&qSTS88 ̅!.0i=LaZzô0i=LaZzôp#ZwѺˎKv\EQPEQP/@uO6]]]]]]]]]]]]EK,QDK,Q$((((((( E*P,Td" YBE*P,Td" YBE*P,Td" Gk|cKXrƒ3%g,9cKXrƒ3%g,Ք}aoXrR\<1n!9u#z+&Sіm)HWeQ&Sqֺ!^o}C@˻{yw/ݽQ}^zy_ծçzT;INwҽt{';INwҽt{';INwҽt{gMpUCvEHwbQ46U~ZX%3ÌĶИ97$O ms=Wv˿Sؕm +Xlǫ"൐K,c5p}+$VtsV[]јDH鄆=%ОL LJO 셡!cٟ^Z!'dNuz/bfo^z>ǜ-/°5{<::SkMX5q+}'gb8}1Za^jU{}%lGK;Pu U{CyVjQd?%T {(X `k(`  P=S@{(C5^7H Rlb z(O~JSRT?)O5*PR O)Ea!^;(4*ElR;<ĻI 贷?&aY2nMfOx>!GyaO/QQ:|&]Ֆvx8ynɩ^Q%^Ίz+vX]{q;nKϙ`WBoO1}طW曾:rpb+Mz׷}뵍Ưz4޷rY!uxxǼ+xUNuu;6MzOX9g]7vҳ#{Ur~w}?ܧ?;76^'\Y^ ^mI4#e ׇ"ݚwε &6zsaէf%Sb;lD@"cOjLxO cYc?e#pd؜;ݓ_Gwx9^muF P8P8TJ@Ao#S{;S;o#շS};R~bSODB,Oh E{lFᏵUa~m iQ/CM3F^{OP{/f~7 iH_/ߏf-hK^JQ}rT>ܽ묽+/}rK'>^W+䊾{XeֿH,eJXX*Q^#9kÒD-h:'\7`{nr@'鼥.Qx3J<5ƖpY}ck'75y;/ϑV$vx=&vU W%o8%Oe´d0a4^'[g3+y`}'ya8\;GKG1Ϗ1>Q)VjYm:o?S%y|~)85\}QqF,t}(L>G1'\},\]}';<NUpx<_7ܷkoO^k 4WVlkWͻӳ{*z=C5>w]/gafK-E Џ!G6l},Z~W Kk+]$Yb,11G|6^n='^'UJp P5V6V{mhkֲu-[ײuMxpȟ.S.S.S. LN>!|xPYRYzL)gEv}S/؍I4֋¥Y:O$-1EL([4yce_?NoG)_=n'SV&R缶syoYX-{V^zTEj`v^TE;]r27 v)_|s2J.xJ.x.w=22a H[-=bG[)>=q|\[ 7ZV_-=Jl Z_-6WS)~VOrIv)9O9rm[|_mW2(ǧp*Jc5?R~"^ѡ-Qz$-S|Y{=eߐ[)eƻql,7#òlA-CfmYd>J6]+efIFl&o&Ild&d&YIkXA+byYAk2ZllV*N٩ ;d٩AvjJY++5F(/52KJoze ^h-ZeVUfheFjdFYa R,([Y $D|oM"I7^^ [YQVQ*[]r_}bx/:I"jzm:]صNu#gl:_DD{L#|&/g4^>GxL^>7o|:h5ViWoF>uO}6myhTGwۜ_ a'XV{ OсNճ'vn'uyd N`w[n5V;jGvmGvnMtM]g+ Zi:a.gF XjVZ6hFZӢߪ;aZ[}Vz^;˭m~Vl˸kd|hMa:.ynQڽgnǨUYWn8-Qxsf(JOBz~f^X?j&nQE{r׽yx/h4 ;Ns>鸞Xӯu{x;w?0Gţ\gC^+G_=f{ڼ'8[۾b[ag>nfnfmYcstt7>est~JCY53"e˵N?=>NU_ V}yʙP+g\c׌1fnl3[[]񶕿3>,5 VKTZ R yJfr}Z5y^rכm>+6VSp6gdgȳh$*θ;zVmЃփo/# q{f;KνFATozO#em5|qg8=nv]a[B*P-nR[BPET ʺU?KQBܮS%u#=3:Գ 3?'J9Rû~FXԳGTJWTUajWԣ+b=6 n}6 ;bUafXuƨ;V}ݻVYQ|t4Q$%'Rhwo|T>ܧ3ב 8;bG<F^Oކh_ʧp=w U8ѵ +тV8 8ـ D w }|p2v*B::?=v mfB_y~:mXk>8GN>hn)-ź؞g5c1C:c'YIs^oGn]O}=tnu7ݺnL<􌎢[GѭMtGiZqĊ[joYpCN{\kk}rhϰNٝʯH9iVzku/v}AV[y:i aXq,کNvJSݾvL"iF;5کNvjShB;کN@\q3nqƜ36;c36T^<ͺʢ,telvfgiI9c3sfghvãB Sq 6&tgۢ؁~chcw8>IOp2>gp Ng9|_?p:g|3qq~/*^ Vװ cyXZD= K+ W>G g܉n#WWYˮeW鲫87ܞ:'p_j~bRx8u螚Saiē>*,M ϦƧpwp^-}/wlχmՉXD%NZX= Zݱ^ KO<4ߺ V15foŠho~ѾQ| G_q&W58}^]fGpU:x<<7ϫ1 7܊ ܉p7C0 X5aEU+֡ ^׵%k 8G):y]Ov=}qqxUF{FUHѩj1(dbhlt*.S>>Ox>>pu' |?"=%~p=~p#nX}8z,z5^͢w<ǢXt΋Az[ʪSYu*NeթUCx7xsⷘcxuCXd{hlD/0%pY+8qazb|8c\.ֳ}%p+^ꓓBS1J6E$uL嫣Lrcܤ>|׵\7G{U^Y9 WJ\ɸS3L5 bBhf yE-h:ГOS)U{Uj9fB(#L_/vD{[7aBqB4VN)c1E$L?S|)u5R꾰*uA*!|#8gy"jvHힾ0^?Ha45>6ωD]"gșƤcl?45=^OXU/b?p j{j{>p#q{] 1kpmX5"ʜ.|Sřk!n2&#n2&#n2&s n ܁;q=3q,{e2\}>Wf+O'eɲd=}^Oy=}^Oy=}^Oy=}^Oy=}^Oy=}^Oy=}^Oy=}^Oy=}^Oy=}^OEc+ |JSr*QN%ʩD9(TJSr*QN%ʩD9(TJSr*QN%ʩD9(TJ3Kԙ%%%%%%uf:DYOQ+vQŲXV&N)?zFV5;K5;k}/`J*T*TfS«ݒ~o~\QK&ט\T#FdUˣ*U岪\V˪rYU.eU*U岪\V']IuEtQ']IuEtQ']IuEtQ']7ĕ3q,3gX3c}fό>3 ! c۰;Ą}>;Q!CȚ< &ɣ`(< &"E:tє?p=^Gi(r:-W=wfx>;/,~'0ch.7e23987;+o_Jɘtz=:/:/:/:/:/:/:/:ǎ/7߾ѭEgV{*Ώ>[qAѹq9o/% _L>&_ g&77$edWXJ[PtHtע'hYX`OvcXwqaHmiTpU>gI%R|9,R$_ '_ ZVIvNbVOZAU'W9F{2'Waq2[CNd'v{}zJrΝ>OY]W8HrL|\IL%J||ή䰈 䶝;[;B* ɝ^ʪ]tHWV2R5;;+ ^.+' \0Wc ~7QcbxSXiXºx/` E ^kXaae3rXX<֢b]XX#,N%SU^{pqBhI}.ufzc+0.vp 81?aaRLt܎HhJ?:V4>6Tg'>B^cĎvL֍U|Wc%s~(dbrxψxψx܂[1~3wN܅qL܇1 `63f# Ŝ_B+WU| gcJxgkp-a:~_5n 7܊ wN܅qL6&<[5ṨRX(OEwGWY Sq `~. 96?csl~ϱ96?csl~ϱ96?csl~ϱ96?csl~ϱ96?csl~qpU>df-YKf֒9t9tllN ]:z'1Qج!e vnnnd+ST0?L)63fb3,s,s,3,3,3DlF( bs@PJ cGgI_ ޺. Xcoo} |E$BnET< x\"rx+ *.ʪr r%@# SotbB9`TOu^}뽪79s @́7oȿ9s @́7j6lȫ9QA(QVTț[$Ș S.Lp#U6{5=ij3q*c^'b.u оאb1]z}% jv!rN:B3t B^h"J}jJ@M"^Hs)apDۥ,mKCie=-0:.B0^ !-0[De-balF:Ĭ)DƠA6: )J& .Ϫݢ~ ںG17A&z%wGp5%(gI8. ùp\ jL5Dx=BrWj5ҬAp0PG 7Ҡ˧AgOΞ= :zt4iнӠo 桦xmbzRWj۝xh9 =gK![F2=.HՕ\WW}*]Lb"zrӍ!̴.VjJ)ȑzZ7R*jڥ75y|/!ww;T 9a?A.A'NDD "eRR"eE!CVMQj9lz,w)ozp%rL-UtБ #@G.\ݷuvVY'x:F4TyTD݀YB_\}/僾|:zS.Ԏ7nCL`V-|=0+VZ#WO; x1C4RyKSijmc]XS5 jM.> 5\_`8M|}᦯t nWf5b&~OJ9HҬ@lW}#@ot]6Y"[k}#9EHL]RF6h|.6U:VyH)4yB2,CHGP_>ZZ 3bFR.A4R6ʲapf4gj@;ٖ# gQQ!б^D#!Խo%HtKEL[i-؍=~?!w9cҚ~Arx\[TׇkFHaMo U &S/E^r!!.yjAsMƳFA]us!SMχ@@ VZ'ݪgNAzHp !4B&H3'״k%b@G״m72-x4$ٓvR[O[UAWY@$mLO3UnFNWPN 'kJ\7DFH ]SpM +MCMRBڋ5-4 Y/Fϲ{4j j$N;A&&â;M~>R}h|ዅ|Nz:]9D7#Vr4=z|}/Zd*ewYmV~a),Z::i+ºN֓vM/Al`ę&^Ycuٗl ǛފZ6 k/i<~9o.W+م=wY[~=]oⷰv+ʮ=yOWޛɮ}x֞gx>O39ևX_>?l0/dUl"_3;|;>|73~\ b_ .FH᱅"VijDH`KEHfD}рDcF4Lq[/簍h6V5KmąlX\2E[іmNc;EGщe-,WtwZYgk ʧZYB)\s .~65@_7n97ga3فvﲥqvv $;EϵuD,αۏ?D7Yk/N{=YeO4{ge%gY<1^`-Fߋ'EJ^#k%{Qlg;D{] ^$xGJ*ޓMd+@^,˶X#/W_5ZA^/Fy"o7);do-y"rP9B,.O[-l9VNOO+^Nu9Jt+Qΐsj&U9rk+,ʺi4nq9[:g;XݜVN+s\\luZw8uz;VZusٺ׹չwpn p:Cpg5yyzycp:cGx1g/k3Ùavf:3g>ko=rYc>k\ Z n51X+X˚LSֿB7XzzY > 8t_>P֬ЃBCCCCC9aӡ/C?X[C+CY9 ցp 7 LJ<x=$7+ݤ-݁C}vc;k'DwsMKv3w;>}}nNw߷s?p?ۺݹv{w~`wtr;+v7wu7ڽn.w{q an#{=n?Ym?9g?y/K_:K^Ȟ5د{#1I{7{~{{ўMgzxzz^ް?yسcxL=/&>(vL]{I#/C߉˪]G(Nѡ ,ו"^UUqw< \7wJױ;Td{\zDԐk9 ~Uɻ4>Mu63JHfGcNKߢBտ[pF\RPmw:/)2}~%z\><&.j-؀&t |LjZ@o/ԛuKSgAj |ڱ.;Sԏ[d?=(CrPυY+<<^:~,ZjW;M,L]*ڎ1SzeVª_Cs]@ۢst cR8m~|2򜆳JP$z 2 .t< &34W2/V8 Z!~z sKcqQbqybjL?,ja_A Ч:# 5>ΏA}WFZԑ$}>G >n[4>յ䧞R*@ԿRX0y3i6ù4ZU WJ)1bh4@`C^ޏ>u=ususzy^D=$%nWY,Zx~b{-ryk6B6iҵNGYZZZZtgA{E9NbNNǪir:u:VCt t,hsur`] İۜjNu۩d}dIqRY?Ә=\⤱dbC=ˆj=u"6LDlx8tD7Mbsٷn-Ժ[u 5oZ`6i]eh]m׺ۭu G,O,_@#8 ƄSbzOaf8c&@HOJNIo{flO6iFઐjK+(L+qrp*HտoS:Xx>e8>:H FtRc#k8Rt GȾ/]×7 To䛩&O3u 6ddïչ⊪ ] ?:j 8qmq7j"{xĬ V6+l+ʡkQ:@AYG 7_p]u _N lGay,y%CAv );ʎk1Nb\ch 313]&S!{PcE(bE!W_ ]G9(r0J~#-r >\G{{L ( -EX9!8zA4/ ('IrB0>)'y]\SOPt9)gy_Dh'hOs6+炪oBP\2Ip\)r\ɍ*7 @h]2\w˽9O!~A!yGPrGˣ(j*:W @\&Mp 4h+Єi\G9kL!Kc 1)S:<44"7:QFɠw %[ݭmfr(n:w9n纹Hݍ4})=@!9Al[@a7*Jj]]gl9T z!ᅽ0RGuk%RF7J%Z۫4)^=JRTSkC!7C8!y)Tz{%O̷wFC )N!8 ah8 W | h%_- J *0AapD!5 &ep0bY,y k_X\fJ^Oܠd(WaA1x6Ϧj VGQ5',aQ<ρ?$BTMt]jdW`_=C@xOvT3IPȠ^ADjy2y q gïMt %NB4 yeggtK42 tE]ގSމkWtAt@ |yʡH_t#b 59A# syhs >ꍗ1ؗlPOԳk@=T97@7HqPL.ɯF.Uc[ F 4dPAdz'!ƾD}I}+ qF"V!)z$C) l  ='CORB N XqR8, @rS,0%q1'וQ^:5D'>VS< CU4V@+y\*vDznCPJF2}6G-6}DsGKq]@]ؓ~߇._Y(h[p攒=7ٳю|<[^*?eSe+}*!(5vK͊L\|f;SWg@Oo{p@Nط@B)8Re~>U 2^<&FPw٬}zeT7HG5]]g{!ƩIK)n Z`ZjoS՛|_cT|xћhjsk4O6GTS5F23*hё{nϗ;ᨫ\<3ދ *9KyH5&C7..u5o0*D޿#nU)t+s?0.JUaj/ߔ硨_}71%5rRedm >>,vC]X麪 scWAssYKݩYp5h+*ƨ TCh+$ʏ'EIQ}7JƞCM?eh]Euȷzħ_~ԬØ3ka)i*QI]?he蛮j}ѸN}g~UOJ֘W=G߮,]SyDC[1띂Q>a rzMŎZ NZrU/ JʩG:H'.zZ2 Gʩ; 䝲? :Nx#{ң9/; E}'|GUT 9AZWptEh/8t"ج֢~dW^ _yL3w-Y\Eu0]UZ#+D/]٫ \nr3Q,ݡ=-;*UVܺ;hv,8+Tf´zuŘ{5=f'OXS{NaY_Q.WNz}I啭\gV7!u^h:bwO^f!-{RT鯲Z]hjz[)i_\RDGR]J›B+ߢ{M;}z8umr9yU+=,0wbE!t"(tIž,#UX4@\U,uJoڣ7jB&&mikVr#VL[WCPNj>d1HYcSü## yb/5jHW7TwP߫%^17q/({}ax(5j> imf^bT}zu>=! :th+ EoX R wӿ[llp~iS_ѯ7 |.>Ykҵl.DuTe =:YHS;7j3 cMj_JP}W/}UyS1::UM#S&2,>v紋)/}gR|9*:,\'@[#e,̑0D#&9X ֢5UcU.X7䪋.+K=DOcIKVlk>뢭۵7v >@-vk{olƆk{olS|ƞ6DmM6TmM6 m6m-Oںgںu7ݸݸcOm׍knhnƛڋ54mэ_-6v_-KE7Q[tin^mэ?#p>ұuN?:q 'IO:IN-SשG9mq?-1pZ5>^]/jkes)W5>Y]ik|tri O[_3ggLg3u5?|/gN&lwlmV!G?mV OcՃ DB٢ve<7xH P^L4 g U&^4v v-7oRCEںT[wWkkmmM<6& C_퉹ZƕnIi+ݮb&"Nei;mvڬf6fvڬNYg֙NJih;mVfvڬK6jmͺNivڬnE[Yi+kVwmeͺ][YV֬5_ qcܘkPL|L5D[V9sKIbR1SP`}#u? _2~ .5пAftQQv>PQ]g3s(E$ !H%hB%g3030 0 ÙXk5Zccֺk\k~Pgk5k]^]޳>fÒDŽlzBVB+X cX A ^XXXWeB%gufL謄Y/ZW@_]OS]u"f邺%Lb%Kӽ[þ{S7&ҭguatuɺ,(?e"MuUu)b]Ʊxi<{R.I V-*N4NKcV|(}9KI1YF߳d&&a%/Q#K'H#^&HפklXpOOXtSfJs%];*}fIr-+a2Kl f9L$> 幘<`c16BԧLNjxKb$cJy)g0E8i+x%F>ß UI|6#x 8p]MUnћy ͘;Y5n6; Gts}O}l"8[?Wq-̲[--VuwFV*2`1~)v.??;u7ߍ}#a/l%?AQ55+g/?ʏ#`o~c OOSq=Os#.'' cnùwd1l8&TxVOO`SI\fOOeOr*}1P?=/ 6S_/ OR})2=# )}zF W髰u~&%24X`&( f`&( fX`&6E0̄>U fbEV-+g˳ ƀ 'V.ȉ= r-?u4!` ( PEadPbB?,QQ|@TuL^)^*6\7e|a[_>E^ H% ҂ -(H G/Y|GWb%LL[=I԰ɂ*'Da%II+дDDZLH33،`3'&NB}rdVO8l5'1`;  `;( `;( X`;,6.i^<Ɠ^MzI-5$-dPYi }?aߓ5LMb dAL+( ~Y2{PY,bS(_abbP ŨYҬ4EiC߬1ޢX0ƪX1SDߦt<Ů1[q`Sqbkb9 >Խu%ԯʲd+!%%QeG\ref(Uo(1f&yX]]v"GȧiӾ,?LEjD#H0*TBcvˡd0̀x xFEp?'D???tCL_GL'O'#r'Ӊ'3DΉӉ(a|9/xuDqg뉭뉭[[%Hl=:z2d/S~ 4)蹒kPlG V.USg|+8)Dɯ.%((P3b b?!++\N<((y&Qr-?J"JM\N<((yCl|'~ Ǖǯ.UqL$W?Fdql׈k? <pYS$QDYbi"F)b%QXI"&M8(K,R^ "H)bY"E)bI"&QXM/E,RĒ(E,RIJ(EL4JK(E,R$J@)bY"&QXeݗ"&QX5RDa}a凥P~XIx_~Dai&Q~XI&Q~XI"函Da(?싔@a/S~X#eQ~Da/Q~X5ޗ&Q~XI0X%ˣl6y< ޠ@.O H~~X.FD.-r<=O\.+`aj:hf+c2LQnCxM~ [ "`xp8p88p8rLmmT+GnkKx;;c8d$yS@ 0RCMCiR6ie S`e.S&L@E PC))Y*(k0 (k0/%7%[E`>%R`^JGJ{أpb!rb<,IYQr_3w5w}5)ì׌)kɅ\ %Qra%Sri\~e#ƌ ьhf4{U؊W- m%uhѶmGۅach'NcQjx68v hnaY&eeMCs(>WsXT͢mmN|iklnD(^{R8vFZ]B:?vc;Blq4---'>6GYs 5~y|l!c.4Z-6v ]*ac7m/kU}l׳k_n}hюG;vm^?뙱nݷ.c-:$qhѲ*޿\WmekqsGǽUyzԫ>2-Mh tv1F)'U˺ӡ+3ks G^E-%O-5q{w9iսbkzעƽ12xxt0SXBn#tz6xIC^5^vB/w{׺pt]ƛQe!7xY۽t :\ Mڽk+lޫ3 TfS@̐ݵ\UKC+c۵JM7t ͳOjViqz5yN9 F ]} }jsOm` e]Լf#Uͣ *AG**MʮjIs̑E:vjvEuVW9JI+M9ЭF|/Rľ݆]CSAys5tXzÂ#jaqq:;^Ç31uT5wIGLg:.l?$._=? =ѿz\Vuk~PUOE~7Z>RѿP5C1Qy]U[$4?N￢^C_uWuv_߂V"CÆvZKZoXmORՎ9qB;bԟmeCr|_1+SUЦrhapըa}Lh(ϰ>Q]AJQ6{ưӞr|wP={ƎUŤ{a_t@0toо}~{oAmXo-PQ:b8d/Swum y_ԇ+սg|Խ?tcԷsa^踈;׿;; Qt|IШᔽN=l8k;o:wI=f8ooRO.;}WIon Wspݤ^h>XN :Jazu&-V]+pE8bmP/ݡ^kIr샎#H8^[ǍQoPou_R8IzŎQh"qZ{N֘i_[swM=:肞ḻ,&5 1W2Z:z&f2y=;z2R1~%SҞEc}m eE\Ꞧ@ľA=!4pemςuc}3oY{LBQǴʾ-0Xc߉sFǁ;#ZxzRXoo' C=KG{V@GzVCO=߳9pR϶szvBk쇠 8ϫ={7Re8>(mݳ_Uԃ=hpqTU T~pqa*F,]W\oM  -t2hžf,~)PZTMZ~5048V ufzgNѨo68H: FgI0[0I0, 6gVuW`XeAi:9b% V.s.Zn]4k6/Z9 mwZ8Uvg4 67usY X\ }.n\#s4~[\,P'ʁtY= {>_O[sԍ=P4P"9PRuymM0tPAqm[Z'Ю6kZZ EkmZ^ =6kXD:wmyKC'®mjCRNõyܵl)ޗqm[::ג:ox2v`uBl1u^Km\W6nmslf;m{<{۸Эtn1/t [F]ܷ>gx8qjrJx8zMfB@k/d*hDIp9cb/j^1U+w^PkyGj^AnFOj"pV4<ܲٓ(2odA{W| 3WA^OQ|S EÞ*>rT$01,XãZXͧ=ss< X<_!>vg.{Zkk|c4x\ 4 ǒ:; yPBue;fw.a[W xc;Wغv 0,۹y`%І5mbUsXq瞁bX1; ,<:p8V92p,Vw'ԽNv5u8[yi|ܥ87ѿ=p'ژræSc[?#eb~[j,ws\qC–/-<[!*N[ k}lE&ElEgVl_ωutFkϏmEٸǴՓqQ8>˽o[l ~;S܅<`7p-T1 fm1VYemN*=q?h7ۖ Ήƪ;+4@:v^%v)u}\NA+omXmKK؝{]gD_鶽Wx%Ѹc]su_;=!TxN}B9-u.uT.sI}Z.(nIiM\mnO\`38Q=ѥ̆ʃb,Gаb8v+cLە5X:XuB w],TO,dxGܳ*n ó>22U("-l{ZɵzE ,K{:,Hs$Rf94zNF-YIz2s&tM<-#us[ž@ebY`,\Z[nD!ǘF<W.,/)EZb}#+,#-r}@ٲ8 ZZ6UFvZUGvˎ}}MC} "G-G)*[Td_Gdr9eDm}@b_80ro+B 7X [ɭm\%Fַ!rrosn߶]KQHU׷'RlMeq}:hTf+hY NE3}g9ֲvYd`}cK@CZ$>C-V0'ko '~zC?Wiew Y-]Cor:Ĵl/i>dZmͧLLa\+i9K&kRh'4mv >&h ~MJOxeJu ,KrJ,[Kԩ_dSSSTCr`#W؏Rdp6_b:RYKd<23"5EJ>߲߳$FѤ4i4'YI$BEi4՚zͰۚW5?Fwxt.[ӧ š~R M[mw5QvWuu?,B JݯtּAZwBM9ݨ-E5tYAoE$M&h//lӜ4 /|Ÿ敚Ooxh>Z/j9/Ҧfnfs3wjr7WڧJN;7kߜ6=+8?#>G~1K7ҽ=c1YƲ, BȄ!4?(BhzzzFY*Gd !S<ʄ`BVc˄#`y%k 2a1y|#!Ǥv_իJۧ9nf%^uCKlx.gHΧ /ܛ|ư59aoN"g;獹9?YkR=EN𜎜׌y cI[9ǍcrN3V>CDkuq;44TB+ ETwE M>V3JIu^iuFmhUw}5zT=V99ebbĀZ]nTխ5dU&'O@'t|U^2$$O ?s[ / aa0㓨ï V|o G |5>lw†ϝe!F(fE 7džÌD>)zX* DqߊlWүD@Ka!BYD3>>i1|"/aVZ-R&Qcu[)eX=ڞvBa/Х㈎SJWT#qrV\Tz !+-*JB塊Pe:T5CM@(JVVօ6vvNN΅CBWBդRԡpX-UGc*uu ,sR!=[8X`~S/š'Dmgg[`uzئ~57H]dSC!֧4LL5h -uʥSHYdwJB5F'4t2&66tmǏ*Uq؄ЩuJm.tp!~8b?nLMSffzoVfܡk1jVOy-~NQbSh,csBQ^JW$-aSb9/A\c %ք&s| Ol8.Nl&ɱc&{IpUbx| ;\8sv$qdę +hj8<؃x.ii"yI wڬ5^}1>9 }۔,̬3s짵ǾL{ƶ99h5Mph2W؏>oŽ᝱ c3j=VF{7f7>Ax?탴h? u0`2%GO&ǢGLr\|rB'Yt}[#䴈HX$qEz8Er)6>gb-ϯKfdHkTod<2"9)K.J.F "cK#㒭ޯ=g||IVkx7|ܽ>&F+ԇq2;Vr|Hm9ȴ#-?3} 7=è9Ee^1;gSPLlI^,Hvdry49oXw2{tLr|jdoZg^c^s,sr"'%Lϛdr֥s!sFp~v< dr=`]ņ)|'V8gTzo/ -6bXqޘ'ބ}^u}\,y]&G 7i܌ssLޕcq_q-"Lůɵ+Kn6Evxr udnr;) KdʫG"kِ<1"Җ< ܞxKCt${GVgʀcWʚAT~T8M!\HD.# {23l6G5UqmTCsAjzsQcQsI<hHE+SIr|:5&qs}j Yh/lnH-kZܘZܔZHmdj+Sn߼0yIj_9gbsԡթ}my]{9歩n0ZK8+u:s,o>65Jj>k>|:=\;]|)=Jz zQSz;{dۓ[ރ:7܍Cރ{JRmxi -6! m#xZmhކ>s]b8D$ކVmh ކߋϊINx'} DNKRT(jNt"މ$;x'ZwvuHߖ.YYew_;ѧ6t:y/WWWL:މ~Dg'&N+B&>yERsł{yNzx{zH.{[\y"Kbk#[x`Y&'|2ɧ`Ca'њCƫ~?V}8ށ?@+AbUwOHvQBZ2ݞ"ϓzFyfD.eBx<.Meii 'jyg&"oQ3"{*VhYbM.[EYY'.ml/-힎.z_̽{=GH6PM?zNJe V@-4tffsA`bV vK6Uf|H}rT.1OErIF~M$W@*I׽&< [ś'{ tpQo&[*7eH9'9m=hEȾU:xo-ۘ3AYmW*葂jR`ǃ` g10((q޴;f]Dk.'[v{W d˭M-Mr%w9bjٻͻsͻǻ{z=Qix{Q bňR^Şie_Jƒ-^(,Y|!aB4M|eQ쯾q$|u䭪>oFw,'}ZooogomVJfUr\[+6|[FvZ_Z-r_of\>|GqSrȣZq;%Y|KI5woӽ_Ns+j6N35OU}$,t.ϣBѿ픸ɿ̿¿ڿ7¿s.[#<6.gYh Ԑ*JQMQw+a@)b&RJrצT*d9z);Z OkRC8R2dRY4x(=uP.*ToT<{U@P"JQPdʼ "2x$xDY,8wVu2eFwRV{.(8_T)vek`BߨE..kKY&7*'}Nl;Cl?xS;G9&OhuΑ]S<(w\o_W=)@qs6t``8F@i`d`L*0^nyl+b`j`l`yR 0\`>!!%9AuIΑu3zfI.`s٦=D#Dc9 2fyaǠN똆ɮ4u=hm'::jp׎t_1Z8i_IXz|ٻ$ٷitrdS\٩v{^_}>Z쓙=L<t9\_ש)ujFoaY_Ƃ{(6ga/Dz׬==Y跿}}^X澱fw}1irt=A{O'~[G\E_~l[SGZϯ2ϷZ/|ўA{coIރN1@{c~'Šq|6>Yocc'ӢqK̎Y12+mަRS~i܆כs):g 9ʍz5¶XgN{/='R2Wq)o sRL!}SΦN) [,7oQux~bp_ŢxuVkݞ2ܦW?>R\q~$s4d3_>%1g R?VA 'uΆ,v隿9iv6ޓQ6OCE9kfgbmy]1Z,wQű1a.ʫ\Odm~]h~Lk\E9ñB.ʅ\z=(pmh\dj9 GQٵ_k:1>Tfj8(~*DNPN T5zBa:D"$aa!a aaa5aa#]V.>!Q i9sD_jꭃyzߺ#:0PK #Z0PKphzSYgfd^!D iMu>aY?n:f$яdO8H8L8F8I8sc=O _ A64~i~c;,\}!7w #.4LT{>׾ؾj_e_k`ooow;]#$gk9@T8* ՎG1h9GH:9:89V8V;96:[]}Cӎsn%u9ș,v:G:8㝵NYN٩8δss\\9 8;7Uf] TIǹyʇu9< !9O. B{}q_\_\/. yŅ!Ņ|P½lE'Ѷc l-&&ڒo mebwWl~) mlEMLHQ|^7 Yu*3kenרttP-[LQn2=׭{~\cc=?V yWnjR>>^hAeT_he[>>|^YewZ݅_ ~chUmVmmNȵͶ5:m!-nK"<۷EmDmm(j{U}>WMBSMG.\mqF2K?w3h9zһІOpv P>9ڿoj?S ۭb~׹^j2$>c"K0pY`5 )ǵ^s{MoR̆(?oj5n{sѽh+߱o4x0_{/Z٭9Y;w-0q# G7ޤ״[=^s ( >p;l|W>> =./`X4܋t~6m5ס:4\밊38{5gb#y?l  K8Xۛ(O9=j U:X of8jûf4y}Bs+9Zl^^/`yמl(?:D?kYʛ46+:P~aW5L\Xè)! =K)32+x 1m4'l1^)/mz E~CM^}x6̈&7ωe'-\6mN*`]jy_kڂ^YE1oOwaEWs5MR؞kh؆9K]ӳ2X#<:`cJ_t_±|W= zvwIqqULH'ઝ}%,kα; z^ǟgђx.['GV/j$8`JA!m>L5?oy^|ORhY)+h{q p-݉]&RK1lRt7>Ոb6UK;IMɻV9mN'lmۘ'{@ ^x&2e!Zb}foX+eDd! ܉Lrw?rXkwj5d Xz8=Gs|'[?5{G6*L ωs\6 83s^i\kG^ByGi#O)g9~kh,0x I̦"^#S1l_Elވ6a]쿣8; R ڳfp҂ظF''Hcڀp>jz=gs7}v'5_AtC^n{,?y/`'e.skOdxB4s;^F˹\C5 \chD;lGƑK --KM!QunIQ~& y<փ=`<1oCvp se,?`ʤ3yO!뛯 (x6ęehY˱ *PL(x6ulo8ۉN|s]OCo#.<e>ܵYrXXr 3oQ[ct/`GWO35g0;!,#;:g_GOӃ|k^ۼ^A93ЋY:an/YzXMƼ{b{Nsg_l&g \$qMBb$Ia(%M$$$!H*gu~o=?ϧO5֘c5cεzx$O؏ 1 !eCv.M2V!+( W0_dⱎN/4 |0ZKeYZ:l_c<NJZx&*Y]^Z:e>ٽ<oUߕJ`,W H'*v[w& j У̠wu!cMZ=ώ؍C*pf^'nZ `f:m>m[%{d%)491[cY<_􉢉 v?ys„nreɜEa]~mN_HS54Gd-m ;&$"y"zhO-o,in)VԵ"ǒ<#v+kBs)Mhŝe&^YVB=R@a_oJŝq7\! Jb5o=ndV/Y֥׎g֟`vHncAK)sQ>yq%V ) 'F˺컝L3i?Ulߥ-/ t=R4},}=᭲ wmصmaM~8dܫ/{l)(H_xBx]A,'YcQwu'#/kkbOvv>'dWWw`+Ҫ`<(ٛCx%(rhynJ&5jׯn' G yRVN7F*ggl;ְRj],S/˾G>)uS bR@Z0N35' Q'τ=dz')!{vϡ%mOVea~NJ6QϲO7ERC{~o2%2\1gK6ٹen&? `zZrԆJh"O+"Y>5K3hz 9҃;9o/);\7Mk,mXf)ȹԪ|cXC>CbP<Yј02%ah&y*tFvZEv+Bҡp&snj!3=M"+gpDQ9\ٶ170[gXU<_p%̭#DXfcyur3̝ȿt #YmX"߈~~Af%I ,Yl6թ#w o 6 Y40\7[}E) s{ZQ>Dn-H>d@x=kS/p5d=drW 2N"9An I )p)\Zs̈.%ow\=NnpgXMq,א-9V=KwEUF?*a$V oԅ־;[>cCnqmX;,wayu8h]M'eehkĪr}~&BJFL3NY)ߡn1$oKv)ѷk)N%-Wo9z;znd*;_|2gC>|%窛./"o$Le^htj4fOۖ;mj(ZjZ"]5#eA8|ȏ͗(ѶwE=a#zRrߘouَ䭋^UWOe^ӏ9{o*$4a3]]G=ű&rU*~uB.3_]X沖誋΂Oui2ub﵇<[]\L"]y =rpԻYV ['2_r^kʺ1G5EEߗ;saIX]9oB,LG)w|8ND}}Q)JKEr~q~cΧ 6DžT(>|MElbY rOXA&B@0 W1 A ;G=ZS1Af*\DF77#smx/ de~ o={Q4/7c}ies ^LpwXptDpDR\D>#4O#%vW8^JG NRx2„Rh>m5 7uaLD"#|؈+mgJ^.7a?7Az퇙6vƾy`i˓{If1r,k0qM,B; 6-LE_^W$2[N)sM\ؚi#{KllX?ocSS7r̲ ~\+ϧXI:30guKeBg4Vuᵰ#uw"Cm=;ǸV/[CI@&_`l+~ YE}q1Ź'pő59至@S2M+>=uL\>\4pu0wijuA8&hq_Lٰf&3lYS>j=df? CϘtGjfU•3cɟpZYyMrn8ab䒹2H&l&lްFfR_˧E`sx\h~KA B'TNal/a;J D4laB) ~sp r䱰qpУ1#=1lEnD~'x3==2z/@_WڳEzS>[їF^<<+QusiJ#߅>җIXɰ?ZnIZa#kgJ^M]F?7a?7ሇ ၾ.O$aM ǺV"Eh%ރNG&3ؔ31߼MiMrdo@?ѓh`Yx DZ.vt'rjՆÿ o-JP'3Xiff.؄Wc 4Ź%pőՀyA)8p3)gB᪂lvٌ| קEa·=ZM2ф#}'iaMg* 2 |Fߣ1z ܇15?莞 WbCVJr9)Fb伙ɽ?cj&У>4JފlweIižm0yКҹ&]ff.EFI,h ]B:alr_ o'BK5zQV; Ehƣ:['oQCRy7wK'`\HSz,,oH&Zd gب\Wޟ8MP?՜7$ Eg;}ށ,}c\yO!w]eow@Fis5ܐҏuMCqWŦjž IiJCY/\=6}";sP[~"s1< ,* v }K(Mz9'`M6Op0SӊRfl| x^7xA_B5u)x㍇>]&6W휾 6DOm|iC*4kDSS RwM&]p ۰LZiXn&lf)mڮ/1ڼ>~$ -b鲈dT,|hHd~x~u`-[]Kf+NPk=q&TceT2m#.hQYgZx/"K:YJ&~|:M Aȵk!בi3N?"c|'oD>|\d+Ww 6f9۬(%O戧߃ߊ _IxX~FKkD=%rpJ N"%~@9`߽]:9ZGis wI;05X6Zogm4 L@gsŭD՛bYbY&r瑫'ԗ%"WB?{ Ob"w8xk!בw!EՂ6צ=9,- FC镎5^G~k'c6|r]g+u\\E&nIz֥= iNK5P!P,{^_|!A>A)uK4GT7122@3}j[n,]En*RTLTWBUuR^^u&DUJUU Uyiڪ.wNjVjR7:V%5JU55Z̭ηVGTuz@ WTQeZwJtMgNm \oɭZAT7nʨʪƫjFl$tUAɝ:\WU苩.UQUcBR7;TUjzPMZpʧʨ󐡚UkAuW=U[XL5R~˴W̭.Ypt2cp e^=1^6G`װ ,†{#l;t@+ `Gң?Nyp\:=-p; 4lixƅ?^dX\ᐠ, kzl[/~ΰ3 !=(GE gl8.ˆ1 Õp==C7?0^:0aCk֊5a;vkL8 4:p\pcFl0<:tXϡS(L0ڡMHi0UaLɄ1lV(Oڭ=Ѹy^B<~8[ET,=e?Hֹ|#yn}Ԍv^匷=r?+0X3o(=Sw*ҕHݟKǫUXNsxY{twijZ6|/+exͽ^o/Mx˽ nﰗ}]J#uzޯ &٤ʦicf63"7ZaΚy{9ߜycnS oΓ3.?Oy}{r.?/._$5ysևBa+tÞ.犺|GYWΈcVTξU]~^=~}3 k9s3<󜟸Nd9w}ys.yGAG"˛zYm{Ӕ ^QHRZM)ήw;Rw;w;mj*`opMmZ/ "N#Ad=&Yݝu!jڤ ^kCkUjJGSZtrlr[n4?( 6qu;-]ĝQڝsd;nq} MSeAuo7Cޝqo,GEG"#-mG{o(iO͔tmJ %;)EnJJ?7ivA]EI1:N\ֻH%w|_z5Ν 1^w˿g9uWzj"el7{^M~~VO{sWW5MRCM1SW+ ]TUWYf뚺30V:Tjǫ z6izڤϩzޫ.k. ⦙irMkf?^A/v' 2{{`W/ ý籉^[{x''xJ;R_?&d}jhmi[W۫MA[Ζ3W )d+JbT[V3El [l-sͰgⶾolCДl#S6Uz{)efOmnm+ʔwٻL'նk~)gځo*fJvn*탦cǘafvhjlmj'}>ejۧӦf }Ե3 Sδ35vm۹vi`yok4Wuv]hEvib%z.3MM̾m67w;}ϾgZvѮLK֮5C~d?2mFѴf~l?67O'~jn;~f?3s~a0ؽvl_.+f?=enis=g1]`R\wV\/׭vY<1tNS.tE]Q%Vnu zw[} T`H0D 2LuEdB6ݦ¶-xY[VmyUVՕ٪*n*ִ5:k몫5U6 ԟZnשҶmV+Yf-k[ږީ^`>ޣ*vlAl6fj6fvjviڱoǫvIvʰdU>iTT;U]cϨvs}>,^ϱsujl_/&%޾l_VMU̾f_S7vjnڥ}þnoٷTK.W]ھoWmJRkՎ&ֿnܠnvk&nqgGխ6bնV.v[eo*{]>wϸwn=7ۓlVw3۞gyS:v)vIƉ:>7}Q}i˻7s91/ zetJj:nn=tOi5SW[jZ]j:^y1/%i2IC28,i$Ǭ8O;f:i4̤1%嘕0I0g7cfң%=1+iI1esLz㰤8<)wpLqX8(2̎"2' QDEy1("/Ey9+QD^"0kQDGYEdieQD^"2h\",7#fEdywE(WVDYEfUQdDYE("FYE("l"9Ȗ("GE("owɔuDdӿOl"#("E<("_DEdo/"U+_G&́(2"s0ߢ|Ep"}mDdG7#cQDE9E("'"sQDD9E\_"("FERx+adUd/L#l@DN"rA2EFi7oӺJ.ign6}= 5ph&llpC[s|gGs3O9iNis䘳ɿv ̕5mM[M{^QgU13 Q&d$eܓ3B3(bFGT~3RJJ_7]2d'?/~kYޮ+%wU ]{fZT,ʻ)3(?՗_WT~S/n_/_iw\W_/~O$?} w})uXMʺzy,4Kfh6fl5mߋ-3/Wb{q먋GẕZJWUfYc֚:Yo>1+}Y(4K׍[] ?uޥ⽺J]bv(E=W/GxzLMP$7WERST7˟Qa;Hw& A (@PQDsu Q s^u9DQQ̑ N{UCO:Un-B h1%h)Z( XVEzQ*ڀ6Mh3 mG;N F{+:_a@Wt G'It p :Ρ.\AW5t@7-4t2q,=BQ6zz^׀Fo;}@Q.C}BC7Ƥ#$t$H L ҕn;AzJz0Nz>/ H2D$DA$$mFtr#I$HyH$m &ͧwt.g>?)?/+5˿|.'/`B&)mFmN[ЖmMжԗiGiH;@ڙvA+ hwڃ!4ڏh$Hh4Dc`KСtNGБF1t,G 4Nd:Nt:Τh"#&a êWyLF{Ӿt0ʜmufx3pʎ%Yq??b4Ɔ_x14+6j<>P]@q,gc(|赝P$l$&l&l%岲l+d{\A(;ȕr\Mv.N>*HuSȻb}OH'S~oߒҤt>V,K ˊRFn  6PWEf=@ٚ{Uq@?D5qh5Éxw (ĐX4 %cx2L@D2$ImmhhZ>mmkh m K m텯h#*·p/#c}q8.πgH"RWBnH"38].-эlťyR{04Ge4p<oUJuI˦:t煽qs ָ5qN`wٜD!PVl;`/*PY"T BuIpj.^pw|_u|ķmt|qp~8?Oq~s<}>r\pB+ǃ)s#OBo˓ {Y]r=ٕ?;owҜb8q xC! !pHpȀpHb8$3R22b8dpȔ!sC  d҂ -a \ep~puCAix6ߚT4ms!p>ĄX;@u=#X_™A~j few\=p]VX27`e/ܐa027feo܌؇Q2 ce`N2jh%LZjVkuKa^\]s{. 2[0U {a$~;֪|#>8OK}^x'¾vD`X 7F]^RױJ'8˷I]*5簾K> 7V:-I`7 Zԝ߶~@'){I*6k}.U6}zgnO&0 Y/O?Q2A !IFF_q.~z^Vɿ;Q2;"CP{Pc5`уƁq5 /ċշw/ȋX7y3 Ao !>' )Q*È@ML͉-s ) "7⠾8#ԫPw"NH}3kMFC U|6C}r|[}k}ˤIS+f@/~+*%%:&*lH._ݨz9ze F S(|}+}/z2/6l <9Vo^o%^֋_Ni7 9l~wArޔaAri~2Z%ZZ6oǸ=՞Fz|j c#U ^XOA {4V.-g3_6دu(ۖ9߯ylmWkSZU..n\ÀW2$66߿^K1q}l<~.fGBYWk ?!ID_uO e6sGnKMsxȫ&#ϊ:idֈ8k``R0x8b 7F-`QQ_d[>ng 7 ӻyVCuS?a>S`l˭:z0j܆9CS7h̶t0H}je8^eۑiCmvz%x}NƍjCNmƞեF2vZXF试j8n\fUNydv6[cgQUݎ.Z/ -\qbZ̮2MH.|б/Z${+V] ro{;/dwpj^[7acb=DL]k֮YݣwHo}h-W0Z!!!Y3GH7x8Z5-,I;`;=@`@ /CONCw3 *zRA;{xzcIkˎչڬvu5YhsV.K t3`X6~yio;5`om'1:]q}ջӨem6ǾizI/L7x~֩Cٸnm޼&7G?LZҷA<1߆O ^s׹V fcU4rR;'#(w.n 9wg%Nb/-MRZܹZJsk&[]wb{ek\s=zs+O) ]-i/%.EE8"zG o<$oTLDfz*j}tS78lkL2C=,?AQgϼ~ڿh{ub'ZrIr{V|HߊbPZ@q-߽ڶu|ʁ-iNoVlȴ ? n6Ƅx>}gӆ]d6%fpז kΏI>0,.*@OrT47ZPt3}gNqmiV#jFU+[?ɭs+4};UuvѮΡ?Nբ>+_:ȟZPÂS,ǟ1Sé=+_;HPESuz}IT5yS&ϡ9vb_,\}T #guQk/CfD䏆@85˔Ը:UY' A%XR\4˾BCR(B\ ż!%g#~n0ϦF[vQ\k1ǐm:hA*:uUų'/-K:-}o;Z|leęR_;s~t\Jg|o_x0Gݝ_W:f^|j&7w٦)?,{"Xڼl`sɳT:Wf=YչS̥ǻƹ ziVNNOV7Rg/N{oR kZ)VjZHgr l^[n5?pdeVHԷj-\z;gѫTª>blsg˓bjRO\xwp;eFݰwQ}^|2W~{f,O L4ڐ~>ڳyxF<}m舛AxrJ@ÕmK(noQc!DÂS7ߨ ^*y㔾~G 7bÞikx7O;*_?&Ҩ_qĒF댶j~>NC_~o mbt׫b͕m^{[822[ܡb ӭ| _\Z{͆XqMnLWg:l:5 -wa78}xǾV:>.nn'0ύw|7OO*Su8~sN}E,E۲/{vv9+ZV{W{ݢ+ &5nnfbËpm{ddynE}:d7밳K՝8oea㒭|y#Zd?BߠQiV_nP'~WZw8,VJJfpwԴF3BwhkE3s<ӟl0,mFʦ??85$ϊ Hڛ_>QfMm2l}̼.~yQ8"yzf=wmGh\&sO~tt]S5tif~+e1 v 3fRk֯#|]xhz2Սݖ93YC9HMF])BzR4S.6Kx_oOۜ]MrZ؋SrX\VDUE5MʥN7}>?n}dEBje6A=Qn"{6o~bJņyi/NSRR/gt0jQPz~ٽsOYmT/a|WvAml;%n[(l*Br6xGd޹B)L#w׬u "[o7}6}*W">Xx|?>S8X9ҏ9xz۹_-,(m_VW됀k?-nG2{&J ~}}eC3i^U[<"'ͫ}9gK7 >L5\(2_n endstream endobj 2245 0 obj [ 0[ 507] 3[ 226 579] 17[ 544 533] 24[ 615] 28[ 488] 38[ 459 631] 44[ 623] 47[ 252] 58[ 319] 60[ 520] 62[ 420] 68[ 855 646] 75[ 662] 87[ 517] 89[ 673 543] 94[ 459] 100[ 487] 104[ 642] 115[ 567 890] 121[ 519 487] 127[ 468] 258[ 479] 260[ 479] 271[ 525 423] 282[ 525] 286[ 498] 296[ 305] 336[ 471] 346[ 525] 349[ 230] 361[ 239] 364[ 455] 367[ 230] 373[ 799 525] 381[ 527] 390[ 529] 393[ 525] 395[ 525 349] 400[ 391] 410[ 335] 437[ 525] 448[ 452 715] 454[ 433 453] 460[ 395] 842[ 326] 845[ 463] 853[ 250 268 268 252] 859[ 250] 862[ 418 418] 876[ 386] 882[ 306] 890[ 498] 894[ 303 303] 898[ 314 314] 918[ 221 401 682] 923[ 894] 1004[ 507 507 507 507 507 507 507 507 507 507] 1081[ 715] 1085[ 498] ] endobj 2246 0 obj [ 226 326 401 0 0 715 682 221 303 303 0 498 250 306 252 386 507 507 507 507 507 507 507 507 507 507 268 268 0 0 0 463 894 579 544 533 615 488 459 631 623 252 319 520 420 855 646 662 517 673 543 459 487 642 567 890 519 487 468 0 0 0 0 498 0 479 525 423 525 498 305 471 525 230 239 455 230 799 525 527 525 525 349 391 335 525 452 715 433 453 395 314 0 314 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 479 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 529] endobj 2247 0 obj [ 220 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 815 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 488 0 0 0 0 0 0 0 0 0 0 271 0 558 0 0 0 0 0 0 552] endobj 2248 0 obj <> stream x} XT׵ f100>8A jр&3(0F"Ԣ1&ig&6-iK45GӛmIl'ZMn\36kogokk>$!ҁroڪWu<}ۿşi^ᄼ W:3Kܱx*9{+W{ cJk[7鮤%_׶5,~ M]ǫ,MP/@GqsSр7v;}GPr/@F3ɽؿs;׻C-h{-nW_py=m$-_ߛ'']}y2;!}C$W ԗO6W{pmRqG?np g|p eGKiRq\ 0Np`lB%q]&;ML^?,Dƹ8N:N7݄{jA o|D(S~ )>3G2wa'giBJz!d`r`E: ]W6Q+ZъVn)mЊV wmЊVhE+ZъVhE+ZъVhE+ZъVhE+ZъVhE+ZъVhE+cW`b)n'f직9@;  }&c4cdӉ&~3#u-IYD@NeE;3;d'sK+/7oT>?ofo]@p5W_ҼqeK,U/*[BoA~'w~;{^VfF\0{T{J-)1!c1GGdn,VJW*HVx$Hp8]2_n 륤aH"+%>'p.\tY_sD[pVt:$.~- dm@!sJLaddBqc4KLgQ%f$CaKjuI`yK;WIYn4Ċ$}(DV/A(fWD>='{) C^$ұUjWu 0mF2PE0Fpb} Z %ߞV$\57I;upJ%ʔldBP%# VEt%ޏv4I3! Bhhkj;!SVĮbG iuXTu.CJVwK1(?Tk ;4KSFcZj7Wѐx"acٸTd rJdWɛt=սlkB t"f?k;\ Ƒ/tJn:qhzd =Ւ5b+5- KXGё֚w.aj4KInYS\[`Eg3H7DĎ2C3G],PQk|HQTgZ1U:4TZ#]54l ֶ ?!mdU'ܫkW:Qr8?69~< YOmBjFpHzdѠ5x&X2ge5*wS÷W+Tށ.*q:y3⃍ؑV5}6:8ґQuĶ #.~啕=JJ=&H%ͼS(S*ڍWYfO]-髛Ge-5:2KyBQHJL"ɔxO)H" CJMݖ0;X]=,;<ή7N%HnbO3:bP+t`KBk ZS#'Zk&Se^ks>o`ߺcje"\fK%Dѵҭ\<*ǃҞcϴLzScc%Ysbcjw%Ka>nr젏]daٽz]Q+0G֪8|T1.GI;@=Am9w Qc~3<m#̳<y:c<ށ.hvaE|cKPk u6$ *s`]*쪢 ʯ70p BS .LL :7S2_lE,^r)"{4v4]E2ER) 5D)P͡OԆw1x8Z7]9H-q- N}]2*`C6Qhǁ]\EvтpU@om5&.~E;dN꺌h2 2DKQYed9◱E6v)U2ES\L@Rj ~BSU# 5i2ԏ<ߌW:uxV-셶idksJ§s3MLp;Z.eH4]ʍa!Sdb"-e AUn4d,)I(2d,Fȧ*q^%K%>QUJUߩ8oTJo[*qR%Nī*SxE%^RUbL%K%ĐJV]*S%֫:hQfhRX*L%U"O%<*1_%rT"J%*M0#?d1|3 f=O1o3|_3ï3*c gg1,0<GfÏ3 exC A`vľe FW18MW <W"l@A.G!%#؏pABEx9jV/jV/jV/jV/jV/D (]҅(]҅(]҅`U]&YF@؀sϽE  /_8q/O87뭌֥٣_F8pNN|9*uNTkF8'8\6u'I\t茬o@| d +6 Mg&}7O$ٿ#d 7SnCՋіdǖ[Im " t$9ץwT:#Vs@C)A!pwrp{؃[B(w~G=s8xw8Uz)Q݄!vsr7ۛrs7)*Ƶ-pB>rQUGQu0 @]ێus`KAisk&|0R~҆v"_n{y 'bZnpȭv%w%׀4s+VA4w ,DFsAچضkChEaJy@ULcz^!@8n!q[+y'K+92 (}fD{qe ?LZyA^rU-]-T-5}/Qb-RZAi yJ)mg- Uvc@\n9s3gb5qQ\4 OAkM3njI08)pF:c&jmj 1! !`2;#+v-Qګ7nsו9AwFN* >kbKO>|_8m+'2[(E pNNS'ó縎RY.9sʜ1#t8TfRB G_!UL+a6e kepwf*p03;7t1ɯ^׻V1?ջQwţ=y?H=w?xtݾs7}wsQmB[L*?6B}3_"+!_ߗ]r~W/I1煛ӹq?dmrv`~~i**);ocұAǫjL~xJZ3u7>{oG|:fֻ10EJGܯһ݄ ɥ?>BU).ad){P;;t/ CǏ pstRi\N?QnkmISg>93)ϭhMo! =HܻUnG7X:t4HI $+lbȖPh,|!{lk;ip><qqu͚+̎Uϕ-5(h`4YxނgflbÛb!aq3ysBX¯?E= %fbe91-fMI%x/0Ḃ==O3T/We,,,,lnٜ2lV^f+K(+*3ePm"RB=7UIU]? R^jXE8_ |p, Fx7Ax-'^E)+/!0p]v#B؉aB B3BBrzey9QF/(~$~(~ ϊg{)mk uUqL<. >/G!q1OS+/xxxQ\%6K*1V6co ?կ+L4Z۫P'i= 1"Z89X'L'UL ?D_7)mk6xON_^x0Y_1x\Z!+@9ztH¿PֿW\!XnQ>a3 H8W]mC/]ݸ:8OB? `4R-O؃s 7#kogt>G.}u"oϕ~ #à n" _a7Fx)*`7 rO< $ Σ\R>*sI?}=>P1 ǦEb0߾O_{8 Cf`+ϡߞN~N.Eق3:er[0nOxnzWlb_04N)f>̀Ⱥ?[wL5/B;_yn>@+?{[&T'0דxE|w&~jJ;~,9^*f [>1Pת3_ora|R}n]n1:]>3YWᳪ[^~cZu⽷{Eω7A@B/)̚939\sN v{n>ckc $ԃ:fZ z.?sWE9UT\-ْl)6WwS0$gMpU ysSZ˾P]V>#nnYa3&']0Joӳ2S=RW}c܂Yʝ魛Qn3'3k_G6>[A ^7b[XJXM7fs~&&ߨ)Jq^>^h#+ g$ %i/?{9RPIDz"Co|Bd|,.,* pJNe9 qbr2SQyJsQph|>-ώN%FsΪ.kέ[En~.=ʐ5s2_[ǀsTo҉w7#)咙%Yfs&e_y,G:0[ f7SH.}ħKN{&&$%HuyD9KtIKʹͷQ͚jZL9/F M;.} *Po\W{Eczip:F2?N4\s22 cRbV0)9oAr2 [RrzU].G3k풕췷 T]_E'eo/ߥkYpK=Tv\_x[Qq-[T8;ْOqҪԪM9[\l?aڼI'ϙ7{<~ޗ|F#H`BEIr>4 ;ZOa2EWx3ȌEP&`ܻ\WL IekeXgIg`gwo΂X]EY Qر:+\:LJW^I=\WOb@$CϦ3kpă5I`#c_YɊ:nn(?/ÎO 2>][ϏY]תѕWCl-ʵ#g!ʡMQ2#4bDVV8>^mMq~vC] QoURbWC ,;2FuSd`^І)|#dPhج_W(pYO)t4?7;ޤH*t YXc8^N(2-Ye?˴gM,ӆ)|2-Ye?˴g,Ӳe:FJ~n۱ C`Jtc_@ >"/l.CXܾ)#4QZm_WS6Ĺj%x/;𣜨T4) "}NFeyplcdLѤvijG^C(ǼFLuOwyZ8t'^l^ ?/UD6iOT"X\{,J˰v衒(#< ụm,B$م2aa;c/j؎\u!5pק3,oo}եkPvO ͣJՉm#ڙ! sԇE ~qc?)4,"Ct+1o7DZ6!4SrGc؂T;DsFQdsC,Ȼv`=.e[پުh~}Z#woLu0?3ΑYryLYJ^dn˴>cr2z; 3{9{`6]W0RFw2 &s҆--arln2K]G9[\RlSqqU)tZOQɻ*J"yNƸmlv;6c{ףς7Z)FF9ȼQ-;7fu)7HyjFVdqkxȉt^SObYQ ]u?z,șɌC.g*r]b+!ޑsY9IoO̘%7nds63_!҆ɘ,g{~ M}Xfv(&YO"g@rԯv6d,=b,V-SfW ZQTK? ("{:yN3;U[@}Qp靺{x5ngg6vt+==wӸݜ=eq [:[|^丢BA^^"{z{`OwP)4;!1 m }A nA Q'tQv_/({Ξ-B{O(l޾`wBˏ˄;\ai).`ߦAۨi(Yt;ʇm:݁cMHМN@v!nAC/;FQNy ^ di!~7L' :m5uClm^\;]=݃V)NhG-DVPNg϶@_?:}pO1Q1@=ӂ}H @g+Ѝ!$lԨh pI!%m^d";r]1}#FE")N;ߦ(gfBa昀@hAwfX܏ò !А ,`޹UU\P#R4ԴFNfjfjEdej G£%EA9*(522utqNd961٩)"B+s{+2f3ZZ̿>*YaEӦ i\vԌYiFʘmg j7+-ϻ:A6TF:/y$yelǁ~kD}j2u:U:eэܩiΌ,n_[WY~>mj_o %{N=75P6K\m<.#7;nƙޚgVs{}RgJSsݚbmUײ==I-^Cjm32Z;|ߣ JAJXJd %UYbiT$fɤ1<<}b'd@!iT՜=ҳ"~`Ru}}uݥw !VǞ̞ںQ<էq-s" JisQ-OzZfUt=Siӧ6L- ,SAR\yJ 7 <\z۷Z~zww =qo3 X9b5qN(3IJȑ{Uٹʚ)ۅQv0e8N,r̹׭PeS^>LىA Em*({;eX>I Jh"~ժl'&PN>@)J٧(+ۖ5[)HɔCBVPBj18D~QQF~q 0@&E] !A|ñ)3O;(>L5jTC 0%CAW??%$`֭!!JH;xuʕ6fV{^x[R8 DQB n44T Ԃ$=$ahmm RBW27O4>mA"(Po ҵi8vء(zRk=zXB|0?%JZ;JPuKo ҾX_X֮mk]_Stb %׋J>:Z:Ix֓vJDA9x7%niiFj99($X Y~`"B $V CX0﵄⮂%"d򕿳j !AJHpcnLmOJD)>  _ʼLM)p#($ &vP3W(f͜5F韝m@sx_ϧYh1*!be3#FxhhuQ}ǞL3ZMڟt,O=q4UOIbR4eSpZy3ŕr8ŝr<|IiӦOKOKr^ iҲʦH˚'HJoX?cmgh\89{λ9GrN<;g9sbywvkԜ{ވ _8؜#Y}4'q⥋O,`X鄜 ./,颥->$a{-KOLt Zd)S4hDQbфԢܢE늞?,}Ywr,mk9bTͲu]o)Pvk'["+Y>BV' "jPMm#QJqS66}1m6{l]Y):z̫hո٫Z&:J&$:Wқ{ ڄÄ9MȺ'ic{%xGZZ#y9657-9hG/ x'V.ݺ}sk%sh~f a \ijZ;i/\. _|P?ò8<(js:-hŭoeq>-t>~[SkiyFM7=ْg*n6lnsc\ɡ#; ؟}+ ӌH}-tMnq5-[΢o}!lRKW,yn}\xi-,ciUebUiQo NkbuxO }AI*99y,~̣a,MgY/?p_2Hf:ub,;3x&0 [dC<00Beȧ&^̿<~ ;1A}p; `cE'va Nx ^7dMԛ>Quuu) Z<:K s~xb/Dt^Gz7Fs?[aNx ľm8P{ć0#\I!Mp.U [A,O! aңLhYj:pޑup!>B| Je\2:#cmd6vYnB,4EX*+P$e\)yWsFVY.j k9&u{/ B ¡H`Mt7;It 򨈥!n.t!AEnq_vw0=0 p0 !0B< 4HTH0y мL5fAdC<00B,4Cm,΁ q7A ͐='^|.S%4ܬQr X Ja52xa- QalM,Tf`lBUP&T UiBUP&T UٍFUvGBQ|T=W547ߢ<(Y6D[ fB&d UqGs=` Q AaPy4RX k 5z-zn lRڣEU2;\:oR^E_"ߡor}rv;||>qp>:Np 8}D7·py'./pl@EPTm@E=T mBEP&T unT mR;MjDݪ*F0AG]QiH{F2jcC|̈.Y+Nw[e6[1iLΆv3Y~('?-c9A9#v*_Ed}7B6̃I_^*xW} H+Rod13iuW};Mάb9oy^Z^~h{%[,D_K5?"o xr%A#xʯbzc)4*=A˫(\)$&E FJ;G~1#1BprjtS>x\NO8=tS#FbKwL{fn+@m\7fc4jFrZb,W[}#qT{8x;W|AJvVer(]I Jīa 3PNĜ,6򞵉gz |Z)Pd {g&og'IW`g'7pÇw|p8S9|(@ID#}984Hg3Arf+rŏ-g^7g^7g^7g^7\7͍wssuGj{}E<𩬏 ǡNsY9sneߪ7A}7H(1*/*/9+UN*;uWP'~l7x L> xQyQ9)ԝA;S3gk5\99]TЧ%Hc3u:r`='u=lU+`3Tps8E*E_*Neݩ}T^C-'_p>' >E_WNC=gߌW5@#}984H?O3xuJgPUhm2ZkÓٔ-ҩlm%a;ahouZBN7"o(?E%_"A&!P&Fâ mQ oAxޕ֨=8 _E,/Fn8 <#k\3WQO)C-_/\ѱhRWiU _aO6|PV|M XnCIFHGE( <$Va` IǦno| b÷-6| bS_ 7Ǝkl꫔wF_7C}r?roXW >Ȇl >ȆJ%ヒ?3yw?ƛ~Ȇწ +>Ȋ⃬ +>Ȇ+NJ;ǎl+NJ>d|P2>Ȋ⃬ +>ȊAr|PlddI}Cr|5f؉ē c?6 c$̐AV|d!IߘVgk|kZԢ>O-;UˎeԲkYYJ-R-{xjmZ-]ɪwD;Z8#:A<9;6qvl؄&y$6Rk#%9巗+`JNTE)_IOu73r]6D{Ϋ-iWECFsi9-e)r<]+C77Cz/XLK?S%4YuJNC=W547C!޾x>[!c/l0VVAyOR%B! "DBh0bqG҉5 Fp}Qq1*.FŨbT\Qq1*EJw=p/<C01c0 RA2B0Ee)S%4YͬbV\̊Yq1+.fŬbV\Qg器 ]tB;h/ёAv.#y:AgyF=g _7[?/J73ݠM3F(3҆1hH;+JXdT\iUbU\w#_wu/*q{sݗ7~\ { 1aBpz12?D`̍q,07G1'`< a $T`)`:̀tȀ,Ȇx ra60FӸ<"X J/̣\b`%꿍Uڱjߎo]XKLȄ_jvY5]Vz%Íp4>wr?ףFr!A,0 0(]1_B!/AQY X Ja52xa-M !:ߔagWGɪBXfEVtlJΫ;w []CQb)U 9S@  5 9L:Vku?\W7^F!};<=;WnJj`}q0 ~&f,G6 YkRdL>?(LA,M!܇4Si Lyڑ֞<\&J#yLdfYh(Mݦrl~#8IL]ӕ<&;f _O n!_oL~{?cRϝb 4C߃}K;#x] yI<)0cHKtGH'M˽{&D'IMS'S~q ϑ iNK'OĞI {6OQO.v+&+&+&+pw=MpǦ'./pxSQ~'D?A(oCUBm(zDvNۉz;Qo'Dvہz;P* B(vN؉N؉{P`' @(p Dڛ?( j[Eq((J= Eن((JRPY&BCy6Sc~KTpFpNYl"dpY] QEkQa ._/K@&EĘD)Pa JFNvs QE)f-CZGNĝ~#iqЅ(۝f OO{AoJ|yb}@V; v`0iC߃m=<#Iĉ'QqxҟM"~x2y'gyRHO N' Llςlr"Εk+0<ẞ]e7n j\ jmjXa +:VX +,7VX +,7VXM_V+,7VXuVXojZa}[jXa j a%\s)aa EZKx\u(Ģ"5*V(.ZBm!&RR%2En\wխvw?u>PV;CR =LNKDz73L7IF~Vu~BU76Tp/TJ|{ ܫd눩GQqފ;3=*ZTAwٔ{;g놽vJ;g녽vfVa{TuŔʺQe S+̬#*갊bJEUԥ*ZTAuŔ:SEQIUS*LTЍSF]٫bU1k*fMT1M#*p{ﭔ3Uʵ*eM*)rJ9B+VdޜlVK6Sɐ~n~ZԲZP,jC-wR =ܝbz)[M5sf̡! [/g5\@=g,ֿ-Կ-y-3n9 tU98ӵW-9x 5-YԴ. Djr{޸g[I;}z0]sfٮs]yImm!-i-o=8o,u,kt|N_SUs5wyw~k1{}}K&jFmѿSR롺TwMӻIy(z7fQҷзRa WS*Esp^@PT8/=}vO R8/_*NeE+˯XecDӨ3^}b\J=T9* S.,ScG&Fo Q^?(oO/kxjiJ-6FaT5ƗƨiF(h~2{޳BF(d~1^3k)ak6ce~2lG3fvln4#fs1K3{cf bF{Lm1Kcfl43#a Kƈ c|_7o_*#">&cWE;ݝ,m"FC~hJ,,YS~X~HM^8tjHcYB-vY[jzTfnB-vVf3c&/vePC~Ȭ.5=B3;NvY^j{TfzB-C~H~yϓCYu顀yB*'+30K!y?D+_/YyZޯ)eSBJG)!y?$fŔQm&~HޯhAw!y?4%{)jqjy  !J[Ji=BjGmjyZޯOy )o&T/SMt"7d{7Sgcd}\Rn3pwJkTJN{6et=ֲ҅TC^z*QR*]^g^WK.vE{=\*=JUSJe {JUSJe {JT;앮0u^핮vJ݅g SJWe ^\*U^\*M٫\Olr!76>z*QR*]?ާvRTz,O,UػOy)We >\*}Uٮ>e/Ӟ`_z6몗SbO5um-)uOk_zϵ6벗SbOU:%ʺ/Sb=Zu)sm-/ujUzϵ*뾗S>W>ת _NN:%)Y7<U<Ɨӳn7Rb>P֕/ϵSJBC/JX|ytk %nvN{:%ֳY{-%NXVe]rJ<SJBC/JX}yp`ӡ)lZ۝>փ3ۂ;RwS8q٠{zr`ݒ3nnl3I75^E=7oʽ%n5n`\e,0~+p&iƵs~?O*ܗ Z-xԸ-$n fCP;$v)[OɎO\ʌ3j؆ǒJ0d4[U62iOS,/&+E&pdo36'G{6ndob;3|w>97[3_n WoMƧ.Uܷ֖˝d\\\\\\\\\\\\\\\\֦=lO<nz<8i{vy@3^?g|> `>5LUzbF$Χz* 皏s ;Dj9[`.rbxI.4^N;N,5W]x׸n;ɉz.g^<8;s u߭ǝ[O$gK?}d`xRꈃ1}G'syr-zї ,M-G3܊6| Xs S |JV|X V_[m7 Ƿ|'廎\py6#܅')w?ý9X_WX2~ Fp`Qxc &U<(j؆qF^6I4ߛ P&y)O;]-ɫMjMvd'Mvd'Mvd'Mvd'Mvd'Mvd'Mvdgp`k<Үr8M <ִ/mA`+iݘP'M6Ѧ=dsp?im1j1YWvAuUՕ/KkK5'IB/JFXQoelԜA~Vg*_7Nr5y7ރ'.A/7~KA\qnYu,-F ߆v,s1h.+2+Oҵ;ſʿʿʿʿʿʿʿʿʿʿʿʿ-C|UiO>5§FS#|jeMRjϱ:zklo0pROTOTOTOTOTOTOTOTOTOTOTfE9PqDтxf(јW 18qx,xNx#N84xx p6I||||u`Vp.c.c.cbb.tmӺ5UbT݊[Qu+n׸|׸|׸|׸|׸|׸|׸|׸|׸|׸|׸|׸|׸|׸|׸|׸aV0888Uҿ&wpAgeO~8ΒiOzմKPtxմ%)7Ux49!jt`:vq:J` iX-hzbev+q8XJ:¾3ٝUyw[֝]r4;ug<]Qvj%‹{`sz}:~=;w}"[c8\w=>%^\/n7~78A|qnY? ]kmnw]_ s*f"7ߠ]w׮k{>!8d}Cq>!8d}Cq>!8d}Cq>^QWuxE^Qw+M|_*-_ߣU| _70? %k2w>eҝY̝ٝdܝsE.΋";/E;/EuE]dt.2EFH"#]dt.2EFH"#.]E.]E.]E.]E.]E.]E.]E.]E.]E.]E.]E.]/t_:K/t_:K/t_:K/t_:KGt00#p$Dh+0GxLmx x-pZ|<=p62W^8,ezql". ]{Sx2 ndOalMp)"4r>s=s|̧zݴ:JFOrcp|n~mc[}鿳2*r]W:.qKt\D%:.qKt\D%:.qKt\D%:.qKt\K9J՜]>?o{gSvϨ3z;m-`҉讋w铻h8qu^'ʜh8('ģx('ģ>O+>O+>O+>Oua'c;vISx.,؃$hBf1 @  >:>:>:>:>:>:>:>:>:><| >:>:sQ.9%G(咣\rK|,h A[7xF=EI pOoVЛ)*C9E}NQS9E}NS9E}NQSEYE}NQS9E}NQS9jQS9EZS}=%F<0[l[P#HQ԰ x CT؁'Oixxcфcx C[TcGހPOZ7Dv|_@wGG0~38:].w4*vg.5w{j ϱFRӝz-7m OJ]_u'R}񝍽-P\ccؘbjKIcꊩ+bꊩ+bꊩ+bꊩ+bꊩ+bꊩ+=,,P[ @q+,P^o@}1S_L}1S_7c͘o|31ߌf7c͘o|31ߌfL1SoL1SoL1SoL1SoܒQ԰ OuI4jnA-5.6/s\x.. uZ+\xkJS r-pnƇq | 8V$_#܅')37FT o Vz-hw<9E 0xƍKVWʓ )uqK[zU$VmY*H"*H"*H"*H"*H"*H"*6j6j6j6y;crO9t\ckj^ δ7 LŻy6N@ wVy"MLlՓ2.J=Źw=i~2O&?'dL ~2O&?'dL ~2O&?'dL ~2aU[Uyl][VU9_^k /+G#; 7]ixDgpd>]Y2?.`[*Jw!Uԥx1cN<{x53V3c53V3c53V3c53V3c53V3c53V3c53V3c53V3c53V3c53V3.g?Jn/]k?L')y/,UV粝ԙ&M-O]O]O]O]O]O]O]O]O]O]O]O]O]O]O]ԅJY}ށwb*\. CPd=p-:z XC}.i#TYt6[cUߣ=ZUGU=qUO\WU=qUO\WUuI-llO֥ZعM;|NO9[ =9}>Ji%}޺FR]qdCӡo$so7| >{Ͻso7㩶NujSiJ?%ƪ8]_fC,ƊvI if U\yx+ :\$'x+ML t9͙fˍ?#nM#BM'?FtOU;INtRtnmv6flwnmv6flwnmv6flwnmv6Z:Nuzk^ ֜771%E.wQb\WMҟ%إ{)IezXa.Ű.Pd]N\ޞÑL[™4vOxwk\Kgoƛҟ7b2Q:JZג(9ޒ*ISx.,؃ hBf1 @ duԳzQ:YG=@@݊MۓyM;O}Bi]']OFtN+&|Q2l d `~ST:=uɎ{ ?z- [mvv&jl~J2gӽk>#& &ѯMQ8}IWt?talr\3b<%ɦ h j=܏06O'(ڍ <$lDm-Vz{^Lq4YjMΝ3qkcACx\X:Ah8 VBjL1ƴj.e-s4Us;ĢZ i6l>9#0GFvWD,+;ݱeu,Be*PYFǢR͕օr\Ÿ WZ,M>ʞʞL!M4tH! 5OmcW8N1)qۭuV>N=8 %/K4]|iV<ʧwwc")?^Ë_]wjxRʞ8_E _;\ݲޤ%S~k,fv?: 5fIvLzk2ۜO ̍N5x$"&6d ʟF򹮝gڧuSot&SLBl|/tx9rW-˃EA3LT/ݷO*-.=qb `Gx ?M 5CqqN@KC㏼])k % ?S 9%~I., 8F߯Aa[Ɂp3G𨯯6:'}j(<*Kf7y1Ǧ`|ϳE?[V :Q_s#Vx]CiGcwxFPQTοW{kOkӨ:pOڜtp0q(KbOy&zz=h3\뫍mxs˃'9>מ76ǹ7-I u&v>\;[{mB%tܝDT[|ҵʥHEPTq@EuOuQ6qtHDxk9M$2UU*N:UeJFUqeWy\Qs;|ddrTھnyS#[*[z+Y5g54jFӨm]k çQ Rx«^jpecEdiiWS=j܆q3A>*I&#]`<Zq$hA+^t{q& u ^;ٙvv]|a^i^i=\y ȷ^b2tbrZkrn=xޏч[.1vvvvv(!Nkc }5vej8ّTU#-i0SΰjTIgYYVfU\DOksT9G9b.1-V[d@]ņ#,Wbqѝ'ʵOԵ.8ؓr<4W}2ݝdVQx ޔݽx;mtzSۓ_{sE.ۃ[z| _70(7ZYI{.jljlkz+w5t>9~;k֧g+fzD!h\0(ctY"EW@sU@bʺJTTH4$NB@D3L/{tU醇IIXݣUhOFbk*/hC?rjQoziZoXƨ,ie7nOo2!p^?Jz|JZC"q}`l[Y:s,/5N0eCцnxb1lhq6Dhr6Ս~> MˆeCӲc/ܨl&T6jj)i9Pf9;xiXMki'jLY3k\j %gvRx.rx-wrx^-Wrx^,rx+rx^+rx-1qxs'qxoqxnqxnISv|]kv d(Gj6( p8S'u̚Zʱ>Lxv}4DeͻV?Xb1g&ؽ iffw``b0n1,[  F-Q`bkAIf;m4+ gz!vC8w4yZl݋?UNap 8[/YZz+G̷fMJ21b"Ŋu bX:m/UW%Hϡw/{S;>t9ΌQ"K.Ccۃso{ʗQ;@ICzhT@src5;ͷ}\(M('=(f!S'JjM3Eg'P$:z`?azijX/ı=8w?^J7i,a۔jΆ$ (\Ls)O[0WQ:Px3<#Yo(^y,.CJ` ZC>nyqh$s'y#NG}Zhk\%eR+P^UP뚢E'CF=`,4c)K(\ [*3=(?A{_}TCj1؊V,8Kmh?T]ہN\'R՗U!xQ7P7P7pP^<2\mJCM# R4M!ES{)$i IBTHC5tP߽H{'%m IBTHI3-@-z)PsR߆ӳ|gCU H& 4S%JIV2\Q*Z-C<7S.Z.0}.P%};w`=kX܂%@S)1.]$}/yٕ@?g|u 6 ٟ=(G/X`W`"0 x (9h$_ɗrpACaGi,E:,E:xG\я*Xa#p]?u,hpf@4ph| h $|:`;..8`Q/}Lv*j;NEmSQ۩THj$]1t9Q#~ԈbkԈ5G$&PjS!q*KtԑEYX{\t.:x JdݬD.kk7(J>Q4D m@@~QZO+G-x_ 40 +Mi% ( v:%ĩ~\ 1ۃX9PŷeC[e>[;%7C3LU$CS$7 @B`9|pXV@ Zc?:`#vz7D(zڼ/}5y><@tU{b ڌP X))RSHwbSx<`?'!8 <ika~XtO0SZ{ے'ٖ< vuz[B|aYEQ /=ڣd-4Ur62dՒ!Fy`e`@pѮѮѮh|m><_A kTg먗Tj|() %$!V^SM ~?[c`%z. Vby9lwέ55ѣ2Pw<ԚUZ#>^8Շ`S;< {=RY`,<7 c?MPz,JE 19 3pd,ũZq-鸖׸NWrU˛d~[dpIBZCjЖ"2 A]kaRl)j{s}\[}V5^ W$}\ X `<>O}Sգc|\M~I>o>p)]{d<O I99ʲy'}H8#}H1~}G~}G9 }Ex^Hr| . }B0@!PmZHF-$Rq?ֵ^}zOS=f%CVTL]Yr3gB9Y3ƏR#Y35zBaj%=vAG5T|F=dUrȑvBɒ1I'#% cdxR0~V9Z#d|b`1W2F>)h=R0Ѻo(Y'[L7#* 湕RѪh1;Zu+U*TX7b7U{G tn?nC?+*ηux+ mOA~~~~n~n~z^S/~Z=3X|:cXIK/k`CJ2v^j%ڒmɈ`ڬ[X6 ^*"ZVBoVq^&uI`$f]e*^Ex*^x̛uh/ZNjuh/7)3h)RZX- +Bb_-h#(vuY[Y:&#Jߪ}srV+yH@WDֳb99䨭V5|xcTNn ;QZxWJCYufʙ 9sܭft)zY@ۗ#GZ%`Qx> <O+]Y^x/G/E$4~z q" ۟C,XZLӶɊ($?67lB2lM3u0šGˇM荞GY@pKb["I7G~%ZQJCɲT9jYBZ%9.>\F U|g!^ }KN St Hc4jd-gW`, WGk8342IV.G'˔G=gC|!>\]FWec||\Y>zOV=ħb>+Ї%V-P吼Җ{䬬lZ6z=tHtHv d Y Yd{= utH3@UdKWr5z=ǁ 1t ug#oAW WPOHd{Yɐ8'j/9涗 C} Z9iUqi-D" q%CRu-\+}>W=cGqq J/үBzהh} Z=ɨe(%NJZ52Ch+$j+M &$z!QUADl/$> g,I@4֧꺗6\Խ&Ϋw+Z}nb'ScczBb پd>o= %n{$u y8 jV8THtr EgԜZ "75&]h0,ϭ4iRo|>Z'c##D}"OT}*RO34}FG3,>KWsk|/z/>_?o5ms[ߠӋ<_A4<w"=?$PtGDWѕ$.=1q MW+FZ1Dk,n-F wj.1Bk/ĽZ_:/RnbbHzsZ񂘣]#2rPhwuk-Ylķb#J}b6I2m8,~GOZETjS дNéM3tҞ4Z{hcfl]{a\h2zkګƕF_5_4n0jo7h;c1Z{c<-7RO,m1ۘ}ek_s m2j;%Rmx[cl1i%.cVf1h^gr8ںv%8ڶ기:z^ffn#}:KCqGr~CG++sݟ9>r 5M͎V6:Nwcc bq5f{رljp;My8fv19*͋Nf&W:WW;י7:[;u66g3`s52G8ۛI=8>~g's3g>j0g8gg}WWם7,gs:ssorsog\e:o1?18kBWfN[]fYiλ=z;ssvC;=Ý<#<#zIv3紘˜B1cv>;9#p̏Ιm|UHs͛4.VqUlDemD;`u>9#x?"( ۞0`oĹ]R(g|o |KV OW:, #F)d{#uce*ꞦjoRja锂\9GxYr*mQx֑f:*m@QӭA^jwe k[Z:R kc{{U-)'l+7tP)E*d#k=WCW:N+lc3*VVҋ'`HSglQ4UߔP[EUǬ JLʠRv#'S^ = yǯvXXEkgǺȭz<:t\-, 3,!'`PȂc]Vf0пv^'`PN zV.xvڥ@q'Qذ)_WbhN~=XwFEn%aIsyΚ XjգZca 5*PB5i+;Zm{/J y~%Sa_r5Gybmخdzտ6X]=\_+qƚz(m )N#_J] 2JDž\X7_c@E=Ě sk҄ ,uuQr[ HZ0+"?bUK'ʱ̑b̪9e.R6-dWU }q~Ŋ؞Zy܊{E[t"ݰ6[U`]^P,7ܞW?AunuwKqnɘ8v]kLoSjGJ+*(X[TDZ'brJ@qq]G(y1|U5ΔWpTJzַ>y1{Bx4:eQ~ź[qTiҋZY7OyycّZ~T5z"|N6ފVqZ_ƞ$k~l{zLvh*[BVbecMRY`2qRUdvg<5VOb5@C*e:B.Rr,k8ZHMRa0B.%3nwp!s"eTjYΕyӾ#c ͜{g:ʑṪV?c#8f:]eL%zTL.S0D+^^YWeN33Js{0xϦQYUO[o~u,Ya8ޚ <7z&0v>#52ݾw<7/||[-Ig%凬3W(UY[7su[3,XpV*X -K\дAeBNg6(/PYYMKjapfweKI&`o)'Z=;e-'ē.E=kPʶʬ:(~4oa}׳WY1: C֭|I+1qb3n1Vk. OWgepk$#ڑue}g2_W/k5X;[Ciӭ4kf3[}WR$\C'1nQ{o;ПS$c9٥ȧuǭUw'`ڥf[w:u98 sT C=I,/W;ɯ@=W1@>רcUԼwƜ䳢 kJ5;` g'sU mfd=/el wE*%UkyZy7:S5V,}G~Sa<\_>-UC y_ĜCVuq_Wv(MW[6497D3VQ՜yPyg/Tl l{Ծx"k]/[21Dn<ɯTIf!]hmJ8ҭo (Ldu԰.,̦KylLykYL,\jq]ZL EȧՁ;j5[O`WUZ{| sT=4hǬggDBݨ=)[ mlgNu yU{ޗy7V=gR1U~:TvuִqTbmބٽ+h=Pe{w# tv;^$#؟{G8ذCp 6Q_VK|K_tʝ[*]N}i VLj~5߹7Y"*-J*FEUVPVwPmk uE^*V6h^DNԨ(owPEy[e9&Dh MG4&lz%T@=&*ELed5at`Gnt]"vNX'{v?gl ^f l;Vo4hzIzF&So4z4~MWox5#{uLo~uNQ(nܣ?1ü>A{5鼻/RϸV_q׊X~z+r'x(:[1Vb|(.ww|H7\1PĝN^"߇a}}\<$bHTƏϊB/Z?A|]+6-[v&k7=b6Pmz`_i~Q.ʵ[0~/~?i_ Mj8 6L>#ƈՒFgm=~1Qbh\͸=a7Ӟ2n0n֞Qox^EOS+ czE1ǘ72 KUUmX}ecm2[773͜mxо53Ӿozж/Ns\`fi{bmVj1h͵ZLA;`~e~ot*ϵڏg-ph;<Qf=rDg@A(5B01B5AhLMUh{ ՛dhE-a݊tr!XV .Cjp/UyDhb6ԏ"Q;_gHO] CWzꃔJs]ro!M- V!Vg7B (g$IQ>IS d-LF!qhB'Й@'z4.4+=Ѝgw&'d6CE "|gEC(9YBRnM"e9>]["=VC5dzSӅĿ8+lCDi'F"h~GgHu,88I=Y"z`MYSrf5b`&`ZԜB f0L֚FLfR[ae1,gmXem/k5,Rv>;.`Y TRvRMP@6bP|TK0P 7%].?7GQz2{?AePd8JLe8w s_fW+ԙ^l>{LuaoԕeHζӍlIײ]l7enbʡAv VCH#Gu%D׳c]~f? 8;_/HdHE7p5qw Nģxx#acic(AacA6qj'm ]CQyk>]Yv-t-ŮmszVVS'gk=tmpŮMHچvN̵u#9aɈL|z+ WZAvRwiH6 ؼ1 5c(}>K[HWNGGWQ'q$}䁥Lv}*ʅiϠ>t|'uџ՟E|>Y,\3[<_ByKTYgא|}>r~]{ ss3c13~;c0 и 1&$IV$٢|.ߛJ]TIBjBVBVZI y̙||ni2͇̇qR\f>OOR4J^n.dz?c>+gg\23C ϛϣ̗q++T||鯙Q\E1s4Doo!js5}|W\gù ]s=rn07r0w=`~i~kOW9h~Cx/#8+kọ(RLըLT k,,eud TOJҖjɰD##2B;eYZP f6 H6 o$Qcl)M15-d CP[oMv=vXl`YvCxy=%˩PQr<Gʾ(8:@DAr0/ PPR9\@ \"/YhˑgGgiuT9!&y,oEL9%^ށ|\.!^wHB;\(E|D#,G2|YEyI"_2\蔯# &-JX-W#yʵ8|:j.ߑP3An@Qn=lPfߓmߗЊVVI+Bʂ"z4.$u!k]H9ro-X+Y+>~e\ʸq Vƥ[2n ]<)wbo]<*.eP#^* NJ*GJ*'Tx{צ{O/bMb/ajFKˠA>?%]%t ӥ/Q hu */7^ ŽkK]PEz5{(a/-AA߃g>.D./@w.?Hg?wO CweJt}j?Г4{O#` +|nC%Wv`e4bGz Y3Xbn^eޗzz.zun=&'0Prshx 4}uh֔nb3 ]Z?jtHftntG \4!lC@ PPc(ʹи񑠂,Ph6\'k\?P˸`WWR0~1kAɡ/ptc: PDq-`\f fLc&3vP0a03f.ff0"fF23bfp3Å C13\p!3Pfa 33 af8a3 CDȤ"KdQG#r RHC"-l#D:F٢T"At@|JťRcJNN&DyrX$!OGbXLŃA'#|B<ω)ޤz\T,6S" )ߩب#A55@0H 07  _%T'0=0zn܊pf`gR/fr0%MGar|F~ RjRZM%5VॵHԴM*Amm(=vR.09`=`@V) +g ~ )_7 ,3`"}UB`g5IX6)3Ta*`*Tf3^Y+fbs9_X63XMs9qMb}頯Y¼ݼT0˜*ܕLU44e1M3MqT6STμͤd113 e3 ʙ*,rs50O9O6sN6L6Ko K?L/a<L>-|JA>>QE91PP (^/#叠pڃEc1\.j.z| t43R0x/fRƤԝIi4R&LJLJ]3)äTY3Rm^G `RfHVw]n~ ?;# WE\f y@D#S~)DyI)-rVJʀ0+줩)IDMԔݟ vavv *%Q&˶%2NpTmJASVWLLUJZV!M&ȣ*[͑*JUUUk2O 隦I4a[(A3U?g*h D\UUua]`]j C|5ZZ9`kהU)dʒLY2eeϔr;;pf-Y/b-ddk%I+IֽTFiiI6:J Dx~hR6ACjOP=Þ--*߶ߦF;;@{>`/#H)v%5BJ(A T-*B4HET$V@j*RAuDN3RSQ]u:yyj1j WSTI݌ߩ!ej6QsL7)G2@>BM]A"\Xb|31vRϨS^A/W+Ƞw+sHv{^!yDn+uW_'dW&ɂ9ssc&.LLeLሏ121abl$| ccshƞ×Sx51+?}~稨=W>ݪ~_7\YV> =؊_s埞qQŇ\Zxf~L-J_?꯿U^?*o;> ςoط;᯽Ԫū[YQY73fq$ł|'yyU3Ӊsl=+͞TUWAc*gTJ7vnUԧSayآ~6D(=ⴴď>1쟘 >E;co{{_"~~{^F+{>>S$/t8N_VOy-_{ZOϯ_Y:ty/ۍ,3#e_~ZY߫k咪/ *Ic!]ͼ)lqb"Uy͏%LGOžuNFe4yJ}wmڪfUq=?V|/5_Pz g}*Uu]AW?: 5+'E4M)U4ͪ>"q?5ş^JT*Yi4yj'^/RGx:7Y)VS.6ucz]l!6t"R/:6֫cӹbM>/iF|CCQQIձi8{ЫcE ȢQzlȦ1Pty~! 44+v`vҕzcW:J4YtL蕎iu$IBPm ykBgCn!Zz.d/Q`wzcc#zezcrޱ1NwlLzTޱ1Mwlz OtlܭBq^XfCzc Ʊ^xInl*kѫkƻzucc^ج56D6G3>o4E>|no4>A5R)\/ӹ^ \/3^f^FcBAMAmy'R>?!!JaĵG ++vj.P]RJSiTD֪NMU U,EUQjĞ%Vak:*WQ=n:΅MAzCU!қ(Hh3 %T}B aqPr;gW^"%DM`zQDrM5U zj(9H QIؓX W!u j4΂B*u$0E]G!5M]OyuNWQ 5Սkbu"whG" GQCm:l!ʋ|B$j[ʞE[ʞm,m˞eۆ=}bO߶[ƞۂ=}[oK-aOۊ=}[o {6cOی=}o3m^տcuvuv9rj]~lnlŢ-r= 1:]nv&!b;RhuL\{/W41A\1 ~ilSco7W4َOxP:9mwmwmdݘmw#D,AvMK~AKfdɖx6:6:mtS9"։u;]ĵzĵsl^7a{6 jGjXV;xc۝+>ՎB+څ a@J qmkv簇t-&[p-xC9@6 9xxd_Z@h˞~Y9l-n>խp j +c+_|Xyq[o}oU>rQu`a T]V*V-r/m}:KeM0OFiT7kF" r'(TK^Y257PuQ&k>buАvhZhob'/>yy쓗>y'Vn~CFʪdzP]P'Lu63]딺Wz 2S tn;V"GoS beqWc;)zq7"~vſN%W+9qxxc9ScSUj]DN*}dč~qbzb>]18_%>x>rgit?1:':ʝ}Oߌ'^4z8pBE֋⹣3=BW'$>=JF]w@"-ضX焊5Dİ؁ŇGW>ѱcGp-ݱx~WMnnqf4juFw+s/'H,7'F%%{- E9 ѧ8`t}t?/? ?: bm6 ӠfubJӢfĬMؤxTNY(ЇRNCr|R>IrArzQǟOb$F =hiJ7J&VZ1ZYPkQnMQa-E}bkq1zzf-6.v[{ˠ'!4& k\04}}q=TqRؘ׸ ZrqPn#FPq7q.1gRW+JuF]6֪kյۚ9u͘J_ݫPK3z\-Sˌ#IZ5Q/JzUZ^)zԻHSwE5YF4Q߆ JýEyD zGGscDEx|J?|U*1(|ux7j!۴JGDa;BL Lsy26E"Zf\LKIg\I<>+WuMoJ[֡Qyh%,A-lRg[U`yt}}'}<~Jtm6R쏌Tߍ4E#>Q=On#KScK>$3wÞSgmwF^9Y\sЇ9j \5;vN/3x>ΪY0x?k3Ne9z!g;vJ7g|?q[.Xv:{/DTӈl f"H#"FDDiT[դuVխ[a0,ˡcADD# 21bDDͰLeY3YYtVz?/2<3{K@6uOۋm8sQ1/#иܓ7죋 ;(M;Zm,s]y=2nGoRorCTVm Bm,VF'E7Rl萔/?%'scB)K~43psQWAt;z=m\t:V kD8\:m<a}}c X7V:]g&@y1w4}}4Vj6"[cTI&V|Opj̕j]w|*X5f4ڹSA{{W#nVEś/r?^rU!w}a͡S)k k%&ܗ$Hj dI8q/J9+H[dt 55dٌLpÑv4[G/G-4hn"h\q4>em60nG~e%%qޭI31FD.0I\ _!֘%JhmȷYAe]>76V:诎/GB|}dO5z6r+D;^CA* ?3l"TV<6Fx27JX"C ^$X,0U̠w*Vd""۱l_ث)jY(r0bRl0:jJh3X/؋scǰyn+R&&:#ǑR '֤~J W&,oDSC03yYKRT&5dSxsp k#-T*HR̒;+!xRI'[{4o%65lg} \'#ue(z7@AzyꫀoMJ;↹bfۂ՗Ƣ-}479DKd.*j1tJaҘߤn0AUP R](1R֪Ñ9~Yp,K ع.KEMl',MT5]#.z7GHmVzɤx ‹%R77u}Gv%=#!+oL; gSpr8#|EjpS8Qϧ:2:5 ?ER n2"atOIspT,`d0 w 澼@Tˤbj2=DIzAtA9ttCQoo!зѷx}Oџ" П!GIDwHczS&A7TBRT3jSѪUGT;]$[DT䪎iHQ5ՊT{)Nu:#%TTo)MR)ߥ2 R~Y2I+WrWfBݢnA>nU"6uiuR:3jZTٴ}!K~|~Ԧ(GJ{ Kqڏ/R7iW33%Dtfd wՌU?{{{ݿT.'~PLX'6fbӏS#Y/Q ր޿8=y1 =/P Xpo921 $l%eVjB_Jf̖f $u\a@&YZ%t*lj-_jIjS"CFiTp9-]%M39c:LW"\Ite˖3>c[q$ XB^i`6pYX"̎8̿D"6pǙ9v< <mY(%Vό=s 1s[ Mf{ < ';*F¶tgoK:Axf 0w&,n[ ^tȼ`)̮ݹAKʩ>P0F>988 AgS`s'\XYG_f = =e%h1ˑZ颔oK\:IR7A'RQ#Jhֳ#*vYH8 +j Bgta-7-Mp^2.YG—WVgUщ$kVGI$tC*$ZuLs6Zft.9]CEbcI^M<ǴC [dmFlg3\n|O,?(tZ䱬6 nۜ(+wlp$CÁmm eX$gw7P.Tn(k\r^r$K⽐ =A d}˳\2ijF,fl *Y eH }jkm )3Gld3#AN~z%Jz4Vzz69tVz LNpz 6ۜJ `{fbd}m}VaQDDf/B`54Z04L r噁8I[ 씴7 l:N`f0^ #6b6c?BcCũ`'8g> Vq+Cς+a5:1-`u7/">;\ NG< nwĔ@ ul2XȾLRAR:vx6 sp㉴'Tj>nce[̈Z>tI, `,P(ةPS0p1$nX빆Q %!X m@:=]Fl$6MVc̙/> rm&K R$,3r`P(ik@Va BWu|XT1f8"ba(ۘaп {v&ކݼA:%IxЈ3 a1ʿ E(/*^彄|J}X-/[]@$D q@o"Dn#BʑE(@WO)_èBYG>*xG?~p?)O}#q;~LƝh;qeqqsЊs;~}995Zw.yv6ȸ}EV0FYD_'$O5}2D 3mQg3ѯOD[=>uEDjT30zCVb/bi7 c광o`Z)~XN7Ӿ}4Ҿ.ߤ`b4b}Zs*Y>#^ZFgeԋ]Q/9Yjdb/c_Ob|KkOb-vWXGa_=s~kaCV1c"ϟ'(vvI9/j_\m7F#eQ23/& aam,"/c_Oa^ذ|Kc2Fѱ1cQKh)l\h}ؤ֯b~>}O;K1>.wa?tHA; 7-o':?t^^bK_ )~q}:}(@bW"X YR4 -H;r1"-A=3]! ^SLef*7cW[R$jS%fet wYL#aFQ#ZW(˒xU^X+89Ij=[i9ձef0kc#rVm%Mf\v pC/|5]Q~_|I_W} lBDhy}wkBD_Ork-7Vi-p02WhIۚ;\9{מUf| F߃b [%g1;t[&ѱ xmQeC 7άFz}[][|Zt^=Gam܎/" |WODsŘ!f0N laPrdW'-73̨fviMbNg=fKjOqp\65i~c`Y]oc[Xy t̊1zy3PuIؙ Ϝɹlq4 Ձ?#Uϔg[lllT6ޟ`e_#H{wfl좍P.C[.&d>~ڱHk_'{/]:3tzXy]L$Stٽ#5\'I,rqntvxBJCE,CCnޡ}3hH41'ЗC݅tJy@ihOE4ћ&\!*sj43ti?,^dJbϡc1^j`3?d.7O:6戅Һǔ^fz:ks>edۮ{Qբ1׀}f;YZiC?ow,Oxaq>Ml]aǾj3SnazL(;yg3.d@7o;vy')iƌQ3lSHZ ͭ7w$/}V*M7FV[RȘwֻ$xӆ No Gk5<= @7?1A, c==8OޢRuU;/MYڈTiON3SKSsk~F}L3MR9 1uF=h7\˳"B$GO2ׇtSozOY >ד{luv0]6lZd ^ʺpWmӆ~ !ڇtcKl y5زk:4BOls&zvdױ氍d<먶-f2[._;f >וVB653sY<dS<_#u&]dzLLutsaĎ"FP3xi 9;eY&tjҕh;ޫK7I-Y'{F yf>\bItY` G1sG 8LkV~JSe㱾V2Am2lGFc1.6/00):杞,Y1#s9a-3GHF_BlLB:7;qI*ڛбh[ .X?q.X~=cowTn"Lj]({,3Xnq *scNb55vB맻 %tc<3wh'ѹ~̾fʼ:W!J`L"漣>ͨ]r{Lu#itUZ ګ`S^GGՙ*^tH9&OvbnMrv80m8ߢ}lǐآo:9wuMPx[`O-jvQMwث3nGL`5c >l2I;i% qDy\Tfʡ g s_w!9A7]ۢuJאGO;-IAmAAUwT2GU5u"Z/UD2UR귪HUO qT.CTIu9rQ5$OݭF>\1/FY`M߂2oU4/ wUNaO_R4EEaR*LIaR)L{`R_VT¤^&MPNC+ʭp(¡CyE)V8p(NP¡| Wt{Q%E?(gOe}d}Uz4>j7WB)7>_8̘(WM2cBeCfL^Q毜CϝG* <(^SO+:B c4 c꾨K#1"0F,0FWgR􁢨*?L =St+sW5?| 4W5n,NVѱeːUt%ML2eV}XaY2¾$s(A̱Wd{UfOX̞/ k̞0{+MĚ7=K(z_)z[g=;>-{s**/rRQsدk3Gr*.IVq/*.YVqU\ pɬ*2{YfUq2̪*eViŸ*>_[cwEK?pWtQ6:j8cJxnj«J;37N:r-#]YuÝ cG5rh᮶s֌C;8w߁ғIڥk}I#־vv^O׹gg#b'w}21rGq f5/a#gҳ D QE4}D$ƉUbx$o{Eo;䝀6> g)ě5ۼ=Ħ[]i+s,8NRaYBy8x9sp 8^w63ٺTU]URzZ|{O?^#8e HTXHgF :>I6?'8pG*&Jl-I™)RpOPfHJ8DBcT% MQ,wd2urTJ F[x*K*z, @;= 5⇔C`-UHٚ#'FǢn<&DIC:ɷ`N = +ʲ( !'Y_L1 U^. DŽa]p 7:`ǣUr]#L 8ɞ^$ -AOӼOkG. 6~7ܲM޴lA &ri8&824}6^---KVגE'Z0 5F50Ox).VEM%Gx[ w!qN5fy+zV4t`eԲ?Ň/p@thLl_s͋ I$P܂5b6]P`7tJDGُDbd%Atd&)FHVa?%dC43@H'`k4/G,I( LBSd4#y̵Tk08o^yhk#)?@$ucG0^4߁Z ::zy MaX7֛ưo1W ֛ɰޏ+bX5f1:z% aXa a ϰ^z fXo z }އ }İ^A-t- %Y?g)y4>Y,SB4bY&w./L7BX, :}):b~o'o_\J^Jā%ataݲvŰh^ cxrCP3PE C0,f  ayΣy.PRi2 &3?'L?D)&b"a&;LĿAsV<_1q?co8`(n 4ݟ0/)&vFK<󬃈yC/Y4di~zIKϘX_8U!w `;@QC? ?R E}9~ >Y 2 Q!p:m @j_;6ǾdYXW@XB]:G|?{v}e#c#AY3pM2Kf?Yfȿ_'XH,ZfPȮ1(!ƈXؖ)Ap}{qwhߔm=Vc[d<$'ڼַSu{ھ`'J'5Jup5QHXӨ=k-+B%u%zȨƢ=d1Rm͙#:y0QkF jc ֵ%5gPGh:4ZaxmWu%EzDa^mN9ǹnՍgh;cPVg֪P}ؚL"k%!_Ys*9G.^fl$G$"XFU%4*3ON0ywٵrRrݐ@MQLi֬éU & 7,c2Ch5PJTi a=2vhQ{@f}8ި+߅jEL9z'Nñ!I^h0["!QH:A.FʲEBy[Fq81j8cq6h=!:gO6LRţ t 0.%. #G{kEթJ'9ᴀ2 Y#fl`38ֵ_ KH%33d!O  o`^On"K?K 5.lRDȆ*C`?)PMF2QN[ctҠY1-S".j [ 4!vĵ$64$VM's;$H?Q=`KpibDfj9!Qx(<^'CvK7J Ýf kcYzj-ш"\/j(#*y2ɥHGku#"h > 5IjI$5N/h#>h>..xbkAV +AuDgPG$}inOcҔ>,AuP`*dQ!QT'@STt3Ǐ;F{kg~tdѷaa[k,0(WaeaXwטo'8ꪝ+ͩyZE l5^z[ b`=F%$*9AK,cjc|uZ!(n'fy~~'ᆺ~YG +*{[s l> ]|m9A,Ӕ E4^|t=MGR[] 糦pE[H-Փ7~j\NtU;4BQEɾs9nTkjT=դ[=8X%6N>8N3>ϭ&zS&wʻf{3_Ӆ~}QUuz{4\ IMkqNx{Lu-^s]iߢo'y|[>oep"ͬ~$R?knN_iw56 o{RAy${.xjŕM3MK΁jR{4NMF3}rTyTzPzpIܴk1苝&Xm)ҙžT[|λ_N|vb 3wi1lwx\ow;A^buM5q&]{MeMgslIs}Դo湧h UIMMu.[wǪ.SM9Fը*Etd`im~nw_wJ"BoJ|b>6@:|fkEO%oW5m=uz^ 4{x & *LPP+(P(bPMO1g_/ў=7>K-&mêkb2JY[P-66T*bABYwYw!+K@6V $/g|Smm.&2u3%k/X`KL}}c1}/~&s&oLުK߸e0-*d1jX.%s&odVm1y?3y2y~cVW&o | #8BU8#d1op)QN os8 0mη$ s8~ '3=0=9+p*7LYLY0Δә`) θ߃˃]YG.ٗ# i KlZp{pai ߤ=/\@{^&ɩɩefrj29,LN:n<7vMvoG:3:mww}~!0G&?N$s0ŝ!,wnswe _pr~pϹ𿺢R ?Ry#{G]p~\q^q d~>=PW0oX*d)ӥ[' Kqzx@x$@Jp ]@E > E5'@wom֍fd'+ -~_+itN)sS;7D",^.(J,lBC_@m~9u]pAUD.[=yQuΥuq(!oCUyFfwg ȳYq炻w]` rV=c(oƀ>ŭɹɻKhfn(4ms[̏Wr1+}Q4ZfK#/9TO\fn-$UC5R*TT9U\:D0ڕs;՘kpZpuCպj=w憤r5(0#ׅ;X*׽6y 5n{{#pOÞ4xPR,&6,om,c.Sǩ@h8wpB:b 稰O#&BAwS#Ul9AިfAbOCT>`R3݊w0;qdĂazY+9s 9bX݊??R^dsu>n!pGoYc&&bhuq|G?'쩊aLe˷&Ǭ=V>>I؞Zx#rG^5uR?fOhHo/(\||-چ5ysFĶyێ?N:4%oc.BQQaGQ۔mlӌzŞjl;7bDЍ[`c7s{IۚL=[`Ӿl]Y|ұzpl8+o:D=;kɬ|ōzGKN[H}>P7_  AnV~4ބ! 7{n[9]z$o0hXj$R=nݾl:fFl kGph :61qC1n}}-1 Dml`zsߊ)xs'w+-yҋ @Q02Li3<7dAFAԊtO2+@Vԏ  GHzԀ__siGi 3RD}kd1y3lcX6rM7s(L s>݊nq44}yS:PHߔosU4_!A4Uԅ6]r @gMt,CPXA=@1-Ì$6ŠMO gB_cH?-{{de'񌴌 d(}t*k'o@o>aϱ>ՅAݣ%@LgB%_/<9f$\Un=2g -7DŽ{ؚ= %XdUH>% Da`D }G+kM=U?r+4Vӕ/x%n>|A~ hZBݳ> +% ֳhm!dD&e#6"g^|Qy!TjFSO<#LK'|4shuԌS9O2|ǟA:%:sPt'릱WTT–o 2'4֤|ȧk/OSS@K>y,P)H e"dvDŘgP:3OR1 ôO\L@i+`]CPh@`1 xEg`/!j4VV,`XG.t [L=ee'+93ŔD/KȳBd)(LO_@;I|QFEv.Meƕ#X"l{yAl1#hGN)$5=Q)ebO SҧM&У|y39Y+E3?CI6?/y3*ϙ5XYn DeUd83ӈV'5]VX+m<420 lla[60s|!;fYVՆ[c3X:!%o)*SSTv F0#k\"T+i{glDvBaYO5 M32d_FrڅZyt%Z[$Dޔy=93vFURv.<tCdsמ]Ձ i?gX@yKyG,H.=侼ҿ[+{+ϡD 3MN }!ӡ{LoBg(ӎifOOl9;xv(ӒܴMILPlBv+OHU@mS+۲7I?k91Eެ݇XW F|h NNMsfi 3홎?|Xp%\e=\U~5㗦.SW$4Lk5&P0p6XTez,"<(M*ʥ^z'&YZJWNft1[;eXߙ棏8Q9 ׷RƤ%W%e.8YKTQ{\ק$<5h֮xҗ9:#*D:K1E,_-2Rb>IXT\?LuP.ISKJcxOLeV^6f}+Ϊ9:;1sm2XJPgf1i,979Ңheb}43|T~u੹0KƱ4\鵐W"jV[:m{&Uq-ڻWљAy!oF^"gp1H N D$J9DBP ADHH5 U5&&_rn9ǚUk׮U]]r`gؼٟ'1Zb*kpVyl֬!Gf\ =v.KnKJMX6XIRgc{۔(ٞv$kP؁g'"^/Vp8+S"6$NU wzt5ˋNsF'6][WȼSe$ 9W惒JG Z?hUΜWy5Ҧ N[YNHj^9-cKp$VlMH+)ٛV5::uOJrJ5%ice7&~YMg2[GW2}udSIq֙HVيŽ~՛m}_~Ѧ9GڞPcmx1JfN-:>u|ځ ST=)*xxlCNgI]ٕIqӹ~hۂC9j{dfCԋRppbڔ螒ڔ% {YhS8=Ι_(ω/Jd[=nRdwDœd$GV/IY"_3FE=3# " :孫ڜ0ϊycٯ&F,t*yT3u鼚կԌYU3 oLdhiR*TtjRMi,(8XAp~Ρʂ) E,̪kI;iyř9Cuu9w /.6t -Q82kcV-OJ=W5:\^T[ ;|6 u{ceOǚ8 .]6ֺ`ilAڑcUlvlAlelYYOTaɫcۻ >;,)c`q/G=H1vIĦvmզN8cجm%Wdl59oWM}debcb˰Dщ26N8i_E:EZ..LMl K[Wv*k~XV1Y#jΏ53ySrZ痦&v&lڶphi5TQԥySly:2j^xGVy9]eʪ@;G,-ڝ!%-icW&Z=>(9PںI}iE[{M۞(鰡jNEE|ɑueu&z0z8oW՜EN==ztDVőɥɹ HM[[>|tnyiFuܺDI%%)VO91~sO:OKom!DI dHRNg\6#dƆyk]Jܷ!R햲;:8^Z?1mL؂謄hg?/XeNEX}tnxFڟs^ߟqg|mt;UWgZ~vNeڞ}tdjqtSW]fͨUN,{kq/F?*An߼ߓkV78S;ʾG7|)_y3{f 1^MG,\<ע?+y}Œ[^{mr%)7&oV{}:Beuotۥ9wiK9Е8Н=8Г8Л}8З8psz j1tmߵ/o~)]b^W6ȗ[x_"OQ/_/?=^`ڿ#EUi5V3Ÿf_Ǹf{֯cVo-/6ok'=Nv/;M' ^=6vuubOm_vW[{= ~Z~ڛ_mïW[j j@~u:_m¯W[#ZïW[ jr#Xy7Emt./qT__ު}l|񿸟2EFp+ür9j}M\5_"Td>_tVxߋkξfçY ǶxΨf{ ķ36v+vv|;c{˘2F^Ǝ|/c˘8uk׻oLr<1X o džs4ݐOöʹ%yZp5xnK`X_g.43Wip"<zb&`YǨ#.IGcEҼRJ扶Q=`;p*$6>?| s5ҖNCr퇒vF,1Z_ <jR%AQ,m&mŵ_A#vΧwBh-3o"wM/OSLV4d}18XeQGb[B(SiZϰӔ)w k+-vؽ@tZHeT14?bʚKh`G4A4XaUYo|kP,IAY) `KUa?AJX&#h:Ւx9Z24Y)#P-s̘`XGVUFq*錄b|; eN.6H[Rd jmyy6;8x#\ݐgŽ !#zVͨ-HƞWg kRE1ShJVRFWgC5eed4#'k ? 3f12jG% 2fF>7&7O-yax>S75 GiEG ~Q'S6ci 'wɿ1ZksыW %e݌ H辐Z) #b87 }VAc ؓ>J+y^J:nŎQb\ `%nG||E MAсk-=Hג00l>K)h 93ag6!K:5ѳ`XYIKkOBQc*0/ 'Ip 5K+Xf?WXz{X_fk-譆a3,|vUo'Q|ϕ"|Y I["Mz_*WΫikJV6xN77ʌϊc{b< Q蕆1i//_[6^QG%}Yk1,͊ޣ|@%-$ݎhnr5 ݺ&  >7G56e3hކr-yU#t5rW OA~>O>xLj.?m@.4/)%84^kWjaIaZAE^ .4i εoSדG9D?% /$ˑr f>H-ĵvE> Z[5B'];`G<'&=;!y)7_JHNf!hnհSOT"MėR<m<˟*o՝0؟z2޽N1{?t ݐ[* oE6@0k\L-aOpF2goּ=Br2㧾0eaNN$ϥpL4IAEDVP!v{,pLe_5(%LIOR0\ϲ`/t/d&DSgj~.`|^]Gn1> G݄xug0,})MyW|˱~y *t.e d~Џa4g9_S.,.GFﮔj*9*@CT]j]Ltkm9F.'%%t˳mMNoB:K]]~N6 CEn їs8}'x'S4έZ{AsV1G ^CyA[vFs{"gڝvAS%6͠\hb>܏8aMc< %A7 .;U$uv $rR?nqRÈ*L޲HE8683ɨq[6Ղ8؞BkJ}8M2֌zC|Q R%my5,9Ge~֑ ])Ʌ]܆?Z 5MܑҾaU0Q}XWZ^ڼΎO2qJ\=pgh!I?^M-Ci$4Xg2hۮNO8 |w.jB=񻆮F~ 1dL=3QCr"g~.bs—'Z!+Zx}oL"~*b"5?rǎC~!NqP+JV6ӿ 2rzӄ.4dz;]*xI{ qÿ=\Oa eeCCחzM SfwGvPV $tt Wxx"@|sY%z%*Lә1;#vVW!6Y]jxg^UB)i%Oh]OW]'}NVFK([{}՚~^Rdӄi:v%MFVTc@}[_&3OʎU!zӰ[dے Ǟ*z7ֻ/'Npv4Tܝ?IhY ZOw7eJ'd-'1| i&cƠӨ(\Lf&!3= h_x4u_g-Kvs_?bgWSFNuje(MGcĿ\<~4g÷Q~f5# SGnA<~>;b(y6Hk'{uw 8a8]]ǵ02u&3“q>I77!$kwbRI)kS|PN w7!׾|>9F)8]iS9(30>ї=̒6}fb>2XP#7Ԍ zO=ybr}3ҿ<ڏ7) 㘒ޔ3`cO'ѐ GP.F 4v҃^py<% c,5 sG_PAF-M e"3<ڛOkYS|<{>k5˰t.PS>Zr)+<9-sΘy|fTyc_>-g\=sbٗsYmHyEUeqf7gguQ2!$J[1sy2/pw䃤 "_"V՜='Ȋ2rқshWJ>$ϼ1iJN=G'cz^x>Gg W6}XKx@Zk!2ccͣ֜2GDU\D&3'©A:(IcGɟg"8+ʝY |_㍫,3Tg\iꯐfV5 .-/L{!c9! %BX !AX B0F#X<cؘY!$`1ƄRR,PevZ[7[{kV)OߏiGFȁ|kd<#J#X/xw}p"J_܆,[<أe{9xڈ_/ _9?A45iSFqBER7.A<=) O~/=xm4E7~cE5)E_9ajg@DQGge{@VjW8[`} ݈x;Q݈ dw?Odk#SOr48@o9Ǒs u9:U e2޳5 #]bz0j5_"Gd-'Q9IJ-2ؙE]tL^{ }0 ]C2݃'z#=OwRנ hI@{>O?2EON3א_bm49!}5d>)+쐿 Q1 pRd\w; 02w=;o܃L-z;HZs؃s!'P (-EqjG+^XhEg)-!N!_%0'^қ||2!㘭 y:KI$BRD#} ()!ɏɓH HyL&?#|ľ&J9ħ=CÀ&>5i 888X7qsS=c/8)?gP~`TD`0h\`]Gڀ Rʑfƕ ?݅k֫)=:X"-ε\hl Wv.t.r=.ו-R׏r}uqa':_չ3K\vB]"o%"]-ҍ"oqznέ~B OlefWC.k\or+leNLhʘgl'w~ןkOOre==.׳;g.u.bOجg :Qۭ."9wՃޝ~.d,#Ew1Qn[,ٍCH$GS~w7l{ >o^&F QG. e=]M+?7freZH;~#}XO x[e=f?Oxc~Ox ~wG!"xQx>|l&M3GjM[yoӣim{=vq2އB!^:[/]dVBP-kK.3 +kkBkBkBkB kBkBkB>ք_ H;_ 7j@ j@W҃[F=6ڌ60:H_6gäP*qҏ2>>@>#||YF,#YF~g)᳌ 峌YFYFFYl;!G#8v}OyD2|D~  )/d/I>_S||I|g|!U|,//d*/g|>_>_H-/d/|||!u||_BB^=LI+BtaѸ4y;זw"Lynλd0L4MM=MLMCL%2S)cg4eMSM3ML MKL5 ͦmݦFSa:m:ghbnecg&2k9i.0672K#̣c͓l|"2JZFVv.!s`1Y%h[[zZYZXJ,erK2RiZZfZYZX-k,,-,;--fKrrrrrrrrJ9VeլakZ`mod-ZGXGYX['Y5Eeֵ֕֍֭>kzzzzzzzzzflmm=mlmCl%2[-cgemSm3ml mKl5 ͶmݶF[a;m;ghbnecg'k=i/K#cl|"2JZFVv.!{ ɑ9u=}Ŏaю *t\Gccccccchspqw\r\up|x48MN :A"gsssssY\\\\lr89O99/:8;o98﹈+es).+JzJ\erW5Uʺ<{Ywqmpmvmstv5]m3Kkۮnv5.&l?S.udlWZ^s/wvwornps7[3 +A1)ţ]S*CL)W28R*Sٺ@S5eM٩VfU`yrMV*TjRG I@W0u:ZNP)tuP]V7mNuz@='ԳEzCBR< {OoO O33333S,,lllyNxx{.yznx|^WQo;[Na\B2JZFVv.!oFvOpi%p@ ԊaHm6VeLmH[kZغk KOl>E})___`v(b~77׷W[[[{˷kN..nn%_/OW;쉦K!` (` ( FF*[@S%p,p*p6p!p9p-p3p;p7 h' ƃ݃=C%`y0 7 6-cS k!Cr<`(* eBCU١Ц[оPS%t,t*t6t!t9t-t3t;t7 lŽ' =C%py8 gS3 K5 pcPXt|rZfvnA1EO$GGzFEFDJ"eH&2.RL̋,,liDENEF.D.GEnFnGFD QSDx{g_t`tH$Z-f㢕ltjtft^tatI>&!9-3;mF;Wףwb$\1-%cޱAXilDlTlLl|lR:V[[[[kN.Ʈn qKx2^/GGǫS K+;xk#~:~.~1~%~=~+~'~/A9 K•D2Q(J&F&2ĂĒD}bMbCbsb[bgbw1ќhMt$N'%.&$'n%$'dnƶd4JHMHN'%G&G'&'$Sӓs uMɷ; }ɦdKXTlBrZfN~!ߒ=_?,d5s/_!k]{o?&|_MTnʑRT2U*JFFƥ&fR5 ͩmݩTs5Ց::&霴%Jkp:.HNOJK#ңcӓt[DL|RjM;k [m)3e/0:s \Z&c9Ќ| Y "rZm) k e%NHp".PׅR .)8Urs4V]xx s09 sWf!`  l6q S<=m!Q"m)rk6[V`[QXQQQXq8jQ+Zqȏn\E 㢅q¸ha\0.Z-A }>haZ- 8 8 8 8),S9S9P Pd - BK!BK!-B)B)B)        o¿Y7 f,vqo2x>< l O"S~(â=q}DGE."=(?c$"Z[`e,E/FۊQQm+FbQ&yK`!0}x<a(l †a(l †iQ 2p!8$<C#T@ ԭmz)$T@BlmU@r$W V2 g ?@~3 e12b}T+VQZGGGGGGGGaYD"FMǠ~c <l6[m@Q}ZBk\h q5.ƅкZW@ h]+uZh-Z BPh-Z Bu n-кZ@h[UT{5|7;[QUnx'Gt.o~]ǁOs(='O^} ꈜ -@NFrPQj4"A߾£^쟍!÷f{zO95S5=C}a+lP؁e|a8`420a ̂3pf5 $Vb%eHXOʑ**Fjۤ6,6Ƥ1l!t K҉t=' H_2adieHjp M'BE$IA$E".E?xn'=LljEOғĦ"zDaa|$K` $KdI~V&i*}4HKzL MjF3,5Ksf0W?M%M|||bgG>5715?7m&Vmoյhʰs(rT]}e9+sW支i_3"|E\+rW䊯U_k"}EnW䶯ȝE\Ye?KsqY"Q (F(F7&G7sqee\9q9F"k(E\;GQč(9}E(O77SĕP|"}E|E $$I)++RWH)+SWL_"}E*T+RW$RRRrP*"U}ET+RW!_ھ"u|Edi+o+}e4yWLRRRR0!jE+(B~$'ir$hh i,Ԧ3XeփdXoևec?Al0†al8FQQr'ǁSPrOn @F5Ahbhr\4tjR rt:ijJf  ?6טk0B 6-l+>cwh(u>ٳl {-erdfq+=3Vʫؤ~ssZ*bВUj~&x2;ChJ*Wz5B,{+ rE6b6c{=qMi ([^HbDd:`,5b٣:ά ʺz߽ka5X m}ɾl_M}۾#A\2Vq2^ҔJjK)-|2Ld,(d!,K2,' $j)kɇdmYG֕dLeCH6MdSl.[Ȗl-Gd[N,Ȯ.{Ȟd8Ld; FNcyi4wZ8-VNkiwu:81+tq:ݜN/;tzcvsǜ9!s;#(g4cqxg3љLv8Sǝitg{=vϸgsy{ѽ^vzߪəOJ^&/8r t<5j^5[5tgg_3=TLWLyq&-$^35dٮf~۶K3v'VsKSݿ_17t[:}TFɐho%%Zsɼ6䑕#>MVA~&o@>HѠ@f!?ȏe_^Q=xɃK"M~E&aSb,OKRKcG|t"m"EcxcHqY{%q Gx ??%/yG.r)gr\$r|N.z+'F8Im\<<ҜpGJ{;;w6}U8xŒǗml;;d{Wk ˾ewl?;!va?Gvg'2TTbW _  jD ʶel3m.V Cneg3ned(kK*k(k+*k+cjC5WBMey=ey:}m|Q?,VrKP {6qZy}^o5:Bkqb1'; 0Fg>lxIv4Tx԰;=+k׾! D&wH'ds>t;{=~R(ڤ0 TQ[euTQWeTtmdx9g&4}J;H:w{tR|ji3w lf0fةmx196+k (kIBdemaem?ud.B}ro6y^ZX^RsT= kWW} f|ފZ'ϛXsY;b)Jubu:r^s^hg bl +uP|}zP8;CXlG!B1kl3>jMjM)P*fD+J$U Yle[PjnzC1>Vq2V 2VI2Vik5[P }2nC≠BZ7+]VTd5psB4TZ5v8[V+ZԍԅV,ZbF\V)hMF{h=Zm7"4kx۰M۲v9]hW+۩خz}v?1=(dR!%e,,SdYTe YReWr(1r' r$')r' |J.Or|^|Qz'ڋ,cd1:h1MF/ {*_51^9)MWd1s߳u^14H0a1\#k3Tk}~P^?֏I~^_ԯMf5>*zUw_ N?~J? ~I}: mGmi - Fi4 cV=n0f"F'b/)Fw=t=D3ytsf| eYEVf곐6l8<1r%l%{cowGlێa'9vҨjj ZV\+UjhuLBkuzhHm6U-iKUZU-oeYvT;]Юi1 $R%Ui@@@@@@Ł5|4-3'/p(p,p&p)p#`L  V V f;'gW_ |7QpSp{pW EbCV %CCeCC5BuCơN~񡩡YEUWCB }:4\WGt^k!󇐙6uټ!OC6p^ٔg" x9F%-y#d+ٚ7AMm9Kvp{(o[!;N 3مc!QdQp';!{> /ǻ!ݑy9B⽑9ƻ!/r(C=?džksOZ9zk{>9D⃐`>9Eņ |r"G!')| r*|CN Mx&'#g)9|*r.9cϧ#'L|)>A>"yg|b,?|?\"" r%_|?\ŗ Wk82K|da=?^YTOD 5xEdM^ Yc^~G_F_A_E_v~5COlR^!TPOD@*zrPE_5UWh:F8mh zofﱿ PFTR{&``G BC-`b5af؂z== .Yz6\MLo^ԓ  LJ^a;,N8vùyy ppbP89\8....}sfz-t-P|Ȁ`^( B#B#!&JhQ 6f-.]=?'|pc $C1m _9`lg~V[Y[ 4 7;}o% ,Jh4Y,m1˚fYɬlU430뛙f36f1n4FcDc1լf2-#f;Qjp?t~nt7[d0汥:f]v=kl-fY,n{ *{X؎he:1:oKU:(9gN>m0}:Lx?`fu__[0x>U)}{_)ۂ}As tݿ 2Q*_LUYt_96H`?jP7FX 3`,>o% x>¾r;삯S;#kf>5\,ϋzugt IG endstream endobj 2249 0 obj <> stream x}Rn0>  !%HPi?KT 2iJ,˺yXvbekZ H`8!S߲ǵj'JN2&lU(0>G^Y\ :,c [ul2S3W0S#8gOҽ=Z e{ePN(Jg p1!xFٔo h1ZdkEAZL mBA*Rq()c0!yBom !yAĎP@*/'^{<; 8E!ѵ_,<cweYVe~XT endstream endobj 2250 0 obj <> stream x{y|Ts=̝̚L2,dB&;!LBBXBH4C@&d %D@](ujՋUP~/>Z],XkZB&s̄$Emy{l9ϹD h.j `)|j(j mx<>;̽Xҧn_hÌt+f/ y${ֺ`_>@^U}Wf0@N2soF~q]-XrݕW ɝWnXfpq<>_jI=s0GI:l]wNiBbKkR`1&8JlYrg$4(Aªa\V+~Ta:PJX X`:&E *ǡGz{N9PV*+uP΂V+70{ ZѪ2DäCݗG/ s:M4]5ؙYP`|~Ę3BϮHv4twH'' Mg`=½kv !|a-Ba鿚4!iNi:M4tNi:M4tN$141Ks /|8PcYc#Y'bj 9C&o1^n`7uv+ =]T hAd=g*j XvHtpLZ N&{a ~8_np;| p'M:]D)x̩0Ȇj A7,p?˙HO۬))I:FR*X@!KRZcXJKIp F {IJ6} ĪN2_bܟ]8xonsz#R^GK^upr9$ƍVlϜ^>"qXrjZ%h02fVB+[r&ň| `2!XrZcP1H~S v $H9y6Ig$b$O^;]u4EV MU(HL$n2mҏvK5 +tXr%aM)#uD0M5ФR)MVK0f [LZFƎ8,3r1"$U^ `y؛"K%;)e/*\ !SueD7CX}È UH05ئm:R$R vKjiqhh/ݏNhuQF`G҇\ 'kZ*Mֈq// ._ w qR.G㢌WSWR6VCWȬYC{V)ЁhЅw7 MD1úu4/84DI 1tO8iNpE7W;,hK8 bzǮڽGY,CtF[2{9 v)萹Y`}رϐGLFm1+Opgl3ǮSf9<4,Cޑ Cǒ5yy~| $q~R#kNSkhL {ޘ\UqO5Z?熸dN[ ='ۯp,tװ!wӪEqaeƍZi˱ .쎕yXx D--.2hPoE_bm{(>YH;O$MU\ns9]YdLcq q^I}Q9#:}ZtG}Y ~̜Dj%b~Uvשּׂ  o -m"[ qް' {Xc@9<)v7}pz Iz%2Bz.DT>n k`K#W9^ժ)r@92vT⚐ {K},ߗb܃+=,dTyx[;1^PX!$9]ېBD%S*!G؇0[anPzvegM{vVzw"8*- ܒZf1-ɥ ,Pl!8Xr ӿ>D_%|ʜx^C ,=e0pd.)Y$ e2&YF m& fB]>_I&fLmnf7w OS bWX8[Jœՠ'.1CG9=ڂڼZOmNmv-_uk-Zmv'R۠3 >$m;Rom>F!x,vJxvkqOIͻѫR[xWC^oa`fH*[3C0.B;5mlT+}$}ڴWoluӦk-h z<I).[>6l6МdߩR;&Eh KB~,U`ذa1(C QOOwC&qBd"d FB AAP!(ȹgw#oE~9y#ZSD~9y!|xȱȣȾMݑ]#7D#;"푅Hk%wF)@2E^2t,?vvюX~rRm5vQcc㗾äX B?>~aXRVH EU H nT;ח5`K~\El 11` lAh\_%.3Bs(1s'V#BZ*4 J@`ˍeLn9K++@=Ue l[@<ں*ʮuwOt ay{A~u;9bʠ$'$e8WܒD|pEca-EMKsZ-.Vbqpu\Vz%`2)fehTbz J'{~BՎO_N܉YQj&vW1ntBNБB*jWa˰~>P} )/k̍i5kfz [ꣷOO\#6'$(y(uzYAB a:;-jubZXVj vf+r€J Ae"# K_PbmvLHu0Dѷ"g_UAߕ~}rvilQhb 4&j`]tn}SF{g!<ׁ.f v;y*V+xAгsX;_IQYPNYūy)㆜3:JEyyL=c1sUƲTz+\w{PwΒe4'uGYo$VgOі'htU&@223,6D8Rn֋!L2T0*D"b&{f;i ͫ/9Ӷ<&Sr#rW%!j-GY+?,c6?)//8HȮ(ѓԔgeP,[ugTN61MxeޅKXbUM!D0[SQ)`B<Ԗq"Czt0ۤUd;};͔Eor{OXH!dfol!HN͜$.Mq޼bhٜz=['[Ncgz㲵C*ѹI`EBf2lg%.)OXR9x0hPƦ~ '^R[ӘYﶯr\~G#3`wg:%/^,U܋%Cn7g]Z3Trr ` %qrP_ T).ቧwB+1>7(E}nՕefuĠ1z8b*&W=)k{AAi艩KO& k\4y:7?odhĦÖz^'vGA]g/()L*,b5|}- :12 ]9 ux'qo3kTn3-ĵRt-﭅z/eKE}pPfrađ^T=`EđYO5 j*ՂK_+ၾxʐk kEtA6 wXb1Sy_=ue-Mͭ/XTQ:_(-Ukel3ַ-?4__ձGh=l[m^q+yu{;wInwFs =-\LbѬ( (*bY`)nw r\IZcu{1f8=P.Ţ/f-fhhM? ߦmZ?=B3pL3^ꖕ% ۔j(\q}۶L -ZX&n-^Uů³a(nߞT@#c1]mǼh`]pRQPrxj)S .g4Si)ϟm]Nh嘑Sl+aW-}Iw3Yl~|m m %2jWeb3U{ sBnK`M[Bbʬ,p05E)eh())O=/[):UNK lMeY,y-y\̲`k()4yʆjFgu6Rxecz; WWhIe=U)[Vfm@?#RY+w6UWm~/XhN6.'4dbM$ 6ʉ TO,Sޔ{Rv?uL"6щEAޱU}y޹ Cm,\^s%Ëf3xe6mzRSNP*K5Gaw67T74aj ob:1L LL +k2XEi$McY+k=$4Hݕ͛v0#ԧOA,{ pI>"3h?l[yVw=Dv8wg-zOYz.'9@h=i`q:OSVY(-Ro;a~|| Ԗ"gof3ZdA SrwM²]^ ت^HN_+Pyc]xSDMD~yVbFE(3 \xtr<wŗUTzdq`sM<I$)2??W_V[-o޽~- ܆퍛[&FΞ:u=;w[Ŧ#9y:\dvu89јWxKx\*k7ma3ޖι%<+k0܃x//רg |L?ܾ\U`Ԑޗ7qk.Y/^}lml6a a [A$&%lc0iJCs46RڦI4MonCJhVHB&监,<>9wo9Ȗuӧ::KFUPI0dR-%߰.<\/gK$~s"z{߮9u{%2fvgFBBjinJNԥ'M)zS!rw,t#_8 ER-qzsiqxi6K֜9.NU2 gt>`f'O Uq,54Wϐ eY-&uZ*NɒrN{nd׭BmW?nqlm0O+fDW@(rʝY rkA:%PgO_IȟytZ^Z+RDP0/"f/|k9 \$F*Dj"0rR]=CIWnbd1>>' }&'\ cs?ZW2{F wۧZXzoŘ=]G RX\JJ**+NVj2 glӵ6b\(4tK8[G҆Ƶ3g2 38Ϻ2lUrEemԤUV(3L-X]]-gC-.;<6oa('C gթKg:MsT.dc86ۢ'gbfDR ҙ[Tif8~}O"7baƗZD0֓ ҹdJ\O \"I̪UukWi̶ ċʬ .:]03EV9%eʔ5dNm*S F!HP!5% I}V"nX+uY- {"!f 5}nXk ,[U3VXKڌpfqJ2ڳV*3i%Y b}N [97{uocLDWJҦO~v~a2_QլoS/sw[X6t˼(-VAfYmk1LVV&4"5pi:%)90<v э'udlt|YC¸sc~H4g&HII˦5뚪f'j 3yks*rgx[c0W93˹ku>u¯FDeV#'$&9 .VbqhpL'zK8Hةn?dǛo(W[vY/ugzG Tl:TW=2QȝAJ  Kb7uK)1يM L{ˌLX*i̓W!y+GsoQSq+27VaK"qԆ".`) 9ٌ.n` L45]UwxW 6ϛo7je=acf͉x%oIșVL4itr\`Zk-B]grrqVl"D0.Isʄ}g1blmYi3gē8ZrmSoG ޢ.Kuݓg}nWUkjTo o*$#S%ie\RLWr"S}&33tmF%f =9QsNph",Z3'U)D3(U\&Vʋu>.^/%߯a/-<9EX[[ 9+w(3"oPg<yUz>KkQrBW!q&ٜڥtI$U/\-}JbZ~TKzOGZ=SlY 6J!0v%'DkǠT~8 嬘]UP'/(k1L(Dt ~W֒=ɿuN{?-y]uB:e4Rke&_NGk;D؍EbX&z=Lbf[7'S5Y=\=5˨d׬'Ϙ˾YS0pM,~}|f^^*:|jxl`ɳT:!,RrQSt$|U3W+O4ILRR&}Ui8V KZIh&ӕ L+Ki42bte\ _C]۟:k_|yl pRJYb'}E]W ^!h$ $"f`_?km]ܽtKjvIV)0|bڮ5;kf|ڲ>]{ #|xPxc[?6Zr+d ɋ}עTlY9ILf&0LC7B9HZ+äRbG뉱mzܕuSu{UBWD,2MjQm:)n}`]m<MJ|@_z^LDG8b~eySXzN7^4#†cwlZe۳6ZS:i̅w/'ٺ wB+KKM}b${عg0{u;wv!kCQpxtjTu*zҥVLt@s)h)!:@vvi]lN7Cb_BNM=Qg:btŠz2;)ĕ%W,hв]~㛯 ?w\Tz.-3gg[E%]/u,t?`z rElAO!s+g9x ӗ#.9* {N M|(=:DJ{{"8<iT  &ЂZTZ"/Z47 Xj9M5^֨ž~th?:ڏGC!z?PA*:D=!ȯ؍؃/Bt?~"Ց2TʀRP*Je@ (Qh@4P#ȿZCP3]?v# "#`٣ tGAh^Ie6Ð~ILЋSG h+54t!v# "#R2пP[$rPC4 @*30+q/dCe{i__1}`cG3 @#3~df?2e888{q+ `{GQ 莦1MGP(b[[[,Շ?B^qp&`7b>y4HDS^BzC!sGK݈=~/)E 9 5+iPPPЋ |qqzW#~AK %лA BC+vmV~ ؍؃H?x~^|ڏ8yVnH[9VN@+;ʯ{'NG1N!C1l !C1l !C1l !C9r'E;F60B̛d.Kxއ5A䷀9@s-"=r"6!h+tv RhOw;kD0"V d,A25'?5r"! 3SYHDH" aգ+Ő~DHK }NHKɧ2\&dBZ!UR:UV\U\LfF$ !E!QHs$YTHJ{CUHK CHK.my!-'Vp] 1[H!1V(#դBHˆ|O̧y43y<|O̧kiz'AZtv$" i9Zrm<p/F2,"'m%I腚d8~gljr8 En(jh Ý}ʅRy6ZOjyFjoĚ^>!GҺ;rMcKkCm~pg_ ^̮ypTT/mB?'-hݴV^C`\d$Vy>h`̒q#X6ۀO7#gnfhۡ=:G /.^lĴ;^dg-1׃ZD6TA^[SU1o& Ro~06ήOب̸0* F>-q:X ľ# ~Lyx9i#ky.cRIIc!76[|>2oSs(X z[=ų-^tlxZ8EMwk#w͎&ѱ!(9-nh& ;⭞@ó2 j~9k&ۇO ހ mٻ Nm:PTx}G?o AP*'OKrb =@W'5A-oGOKJ>7x۠M~Ho/mR@ z 4GC;ny=T@h7z(P4\z|O+пɱh,򶸛P"ڃmH2jRm~BbE1b 6}T047XOBb<9!ǝl| 9mAQ V6ހk mvE*kuL5~_c5:*PyqU>SNj$B`k Piq6;IMLJͮlRW^rxs@ 4[C/Xb?;Cprs9jv:mVmr?lvPo5c :IP[!*xEд*`h@hh+ ?c}퍼64"P4tjm ֞̓X5y\0;K XȴPT $2T;;FAfiN 6AxjlC4{|mc:t3@❍Mnbwm{toEd Qi$B4v IOĝQ͟@so6FCqZ_͟HK>z=䇟0?aE <^'Jd L0kёDO61'KB^#VBGF쌜aLI#]t3դO2>M3~rEcyb~H3 +/ϼO0VLZrM&l.9Ζl-bZ"̼na.w3.m;\ab,7=U/rd/r! ~md6mҹqwq 3\xh8SOspw#<OOOO/O27beXbcST<[z x OOO'3s/?OoO׀0gUki:4xZ<5O~ix<=<x m ?;(ٝ4."hF1Pzw!1qİ)E*6mn!R" E ! Ac3.b>7'ߝ˹?¤Y,}a\4;݆ S v]Ińb,rNy^T*[;NNIE:sL`teΜ|NO`U5Tv-cn1bmXd-Ƌm3#ivz;;;b++O/>iOOkzvTІy@}>I_^obMiv'v>Yi]j';NM{Z'씅.Nðӽة;=buivچ~2NY2t#v*N%vZNu=;N_);vNakt;v bqi*vz;-NObة;;mN`C_4]/zaKPStg:U%٩v!9ðӭة;͖w^N肏}O;; N7c ة;NivڏLQyvk(]nNSi9vZN{1R=GBN,G'1ZcWi v;NM$vj>iQ6aدo'GzDbԧڗb_c(vz;ŰSց1T;uYdi09wc2nة;mNt#.g_]Лi /=Kq. ?'*mea;NyS1fP@,g*N,qWU,_ _&7S2 >>NZ#M;؄>q>1TOvLKs)M4A0ƵL#__kOr]r;|Q!\܂(_.'9-E|ւ`i0XКtlR p.\rN-(-** \^ -z?%$cc# CF:Pm3 rEE n P2"3ma nTٮ]HKYeۙZN`PTI|ENʶ5axDYp ٢ZwnTvn-UCȐ->/I{2NV[Ǐ6|y@< ξmX2JKuvps]7mz084M!䁍GMۣ.˹ѨIXMvp(uևF"M9Ma]LNhvav^Z5eL5s[AϷnne84rѦT2''mIֺ )MȽ2_ p`̖LK-6쨚3a2Z/ [v Ƕ?95Kۻ(WNGSTpiDd2P5o Z^b}1ٮ,\K tLǔ@Z| O\  `#uq Xׅ/up/ܾ9?^-)^h@N{aG 9Q'Ĵ/*{Nv?i>_&3ѐ?w-NOO:R/,/^|N t2l:M?g2..5"7#FjOL"j~FsXi'O3/O:ۮ 0ၞz,dvxC<#=PsW q|Pv&2Qk4K0f+<1_i"O.x|D CU"q. /}C`Km ")_ UE a0E5Gx;Qlh؅'r[wٓ^lޫy>kyEWatLoSu(G$tX'`kj\ƪHHMh0\".V&iW_x,nwro[xF;)CQAԜҋ=. I,CsJ.GN3r)FӜukk9-wǸ.t ), fc8&u=Ix{_O>ޟTs\BZ5嚜>w([8ݍ)t)--Ct7,W#&kiSm[& Z\PECq⊈S^@@w<<6ˆ^1kk{I*82?MX̃8 8Й";ۮk^{hvYύui6)jah;4kjC cW =;;e֍@8g.wzzz?9j3,H͟ZQCvu"ڋoz|'-±ۃo&]eG|Z~[|No(GGٮ(H} EJHNoVN|[8rLe7xo{Á` (c)J(}WKx$$EFYҼ$%)Rm e^Cxqox뱤;ˊn*,^;&Ji™\=^Y͛3w$)ėkBkMi\Ԓ5xS]TrF4Nȱ(O)^w pnwftktPHN=./MMDz UCțEcP:sǟ;{ؗi0Y:T%opV_n2s _^t{,-<6Wt ]%6ƓtCfn! %KgtH/.r@R7~׎%\\k:rΕ˓]*JNj%J]._+JtؤIl[ご=s&Rh}tm+Zk'RrX}paf8=)tyַ4`МhN$'r^݇t %2=Z ^gig FSYo)yʺ; w+Q_"xAyX&H 9á<ԺtMZ?D59>2Cz,GYÞu"eTW_r̃+=TDww[JU3V}Z>9fS>>3Esoy["g=%_t:,b_ J'52{w-3"N7{ݘw"$aX/=h|ZwҊ2mB{U[mh=6BMweem_.P[MM p]h}I=?8.87z|IHBSOhLͿ25$=5.5?2)5YsR羕:5YgDj3sS_2]pfD/8J dꟕ5PUU+pVƅyzN/궧j?dU_O\؞ezWX)OE}[v/y]cA4xR<{h]}{]X{v#|_Ȼ5/-i 6`tws]cݱcF;hL#o+Tx(L+Rk\Ǐ1a cF叜}B9҄ vOh 흰h|Ģv?PTT71mb>pʫc?;kfݥ*ydx$LHU:ZdOp) mggΜgvx3"=#29E93fgJ6gϜsZ*lY**VULXRbME]E}EҨRyne]SW=sIIUt$|lyљ<")eWV9YrK5\֮jU[}-RS+kGWTU~!5k9RuVJ#e-~WnDpŽi8BQ<"UlDd}M$2I-Nc):,#2haU:oUHUCJʻZ\f$ZwV*,J@+UkޮKR;~Us:G쏜jvmI}LtC:fX\4ͣ0ca^U,c*T;.*l[&DtHIg(-5.Fґ^XS&lo߶R.VDd.iODT}iֽ9S:}:x)0䑌VzYz):2 m2uHm!lS 8)+X3woRclfq(p>by^a3wlF˪xߌߙolMv -RWp7ې)TZ!jW3H^E9}n ߧ_w kN'Sdz5Cq fXI+H+G+F+E{{EWIn/.".~0\Fís n;N {^ȧ a  &d()o*LRXgL(yϖ7±ma{ /s_A+||vNl:8 0  33o}^ҠCg8 Ά.A\mٯkĬw 1ckz帙Oay^m8W8 9 $ a=z1a <K/{ed+f>1{o vspNvkiҠCg8[;1kZfͬdFWmL>7\?lR?p0P kZp7 y3 ( PA!\f<jƃf<jƃf<ځvA;j<ƃCةf&fssP#|C˄C/8z\Yp!\d~[ 4I3 )ϠBp>Gf8 -p /6ٌw6xg3ٌw6xg3YwV7znpSȃ>>fL# \:up?Z<nƳws{78x~3ߌ7x~~3S4(I~<~9*aک? ?+O?s<k%x^Kx~7:~o:xނC-?O?u߰ށWw=la;AjQZԫjFQfԫjFjQZkñ߬t4wX8}c쀝^'Q07@w0W앰'vvb)kWo~WxTglb||߱Mlz aT^"e&x6_8; xRq< cX`ΙV!gy 8'yx^=@ Qçpԛ9 $pm ZQ6&OzPn~Ĭ?byx^5 Z%0Vwpy©穦5X=kzj}l .p) @ rrD}F.\ a ,ǰBXqXu<Kĸ2]I\S4`khk=I@kşnP 86u7 7vI[.!쁏81Gu kC'Olz>^G3hd~Mlq8ÿ XJAikAAA xPCcgq13}tԘQc:e(kLUTeLUTeLUQgTeLTanDc>ݘOLi9~TC>TUe=괬'xRN{iEkrׄ}E6gی̌ 75\[_  窒3W3xLr߸Ӿ"^7~nA4Vf9fQ+4ۍ|ɑKqZp9TW~Lgz>J\UfGYH>WRS>u+r'~Z9[|->c[ͼ,[|->eϲglY,[B3jg7w{5Gyc0 p,8u8Ѵ: ^;~uw{oڗ<шsp.C߫ Sxi\|/FG`#=b#zc~H0Ul8!>އf^5GveҮ ٕ!2dWʐ]+CveȮ ٕ!r]7ߧq:Lp>.+5XM܄[|;w\w`@5&UcZ>|o9UR!UR!UR!UR!UR!URp}gf7k\ܗ} k#̝yܹď*߯nwcE8:QS5O4|D 9Du8}Npy *DOv]Otw9/z9 rͧ]sK|^?g ѳ]4zku<5|/p +l].v]u_\˜o t*Wyqh'()v>}>x^g }"N8'}Rq; uW9d42տ4i*%L4i* JҠ4h* JҠ4h* JRQ;{c LShJBiS(m MISh,} `4v&@HpA Ξ\|rA.> \|rA.i.ę;(p 'p4'ăxrN<ȉ9$'iN<ȉ3x9 p p~gNrMp4ם亓\wNV]ՊUWjiZ WZ&6պZWkjUW+rbFZuqjEVj\-պ6r\Պ\us4Wju\mWj\ \uq.ZZpnj]\ZZWji6 \Պ\mWKs.Vj=\uq4W.gxjEVj=UWKsmj\- \zZ7Wj\ZZO\je0:(rw)pwytq]KK˓%]K;w.R.ܥtqr(wq"w)r]ܥqw)pB]zKw. ew)r~.]%]2%] wIpwȶ+CuЩm^(= q@0\{^[Re;$2e}ɱi|WB'D[m ^σвhMhI4l:KYhDYg[ c჎l5X?욏cg=z 1DZg=z9w'ޱ֏[Oqnu>5p4|ұOY?m=K_j >˼ ΝoĹgm 5+J뗬9ұWkC'ZCbP}k"tuc7;wͱۭwX;nknZ:zܽ߇.ǾlMZu8UϿ~ݚv.c߲N }}>XOU_STP_%UOQ)U75(PU)PT=E~ FQ+U*jQTST=E-z*E(j~:PT=E(j~OQ)PT=E~ ST=E-z*ougRbx{)LWL7gPJ~S3]i6-3eڴ,eyJiS2cJ,䓦ct|t1NT6ӦbTLSCXæa4̘iJh0 KaiXiS0c M)i M)1` LNS89quΟI8z:qL1K)K~jZ)r~ڟqj/g.xYuއ)9z8Ͽ#4Eth:eW٤7QIJ$A%-IQgDPLbwմPMަGPHިZ(h~DP%.jjߛ&jvj&ʚ3{DPY'P.&KS]7%ߺ LS`V~sto0E;M.z ev/E9b2eDmֲ5{PlfjlQJ%>IBO8J()O8J[)Pb?%&JaJl S!O8J[)Pb?%R(%vPJlfJ\@%RhN)1WS@͔J͔%S(%V))q)%(aJީSb+%.ĥ;QJީSb+%6SR*7PJB(AwntR=Xkʬ3A֛ )^(Z)ޑS~R^35Q^F)ozGZ)9ъHI)h*裮nZYIo.?5eM׼UIi @a+)krGYݔ CQ}MQ@QJꧤJ꣤j-PJQ$%MRR%uSR6PR%(z(@9C9}]MPM#G1S~願n飘nk(b _UJtWR R&)eRT)eCWG!6Z%Ɨ7nrm~wG)ݔI)9JIJ顔nJISJY@) 駐 飐jF!2I!O!i PF@QFwt4ûCSgZ/48;CXT9bhqhsqdqEhq A|#84/|xPv>)wl?!WkxpkqN=:;l]p4NF=xu=A5\\>%`msAo,q^0^ ̉A6|OOB̻|]:5{wy-qbQtt^n-X]=X֮ uQ>jϹϹϹ+`G,8x!3؁Iij؅Px/b72^x {& Oاq:`)>sX3p&>pmK}v\#],vawЊױ7Vm߱"THhݍݸ6xDBv4xZeA2|7z͹X/ yܬ+\.+z/w wW*Yո׺v=6o{w^5ϱ/8="}py(vqՎv\ыKqChuh 6܎;Ё;wnt uX ؈{M?=z?3e$&W5<Ѝ#o# |B~F񿄖FBgGw{|;~]7\7\݄!16ƟOGG`YF=% G7[|[ ;!Ʊ q<ē ȣgxOPSx`&bC ݘKx57Sx o;cSр.-G#8Mg p!Y+\/b%Kp).C .- W\9HXE>X3sE////////////?yZhZhZhZhZhzhzh?ES?ES?ES?ES;y;y;y;y;y;y;y;y;y;y;y;~Bb! YEQ0spp8B>P1GHy2v cq8''$z*"*"*"*b4|2HrFvH#;$ic]خߐJr[In+j%Sz)ݔnJoJXI+b%Y$d,VJXI+b%Y$d,VJXI+b%Y$d,VJXI+b%Y$dWKɮWx7J={+4ctrҩY'[3wvYwṠ_/͵#syUS^W5UWz^5Zl`#l䃍|6F>`#l䃍|6F>`#l䃍|6Fp V\+ʀ9p Vdp@dp@dp@dp@dp@df2/U3`Wd&ăxpn}<78ɋ8ɋ8ɋ8ɋ8ɋ8ɋ8ɋ8🠈4Lb'.< x10 -s:NRI8I'$uEvT"_@GX5cfbjA1 Ƈ!0>c8p8GhXr^=nfDr~;s3́>s3́i$hqyk8һw*NV\+v".1Vx|W k]M8l]ֹ й ݙ֑ 8 u6ZGߊ:nqw4NX\&j_bؕBKy~/>=ca(ndM7]Ktɛ.&;\(a8l6.)NOq8=9lNq8]*NWqyyy.0aN9WVp+:q?D K˂=t1ZOL;wg0-V`,WA3h0tmfyϧ})W/fmZq6Ftv{km7 qn-hǭ tN]t6;ڿv]2E)Le.Stfmܬq6nڸY7kfmܬq6nڸY7k^^^^^^^^^^^PMqSϲʽRy.ﻝ4NTiFTz6p5̪U7yͫn^uWݼU7yͫn^uEd>wܙ*2"jEwjjƸjƸjƸjƸjƸjƸjƸjƸjƸjƸjƸjƸjVcoRJ%hsʱkkuƫoW~eW~eW~eW~eW~eW~eW~eW~eW~eW~eW~eW6Xe|JOgJ(W};lf;?o Cclw1?wݡYE<ξ}z2ٲ&[6tvnun;Pݜe]aGwѬѬѬѬѬѬѬѬѬѬѬѬltm;q/96a.'vzNO ;=a'􄝞vzNO ;=a'􄝞vzNO ;=a'Dy/CV"](wGW+ }J>Oig2;yW0))<~Ll2۴6-Ml2۴6-Ml2۴6-Ml2۴6-Ml2۴6-Ml2۴6-Ml2۴6-Ml2tSx8Kbgabpqﺦa'v[{_ |Ϝٙe'K@(EKukxux[5Һ*X <>5jb[Ej*W*HD4d, ~~;gng9tg5&u3v1=xTFUخ]ךj0a\SøqM 55"Fߧ 0Lg ݄&sA18.@ \ .p ~~HҚ{ɞx\n|jF]6ӞfL{iO3i=ʹ4WVIo8ϋ{o3d8j70lf/DJDJl dI[lMT?1r%{8N 0L g9ș@r&3 L g9oL)0>˓$ÒxHI9I<'$$sxNI9I<'$$sxNI9I<'$$sxNI9I<'$$JBGP^ Zbty%:I DI?~&~j@ -ו2nW);J?vVǕq%aÕp%6\ WbÕp%6\ W/G72t =,Chڹ6.iVK¨Khں.IG`5h` X >@ |z646S|C~FFVdUbXz>u`>C>e`XuV]fhv]fhv]`̯VɧZj+ء XG "b={6QZP4s,+@m' NoSU"ܤ#._!s(? ^K4جֆQ"2Հ4 HzS(pWi FjwZ+{T-T'TQ]hV.SgUhI [Սr+wvXlnU)#eJ$=CGɏbѱnJ8k miюҚ@?x?O˴FҚZZSKkhMi5 4{' ]-8cx?FBr$nC6$nC6F'pYD"2\'k1n^bj>:X z&?''shy/U`zxY@9/b{qѲީgw2K.p\S} ۧy*6Z>z]mɡlӶ}5L4L>d{%^k[Ak8jg|5zp G9Vz,M|L!>;)|'VHc4VHc4VH0_×RR _JKM6Z l21);z.\"p.GWgQXND`HpZh;@fTXڌSpx65SHلZYSֳ[?PSᔪ ƛALN_3f:}t|AxЀ/4)?cDD%Q mqqUo(Ah)=EDw_w%.3^_-l6pX&Ŵ:a"֋8b5F^/K@}BMf{{{7.?`؇WUJ$&ofhVYLk\,?aX=ۻr#-]Ͷݕ c2;ZXyX=ޗc4ه۱fb0f"+z |`XV$Db1VJh ՘P t-\O]@1Y@v%b),6kZ酊酊=R=VJDR +%Rd. d. }15TRRRh&fRh&EK%*#Js>%$/LLτNZgmDWpP+JVY#ex !^ւuH|ƺ|J HA  =m#f3m=<%$}U+֊[=!= HpZel 81ǃIL@18\ ~~ׂ[İN`S\0 S0EAAޑ,5`-ZuUG!ʞjݮZ[ZM4>§RT JwwpC~~G_}$(dEXk{ڽ i"Md)|;o" +pEHi"m,;yd~ rvb\Kh%%ߣXpj'i'^~zy\i FӃ7Ѓ'W.aٰM9lSNr~4^?,uHQ^ Ie9LR̆IfӃw6 {rӛ' GKz$i?}2"` bM1rjBkc 'NrB_˸J0YMڔn皨]JL{ZmdXJhѯWE>mqT[h0A̽_-ab8.L& ŜĝXx6Qijiu\ND4vlK X]Fw irMf~c.# oH%,/7.VxR 0gBvJud_1/Qr"Y]z>[7{kٛ6u痜'%4aOkeWMl]^ToH4o#D)j}5zްQQ^+QWzs,)s+9Zj ~] `AIVh?$垏2C b;QB{w扸7ϰμ޼,`޿bަHmQf6_۶*l36֋ +z * \ψx(2o_ͷɬ?sw7X$-GE}戸xBx^TI!f |.nPT{*w0Bsg{$(ϺH)YkuFp( NJwX7]hg̻JA5{<*[w &Y7],*Jltvz;mx j@-X ^Ѣe;jƵ .=uehLeq!9@)yz+yQv6YgbU24=TX&a WD8+Y>D}Kh=qU 7ϙsz8'9bo]@hDp8YD}4:" s=>{@KiE|j*J"(c=c^ 5ڛwxcX7Vxc)T Aƽ}ՁVu^UHPȩ ^ݫ{5wxgYuxV؋R2;k*jQ2]xj= fEMAG|)VJėm杇֓1X0@}w:4p:.).WrU`*#p# n "b>D u"].YDRv"euF'UG#bbp8\.D]&:v,=\{ Z]A+huVkiː°' mi+4"miH[HY$ܱUp 0ey(USHp 8CWj|55PN`gATMuJJwXJM r`0\ҟ}BѬ#FdX̓C01;^b%v{YG'<{1ḲR_/͊ixw5]*nwbC~+0OgBsՋKaRؼ6/K+3^*o% ^M9_vٞ{کF;h5^1Z3EClx m>:pw_#)ʾ@=2q3o@pz%>\p\ SqBU^K:0 \n?72A%si0]ޝ9򞷩rMQeiypMީ<%o"T=:H]׿W Eq"S6 ^=2 K+~!SIuȤ{"j:#Wܫqd} aA@uX.ۂ&H|gޫZ(ʥϝ~V`/8ǩZc45oNy{y{ys~[y2eALLh( ,JCip%"BA=Sj|RF#gtx1r2{JWwc*LOuLg>keqќ\BhV͛Q7#>3 (ŝQʎ|"qt@D(S{3f˭3goY=`0sGzq_{{mWEgQ,nǘ9+<kasW=c8ڷRV*粖y-&[sZU>׉2GqTq V̜e36Ӊt18Go Ν } 3? bXAzuV o8! G7iygIpiV0l7u=V*f$KuP*?KRS=hz@#ֺd롎0= q2_8|/vU~o oAG# mqZYFDljh=lr3dxh̸oƛY Z= ns:{&ʰA`"PK-`"n9[a;3(s(ro{t-%iI'-DN5zӎ"H^:wDjl0v̝ȁ@9DN$0ޥ"; W>tj4e,OϋʋWȉhIEOK1oIoI%wNO6$/f${N;foQؠ؉MjUw*jUd{'ӟdZ5yQʴ5B,ӢmRdZ2~Tgd=F}]W]_8d\|k[OYl +AW#RD|'6_D,3oE2"3*Os=${H|+~|+4{Hfָ>^f3|Ws} 6h\/;E>rBҦ!"$ek8[|['"fuiL%RQfE5M4[ìjk_{buu{9uu5u55JZ)Z>36k=ץ\a)k2h]"dC9X.C+.wYW=֕rOu.[S~ruɄ\rLZMY>j)6fi>kj-ڮd[ݬ=oX[.{=RAA2`b*{=NbR?{؏؏oK%r`)[H[@~BybU򗁩[OqqQx1d4g3A.prΒO9QY'\\$u.uJsdg|s\\\!_tqn/97;ל۝ NSwt9;98eHv:8|謳98v69ه8[-r-H3>ܣq8X2{ v==ɾ=͝`Oq'׺?p>γs>a>V۵:w^d׻5noooooKݥRmF]kr vnu;N{OW٩ y<{spp0,84ypxp<$xh <*% 3x^$P*P:xMMo 8));eӂg g_ (|=p^pIpIw \\\[%TsA~9A? <8Au,gx)C8Bwz"sBГCOrN =Zz!9=R֙ z=9'Ahsi=\oЧOiB]sx[v~{9{{y832Posww+o778DgwWMt*wSлș]]<]ٻЛpt^ʽE,7K=oWJ!g7כ==,yeSSN9z/y/;Io-qZ2gq^aκl;5l3IWsK.uyMv?pn M76yx0z>OEj6kSjYǠ 4Uj! ;*]κRcJ-:G _ }(J*v\VLS0cT6Mڗ{o_iQM>6nOʭJA˟MߢcgrUKJ9liSk lA7/ݗ{o3Z}ӂ֏9I}2K_T';:UjjʌuЊ#v.l\Rka书\㎕puJs0VSiU%|k kM}B:[׳൭mS`]ՁVdd1Ӛ_̽3lv8jvMpj}I1-Uf _֫WYwQ=J>G| Kw.d]8ߢZy=s)5A5xfF~dѷ33G|=G}&N[zKjj[cb9ۮoGu>nkrem?S'V 8樑=gI_UrZ/ԉJ9j|E\?s"kU/o+W,cH uOիۋ8S m|li~wy|`YTihmնF Ōͱ+c灳0Jtت6%51zmA?Ƚ[>fZ2cXr~w^jJÿ_|+uv.6啽ݥys1'+s91?C5~<#h}ֳKmjՕdm5/Ȉ٥=[zz3'j?g7<2#85UQ6=Vf{9ᅉ9X˧QM4u3#"55=34ޔ>y_{m'r(}fP2Oz?ᾦyq=# lu}'F/*ib>5ӘMf$3s{O&sˌ5r{]ڝ_[Hν~n2t医R gwW/9wÜ=;vza'#HXg!kdQ~,}+r]—^!5nb]7z`ed+wͼieWsrK/;E=6ZH{\#\'."1zw0ˎ2hdￌ0mS8I.\ʺ]/pNϖE ևb~*XS﬘gIjQVѿwRHQz?2O1g9rw5v&Wg:g3Xs_^}"u~gz}cx{ ;9l9;/׾`}_x=gFQ>Wߒi>YcagX=nRWkWMYO' j\l%Rz~6>8$IC=;Tkz~)DKytrX扄s^ڷVF6uçIlf32sws2sC]֓oe5z-hf[h*l}vـI a @ a BdWTDp?㼱1o %怙|#Ιה랂{l@uo-o1*mXsL+ˎ)Hue;Te+¢VywOj97}{X!cω},[Yʾ? cN[qrۧO%`gQ,~&eyksk]#bxTZLC?t3[i>͡hn=C6}B6 ["QTâ@-\^,|1M* &MLEL@@++++<+7S/=ÞQ%3<7znD]Aֳ;d}C6{d=*ʾȾJu%سrjr'߰fWf\,eɵ |Wi![Q&kV*GS?#a5^|jZhũEjG-VK zJBzJR׭Ѽ^WbzWkWAm.$Q_=lOnU$nU$r|N5ߩT~جa=sXKGfsgsѹڹtfZ[V..k/v.>YڭY{z~^?o+J'~:dVC[V̬!G<_K_{_'_'O'77S77S#CFH! !ygɇ)WP^)UŵՐj/t)T)@*TLtjQ'JC tKH&zMч& jNyCI!jQv{R/7RbofcU!h(0E ErhM@ Rd2MA d&]>\Y[F~R2f͸V4)nCjH#Ht'Rc ݍԀ~r^\``V0d!?R.RR-E ?hI3z4R#ZK`qaq^BO^W*ko;=y),{NAs=lRmDʦM} ՚mVsYmh7vbJR!MyB EB``Ly<.UZhR'|qw.EU`ad }$)Rƍ!jPH!jT[HiAt(2Dڢ6e:1zD4E9"=i!̮#=JCo}+D?6`1 =Px1$bq0ELEY5b6Z^E7-\{>"=yLCX{,%U=y=D{"'ٓPŨ{ eڗSQ~}z2;|t{:Z}tf3PL{&jelz{noB7۷@V{۷ٷ;;ٻГQ{^\;ߞOuQT^`/' \9dø6jG##QQ?f4ًPy44Kq)_@VثI__A+گd>p;ZwQ:*?7'؟_hoNf{ u[чm|++oߨa mwۻ ZL B5 Vc P5ꚈZ erW _Clu#jI݊;K݃{tCaj(? T*~FT5RGU:GpQ(SQsP-fdTTDPO'Փ_VFzTB/P+ȣV5:HQ5tAT EgV C:d$:dD}Nu_(٨6Rfjڂ:m١v/՗(Z}Vvo}{W?P:~DmA:Lژq؎MYrgq8RmI'Ή:N'kJs:Uqm S>'IC N&jrCӐN#itZvNUsPM uvwzS8CPgup.tSGg3JQ(;CAs3g'8P>љLr.F+8KKQeeh}3W]\v)Ϡj@TT=r3יr l5a_yCyg#FjwR} 207CyX/72țZMySA(y]|^o\ kSwKр[Qc_k_jkkvBjkkO}E"j+SAk{zSJA?tQ |(F]'1jOUDX+cnū3Xc>k2Og,ޅX0Z O %Z yE蟐?..߄[ ηSoH; K \7znpo[~`b9ԑʀ; TK@%0<'Ӄ2O"r{"cwcD>UWcؽ;c{3vOe %n] Q4/sPshFhd(Zٻ@`- ;'#ʼnNKD grr/r_1 11|b8!FCnn0g'!`%R*&-T-TW+(a>bz?\O1wpZ7> Fƌnj<ȷ(u6U01sa39f0(f1sa 32s0fÙ9 ep!3a3sa30saqV&j'd䪲*d 9E@!kP.I:!9Րe{p!'ʉ'IdKȧi9Q?!j Q\$|g3_/e]#Pf,ur r v;X`Z.rmijd[ߪjUV-4+ g[jËZTǚc͡M-Yw#_iDnXSj3/AT`Gg##5SSEy3K )  T1K<%lTWnTp zFxFPgg$JFyFQg4ךyȗw%wMde`_)`_CJ0d0`z|"cfJL.8R=%iٰ&_kvCn48 rp*̝1wJfԝSON;2wJs:cqaP՘AdZ._1_Jsp<͙Ft*,#e1G*pV9s|S#Dw")w; we }T]뮥ߩ݁].|~=,%jmm@ju ]:LMtSѹ[;TWw]Q#Sz07NS_=Q_ iJg|k5:}J 7f[-ې6X x/4X6 bG*2?#__D~k507YkQ^GEoA;wtRI% f |Yz2m=|7 Z.B5*0c;̚eg_?#Q۱oL_Z-P2٬*O{J㹎D/:6|Nƒc=cciP\™|CGk|\$>S˹ ~z[{k~µh>#gӉXh^wӼX֑v~:2nvs &63;Zvтy޻*ov8~i?_yE0Q}~CWYcq*_'q|t>v"ώ#w' "؎^:)>0oar{TEP9YY[?sƷMT虻R(#w<j̨(r#rtW?>foeOz冲sڋj<9ǯf%K+a+Xu͎Sy#ܟ]x(;YbM佨Jj?'w*5ǬmvoN6#>דj?{~*2X;>W|󰼱!bջտX,l?5:QO}Gj䍋8w[vNF̒>i'g+xt3~0?.>Z=Sn0#se]|"uO Iߧ9Գg9ѐ=jq7odsձO( 6 Wl2$pNc<3ەU9N9Po|TWo/FQ~%M%ud& 6Y1;j-sdNE$c&l'ۓ]d}e_JeJ`J8*rEUX9Kdiզ4vJ7;jS!gPmyr6eݵ)M8/S#|NMMr!5L>!<'gj)ʥJ>/r|W+T(ߐoP{|#NuDnP7O9"P_Sr/ h O'.0;mhZ>c[ 4bUIVBXV*]feXiUj@SFV#yy;/8wfeiv_YfeLך}:gൽq4L! ɻ-6. ,}ET0;.|(0;.Vfe,͎ˢqYt6;.feqZh).Ӷ]:Yk.FHukNcvVE,Bfge5;+Gp=J,cX;+%Z}X9nXi~/Ǖŕͯb5<.%IY['yt*.NYVv8[xtHm#56!o80o-9ԐeZjԈfjk}TNƦv_,/>ւOS J9rM6b^_^//9֦(o:βח<H>,N`^-{ز7aX.ᙌM8|&;o"߂Oc ^~2GviF|rg9rC88P=]]O`?s>F\ق|9s(9NΦ뽷P&{yI[coQޢE㼅ޢ͝@f(OpLc5%%Xjoh̑q}C G9&xFR>ǵ+4a4wgM$d5Lp{Op!xZ1Jh 4PxlstfN:Q'AP* ]&2c,3 uCh6'HcД.3tCm-t  n+ C$oHԅ :@6>ΐMf{9bӧ{7 !CT׃ &3^C!pg4ԣ3gT&3}F2 >c*ʍx=SDM(ЪoP3UH LHȤ"J//D7=8j^z8 G? t GK{2098<8ɿ58ݟH@h ԍ4tL7&lȾҪK"K o/W:p:\3(2%2'<,׌4tnhHhdpqh\T  ߟgK>>P:5ҭ9ozkh] 4tCh{kW&P(n+С7/n菄ӏO >|*<i_=Cõ-t@˸hhhܭr}EE7FGwEFތ<%ШoWtF2hA5C;Zx>๼_X?_F㩴 $h̿{Ӄ} ^^VzmxMs,FfEG৸Jk ;WگG%)ҫ{#OE>_Sߌ,3>^[:1pYҸTyw_ ҧ Z[9'r/ZɎ G/o $2x\. )nc08\(Zz:F_hǵBW/kJGBx K.=T**CJ#O~AwCoQN]nn^lFAxrxm m >Q0"s~sh(!ӡoCPhhY4M&Ds"!aёnۣ=Eۣ/aT|={'.l8琂H#)іiّfqZލ,?:ֿ!JpN@?]녱p0D["-y.jq0` |'!3L xCLX_ 39;/x0x?20#0-0;p{5F^$ ŅRq.;̿5T?eE{C%o=Ba{:|gkR:R%CK)uB !%Ru*bo!^!RC%;%R.CC]/u~?O8͙3}|tDl&~MDF׎-vb3+P,_}t0ɪS+ F1*:| sna^Ekp*~Vh}VWR8OnW }2~GL:zS} O?eO>YڎĻ?\T?(~?g0,OQ ~נ㷮a֡'!|.܅̣ *~=GUT1U8~p9*oZ@ŵB q<V~~һu@q ߇h8'6zAa'5hB Ig4Aډk57<:I҅hn[A Kw 6i=4?ϵ?.- [ 2l"Z٫kl~~?-9-Bh}@7٧ا+";ľn'yt!'wr*Y 9}w:<gw{ArֲmaCڇpI1m9\m׶ mք==Zp֦ZV_)myܢ۴ Rk| 6$p `smH}i[r ';a ((a o>epy@;q`rj gBYn?5rxka)97k 9S\÷n{ w;ɝ΍r? E;({{rop5AnE=LNPy[Q_R*RzJ<-,U[[SOoi@}sKj< iL13UVUہ(~/IƢSљBP:qTUFanz {@Ѻ>.y&z9QπRE"JɫwջQ: }MzZSuk'.ۣ;HzA*Lj&VevbɱAзFUi5DcQS$0]-@S70X6 Vc)0ɘdv,Xfj {gYv9zQE"<|7P1x%O}eڟr> 叡P9zmGO@OjY@߽}F&Qr]$>2^TAR PQXQ~Qc2P8 #u}fi[%~J<41zFt0cb~foCe\(~i&̼~œaΠIfξþbͱ *.?юyϴ  JM|؝؍~L k3wo{/a:q!q3/c6q)q kI\'$>x#=/3~XRH+EJ)=J2y 劲Si5[-T>WwUڥ|JR)MJ71* ʊyrUW^в*pϫeJ#U5uU)Rq:.Jwk>Do4{+SV.A LP= &i:|̗6*/KuCEuPYT"(4-a(QdBŐC.^ .P$tlrr8,ΗFOdqpJÃ|Q:D.)źgB+aCCQ}]qĭ8+y*K4 t >+3 5)r'-ңW9=ςb)eJijQ+6׆r3{Ddw#0ȼN"~)́.p#I0`f4dTgqRZ( ^ԅ@$Pum>ZYxqX-ƈ)|)txAo]{zSЇ>o8S*2r8 utPt) EPDUL5Eu!^>YQy >&Іz“̪suϺRC|QIpE&Bn|k̘ j9PwC}NuKFW$dYEفt04*hdxPa<\ po:<*w #Px(670[I}ṐM gD[~#|= 53w2Ɍ g;a&#3AA/[#Hכ ۥܰf?KUrzvZs¤7L!g5pSɂ$ilvM_(=P`o &f+[{A:?"A.A_%}5P_o/Ϻԛ[)zoyoNZ .ʭ2V\u~:+M%M"22뒳͓J Ewͷ M~>h ߆Yg|'J͖kw%f9OO'--^!lOrF@}R|9jҪuɦbITo=kP>Bn&] ]CT_C67:ej@ne+6݋k^WAOo(8e^Ns-9;p .nnW]r8f!8𣏕nXb2kۘݴݽYC:xF+03`NIH1i~ǥwNئ{z!\+6.-#+V{+lݴ*Lvzceib5/_>L,[gj6yuq>=u ZE!g/_yo;t%rV|yoU} fɀ<ھ5ȁ^/U$'s;BP!9M A?i;'V h<]uw@bk#j_.ZBޤ4k3hoz)ΖSfU:tNuyu!{0-ez_}az5=_Zc!ն&m_-GWA)H3>n- b*M7msV sboɏծR{J/谍:na O iLPeJRo+]f|#x<-VYח@wɻV( ~h,.-}^c0]dSSu V}~? >`t\pJV0[H)ӥUiwK' . 97ثگ'r?O{MJ9%j\>#^ wˇ<|߰o1hCݜ@:9~ R LߕVAu :ˆ[*[~0/W(fmu&{%fjPxmg > wzVntY + m6bg4`VxSuM_ĖL!b8Sy!a+D x0=+z(#+t 3ncCe<2q5Bͼf?F⤸I%qĉK ďkt7ݍmIq\5ڟSY7.j|eN=J{JHL:)S$L=N.UF.AT9Aԓ$LUX3 k*c)"U88A=Z$UOT%N%NS&ϲS /PI|;mD$QiD"Qi95%q=&uP(=y2ѩN$:u\O9 GSG󇔕K8}=sS)'C\.Gt #O Rܣ\ "OR1 :F **< HHp95@p9 \;g8gNpALFP?|S׸<W7/")Kgȯ2:[<]D~#oytKS4&k}#/'~.OjJTFmuX4GG rfx+3UHB/VCN7zny.洞_2 e"xY ~^L/2tCk32a`pn=!OXjG2 Z6W3"K}zQ͊ӖZ)AJrle9"Kue ]ZŻ\g]]]ݔ;ݽӽ۽]uB+յO|K tȔ4v9j-&l=kyib.YWZ=6A{r3s{]gEh3#{B8(KwBilG2e0:yR.+嚣E}rΖg 6k낞o{Yw [D<ݞ ϸg3Y,ykU˽em/^O9<Ǎnנ{6@/nWP'Y]%xW߾rd2*5!4s},'mU1Rk13+B&TׅMj_*lKVrU6 l1 S>y!or]q+]7EqMR}tH2T$l[cX?wtRk_ucȸmz#S.N[K&1_,Do{%W<+'9b{,vEuC `w,wnC҈T$8j\פû,b!Gl/K1T,!+Б HV[}狹%(n/l4)BU?D1ZF41?c~LHG-54ww:]cʨ7 Zl3Ӭ7:uwխ{L.3cqPot"C٬w8[۫,C}t(焽։lΛm9㝖,ḳtgh{qH(3z[&>`9`q,Y'`p:oC{l\fgEP#Z2>c]=Ri9XUiGר3wސt&sgvMCrKn'gJMpo F "U*tܔԤlJ!i4)h!ϼu}>G*ca^mszl} 2W;ʖLcjU1 t/u-Y1%2e~X7e1I;-G*M :նz2"Ig6uh/踩k5 Ҭw DJ"'2>u%':q v.hi ' :/ۃmfÀ>ؾa ޴t%h?&AӾ&{Uߒxx[PƯ:iCm7Im:Ưdv˷6;ųFKKsmemm2FiH3A @3Zr vrrN[G7 Km76&֕@́>-=-Y1ِ<$,IޖZgnG,5gYEzǰD,/4rۀ%6v 3;Xxnp;I]g>;6cΪ皝`yc18}4N31q,:Yg!3qððv3/8@k4s9jNilBO[Lxs9gap NUNj']ªܡ:da#mᠳP(s^6N;OmW;kOfhVj֝i;yRM1W-FDK ;Ļnv;$ M)vАLZGa[qH\sv;S"6 )w{b#xE4$deQYCƱV][=`t?ec1DX'Չga^J#u0$5;Ⱥar9YLYYaIWվ; MV<5&mP{t<_j+otLb߶:B*79VyX]=4IVi8bj&:Ǎw y;b&d԰a,j1\ځ!j ~?4oo2 5L?ԺZnyJA5y ޔr{̅^mV/r Q(7{Frj F&8a!a0-`X$!@u c!e$zYy}#8DZBa?/Gpޫߟws7^I|\]4fk :ZF.[7007ZZjo 4Tb5\z -M}0ζ\es}WV~⬮k巟}||}*\kwa;oo9?2waX3dCK#inȇ^R@h_ bpK&d{G.1@..d/M\ݐBm4{qإы/=zkS--QRn@~퓙ô^hCZZkll/v,٫ksyLop7ReK܅ G1$;QԵQT"X1@8v}ko]c7` *q=gc}fR߅dp-F]蹔}}3zβ/vV^j&g/q,񇗊-ݳ`&4/_Jsbҁs[F/ D12a/_bbS!LA%WXyĢسwϓ[o#0rKB1N$%QQ,EW/F G cva)(J:boaTS$v3X bMMoMe(n2cqM67U9EL1(bP$ ELQFS FS+"61 bK߁XDC(!a.bC6' c<rx$ ǁ(}\x4>q o~Gx>b_#܎xjN",n#C6 "&}8o}x/ۿ o#rSqkKFR:bCUk0·T3o N?'?'HK"0"To~JDȄl9al9'=0z" `D0評 >\~/0o"{1Fbax%bG]xB_m x%cpw5gS#V@ iP(C)>c(E41"PŊOI'0zRdIq FO=)rA1Nb D7Պw{ uxӘuW)D݃!^{uK\ BoQINr@]r@:wH!/iW>P<}C1nK$;MUvj.O>V5IBZ*Vƅa9S5C_ȮVW9 %GB,=! , 3JDrK%uziNZR. [.G9 6'w˽jAEP$Ye9 \x s":K$7M&ub37 Zbjx[۹eIސw.9y',B%ƹŒN' R8!q\aW G \îxxh ڲ!u5H\Se#ǂnЎa0.`|FAh)iiMhjwei~oqXpuP+q`̒Ԫsl/LPd7kTvSsuA!ZN4p| P>R"P6Jwi`9Y8;p}CKFSK[r #|G$%Dw z!ݐb&mi h*^NurlYԏeH F, \1r$'_%|M*%Z\{O%`)G˥ EP^;,mfncUJKЉzuu:M^ qX }`!G o\&fs`4sDZwFcM&)]vHHy0?)%) =`yk|OH!=I%E 3%q5hi8`I "N 3~УqY\uefMME +MuhN&55 xiZ+AXش m4ez6A25e6 gDK"o` ?MdaR0OAd(\J+lF :P*f5f'z[{\Xl g pN>)̃_jYY\%7; \9{A2VȵsV$˵Vb7bG\63w[?D\#'ewU0gCYA }a(áC{82 h'G&qu?8}7Aq #N߇8}?q_>)1s bQ $X!~G,c ?@I<++ _DR!$^@I@IGz P5Slrʮ`ΐ!ˡt: PrH5 $_(>0QY5$g(*$[pH'!0+ʌm {GC|3+j;fIwjBIPg" 5еPoh5w]GMFp,8\ n;PmHLJfBK2C^2Ql,_ +gUNte5uzK> v5UvzQ~궗΢S۴UX c;-NwN-%i+&-ے5c͑d{͢tWW@MY+-TJ;R$U$8nKR) y^i@0"2UT^ԕ \I͘F(iNѡfC3\5CP&j.ƹ5ʹr"gqc:pl1sb>h_aW17mܺ&j]Pܜ 4=ۮPzd[ȕHwsekbuCu%tܚU5c|d(ޔz&gVf}Fg-erfX /y3{&h-ᯁuy&'|1ݡPh*0u1HV?\`]Y,[e!Yt*d 1UZ]եֹ3Z׎uW8pFkلwWViS[o'죬/&l)zu<^ϭ}?K'Y^3VMqnݪiJ,?-Ե.ScyfxmvLc5>#lJKTPhlkz3@r@VC,fC1̦;H%{!" *@. ;GX}(:8\]8`7`v탡y3+$bY}yzfAmfMa06[&CtXxP<+FR>D?b\3Ip l5[D!M =cv B&j-j]]foSw`ˡf@77f}bXl"V[aqL6[u|G8"[|Lnqs",EpuZ3J\3V['r\)Ɍ\|S6 t)/4l=Ma}[vʼ|]j;'IYAzPjjJ&Ug$,_-_4mjr޳C+ձEJI>梄BpY{ZGqG{vZa>&u_of}[V? @?!)!p"4'c~k$lC}ghԺTOzwͲf^yzSMfo7nYVxŏEwTg1SosGʦ۰_p\ -3_UV8{rw/#' m{ots,Fm_uFe^58N%%tQ6]YZg1jO9ނi]ˁk~1( FQ Y}ս巃Ar|?ퟫ#zfo{f {U'铅oBG,zKgkh4j 7f7=ޱ|wλXDB J |#2WU9L@Fht av抷zǽ}2i77 D6}~k( W w

QQė/c.(jDQ!/|y^WzUgtVտ"& `눉.!*;wX7ھNA'\}pup nևι&:G蜫YtՏ9W?A\-sA\-s~ιTn*bV>R>)w~S>~U8KbEVEaOŁM zCPzWNxgs E#>WZx,ޢzSz3zTF_{m}|}_Ư;>>}}fg_ž U7a^z 3"\Xf;327ӊ$'3J߄R1߄iRS0@3з3LfxR{V9832k;ɜ-5e'rc:A䞹^fטbrVEk\R&wԤ;sWN~P3דaZ>xi} Air7$x 4lCRjsOnڛ[c8l..YX mE[@}ɖ-4lMz `a2dҘL,sD {/Or'01w܄<)Qf0rV4^#<3 s a%#fYe6{қ0yçcs{ 90:pTK b3hoaqdدcf8N/ʌ18т(8Qi;XZp(/#l+KMi ; +ӆ(o7Xɭ:pn\fz8Уh8>ta:!.Nz4A#ctG;~&)elE׭kK N.-ʍڑ&Q{zQr`C;2+\+aVbk ָq? : s4?zftlx;Y5͸ŌgCw@=>3Jt` fh˫+v\P9+Ai;H+-&{D9m*;{$&`owۻJ v&=0hЦz}n-ɈXRÿ` |H|Ĕ>|9,_g%| S+^QSxRL3+~E+~I/bR ]Ż~{O+WŒ]d=dYy#{^Y~9@`ɛM09"9r\%r L.cr{\%WD==}},5kEK&m%rR]r"|5ek Zõ}}ثO(?)?$SOaO+?3gŎ*U>锟S~P~^yL|N AyK/`Y/bo(S)X2USj,GUj\e2 S+ӱ|@GMEMaQQؗffQQɨ9(j>jΏHcGTΧxOSqgDT^ޠ^Nz UsH*^U)zc@J ׁDӷ?ƧMxZὧF '2g_}VQHi !Lve u7Ǩf SrlP?;#eJ k:zf?CM9&8ZXTGGщt K 彿 Giz3g__(4c Զ^iegtTЏSO7{W3Օtjk~޳2+sRGkյO,T~pY]KΰSGQɮe]Y L.(tvkr®^@*WM Ԭ-sT}&j6;+ߐ}4ҹy@Wdܯ kX@e-p\:~dӧ63@Dq>);t UDbm]0u(sG~}-sֹ(Ts41ܠ 2uG@jyhy5kx}PtmY.j6< }IzhJ}:eH*jKե>D[5ja4= ms_QR69=WrYRvЯmѰU겆u/kuŮj W{w뚫UKi3+ U:Mj ժ3mR\ ˮ[@Sw>8$;]H#F=+}ǾNouJ(u;2b'i:`Цct"XЏq8=јr~SUgt˾5(i޾ .M&,+e *e{FTW>\zzY0IR2{44gZݗ@IחDP~{tx.FW^ea".YN#v4T=N:5.f<ٓY“$uuBuju^תNWVwT84":8;:=Ikn*_PzQ鸭6;m̺~_;at\TO5Emu;&ؚZ EF7xʦ<㱣Qy#h,-hI1s鑙=k]Z_wQ.-u w q o T6vF;Kۏ?h?I͜9 ebQĪ*{jÊVjS^ڡЎQu2bՕxrUsU-3bUWtԋ6jVu =Y=jEզU+T- V0'`ξ]8&v?Z0hvso3bkbMk ˘QmqMh>advgQ28#k[3,[Zx1DO{ k`ZW;pȚ5iu#z1i؅&iq4[5 ntlw4]XYXhqM FSyerʼz9G ;G ;k mEwm<2&Ϲ-XY#V[óu:hfo];i]Yó'Td άwNO=ƞ+zMuTZZΈ1nw>ҿֿ#* t{=5H]fJyxc]|v"9RǞPQxo$)!R;kRPVo.zRҔRIuwx{K2vT8DzkEGWfgԊ󬊮q_:)尣YԙSmyGyGD`$zO#uCr$.M Xŷ!ъqMi'撮yΉF{;9:ѹYYh^!Oސ?Vh4&Ǜvh2W:EY>+?.wz+B C5eYiƸÑݑZ9ښ1YjDX}&s=t1Ntjޥ[JEƌEI=C) mHJEz摴EJiq:}UX 'TָΧT .\&ƞpzaoE5t8uGdo`΅Ԗб[cskܽᙑ 7\T>f{:Dtsm۟7;;9ȉHuw(\u k^hoM>q{3vu?w+W!jFUҨgu oR"W- {ǨW+rN8.oͣF8~0B|=$7p r2\W?3M%O Q?o><3rkdd@wfFp#wsW^~)TAEAcNj+ʿJ3R|!ef#H\IѶ7|5e,29uԁS~Ndq lNp`s`&r Sy:A&qꠐS9u0SArꠘS_A nA)q`ǭE+&h k0a,3@|ħC?(o[DڲoHzay(ʾ#_y?/GY|oZ[km!t[[.K%"Mܶ4-6[mQ#nH;vJ\g@WQ`胫^\o7xIH[ +迒EE!r==x˱go9-9xo9['㉼8|r\['Br<O-ǟ-Ex*o9.-_-%&r\[fr| o9.-Ƿ㙼xo9.-xq5o9 o9[[kxm[ǖOrOіg>[Gx?Lܑ2{?gyj,/<>mvU!wh {5[[֐n>I\kxB_&jZu~0~j$+Jk:z#Қ}1>X~5g?+bPY,}$x!,!S K86k$je, +I }lz#. Va˻8f>!R:HHv ~<&B ]g4 =kA>-Ӳ&,+ Z5AH}hZ_ĭR_ }| 4c@Ct¡ݭNK5 6oYĘ?d2 bwUT0GE$.哯 F pӜM7pWAgiAs!,iK^,;"}6OEpS'ezѻePpx%&(L$87  EI ˔` J(IY7Zv]5 ]5R'5R­_:)U%闑5`|{xJrpmXUͼ@ND:g3`iOP:F <=OcC WRoF}w@x:^w!FwʋfidL'_Lc.e4ϳ >MR.z>z3Ѫ<:'ʧRf#>9,8x&*2PWuVwոgi%w3*x\^Wr [qCc} #N]t?iq!)WaӔiGAe_Q#MGv%M%7 @D=G&_ߥS "C؉'W31,MUMyʖED,\0b=~X-*Yߦ3 iT\2޵ʅ(P3}P*%j6,\o)s41!>xey4f63o9u?A {#t(4؅xPo$ >K/T6 唗l̄~^˒ ~_>Jx_*xU+(OX*/. D'9%Pq AwE˔'p׀'E &c4O4VJeISFP~M7S_:J`WƘhd(Lh"?Jp.XJG4\-Ï>6g۱@W~&Vd"Q N62RvK^Ko~U.С*g*+:Ff:VRDmaVi ixS&0jՙ lO"SQ^6l^FI61\d)z I1GXVV|}/0nKZ{Q[SVVMS-j}5]zR9 mdl~lx|ڲ#GF>O\J\(y38<^%W#@w!mypNC_{TA C; } d1 pifB>l5<' 'h8Y~584;.?}i7!3DA,vfXxX-:uiV{;qF<+c7u<(}9wQ( j^}; 6ZwY4Hs3c o2'Mϲa 8/qw)}2n j=SſOpw+wrW͆);BOY"RY(@鍼fqWEFjM]lq]?R]ao`'1j~ZȂ'17T(ϸy瀬sгN+ujpiT~o+rp>zZ1i3:=]]y˷nwHgwpeU bu5Ug'kWf%%ܬJ'Ԉ#\c]V=zc z <$[ZG'XjUD3CZ6lC{FWY0&| GUوmi2#J%5XK1V+ DgF\la=O}'WRv$sA_+$>5VTK!QJ{CW };x/Ms72Ù,dz6dvqw %,r X_@ h@ >LBCsA Ѥo*Տ)ZNY7厡vU[ռ g^9#B͌sK.kp7p-dC$J9猈x9g1+*"`\s &LȚk@0.b~gTY.{=s鮮BIPf'Qߐg,p(0)s%ēt7LLVƚxV//6es%8 $s wmz'p+2ϫ[(x7RJ#~W*HY@Hz '7 uR8 4q6ڢ@p> j@<]/@$"x{& 9 Mu}䙏8N?DkhiLy~A##S_ J{ ~mWCQ"3劎~>aMETsEw.%~*A?Q~_`1YpXsw(\*uX3a͆Yo &XzIܗBD!ކzAUB9IZ>g#%yG }Z~U™Yu㹠.pf'z<K450Yۏ (F?} $w%%';VId!YEYX%jyr#MbL"/vˑm(H ,( R/֙)36Ǜ qJ6cJvVbUB/}ڰd{0?uwh*YՖp>8dt7yMNvY)qIwH1ovKgxx%`2g\񄞟! p.&zK1+[ǟ] M'5~ާ$`UW. Z7+0ЫX.UX=ĦN֒UXbB6`p3PL-ى*ʐƊbu)i}D~bm*5/%/ba!d0H@̍ېg. 靰BDZ۞;s@:Fk͝,ރlS 5lDkıG$]`0b1 d/G4m&Yr%1QɚNfᆂVz.)2)]O!=Խ <֌S&c}K־bW=h8ڿW~ &oN0H]^;'mt5kp)kbH#-C" ҥiTP'kYG$|$p/kfN3?~ <$'#= K͔  ll6sθA@Y>}$pp pppp\i`5p=RUN1! x>Cǁ{Nϝ<|sV۠͝6m= 6ˁΟ5^x3yB ~ (/Zz*t+a0i7sD3ҜMa*pB7ƕquYǜǍ7V?,OQ~+o*N{2DBǁŎ [v^Ep#y,|1o{x!TUE5R@5VQ+jX5u CՓ"Zo7n>Д25M %X_&?{l(s,MxcK,{8&G؈d6 4,^]䎼E{-M|->q;;^yow}>jV(xM#y+w!6E|-_G|+mr lke3lr\-7ˍjC7v=VUGڣ:ꪺ^S}CTS95D jWUW٩Շ/՗Wל9? aÅ.pz0\)%dt5f)w5rpO7{y1>o ~cIo 4n>1{xk)fǃs9PUy2|*ýW>{ޫ ^ex*ãWXUsWxU'0O tyR`˓0y6Stmgxo3<{Y fx6s|mxo3{E /fx6K^ /fxE:WêMp$F ~T-[VFuͪ.ޣnFmm[^mznc{>gORu:uޤj}Ѿؗj=`a:p3p7QnGYj[ꖪn[rݽnpOnۧj{ѽW+j(DK];.Nό8ҳqQ=;syz^6>_///Ջx^o[v}V|O|^oώGx__/44՗e:f: LL1303Po fFdF͙QQzKGVG{ѷxo?VG۽}GGΜ9C^c/#qG3s /\(2h T'yMz/gB7{ rwd[-} #QiGyo~ǷZk5S䩧$R-C1z z,z[BoYe1˕G/W\%r˝^*zjjjjNՁ_t(JtH! C"AKD-Q+/AKDQG/AKuD]QO/A2>^Fd!2"c o 2B'{AnE/#4 2Bz^"4/4KAD/%&x^"h%y^"h%x^"hZ%Vx^"l/t:KAD^"Ή%hSicϘgHgs揰7xgyҳP҆R 0GCTKFHX}ɆԂ R+jG%ur26~~ O;}hOMi [T+W̗qCwnnt|Ӄ4'h:=M{h'Qp KC֬Ru.+J\AW'pE]CW1p{S4niSM[3\30S`f0s`AKsxG:X͏ux>6`{csl1UؖTi[ƖUly[QUm=U6 T}6Q l3J5@Us;VvIlѪڭj}žV|ݯ.Au~.Ե=6;vJՍp\z՝S_{I}>rߩ΄á^xjx^~ EQh hzt]`Ύ.6ˣͦysmbjFGo8g͝q+.4ĥ޸|\+q͸y8>)><GpX<"eĹx|<쉧s"]*VvQADfyBFXE{(+V>* V ^Qo}ݔKÎ.E}@옫'|Ub C/x%{"_Dw3CE[Q'f[u,M9Dz5t1]E[]"/hC-}3feG=#ܙyPm{gA#($.G-'K)yJyIoPPH/SJ)ה"_[JSIy囔2ߦ.)e~H)cJ EP$duBI( d]BlP$% E"_"=dS$kE9 Ed &J(-P$[4HXBl" E%dK'ɖI(-J\Bl2RTL)S)L"'RZJ)Ej$f=EE@RSU~#Ej91H"uRM)R?H" S4J)8HӔ"R4O)"H˔"SI)6HWڧRcJN)e: E"<7!x2jG1w#UZb ª*J5')zzg9zz^%zi(H[{q|#,b9ePYe)RXeT2*D9߹SQa\7"zHEB]](c;Ee(Onޣ{zo)j\5zVo[V}Gϥ=7$B'{(wLǜSUHI^x䗷YO#'9BRNrUwGr ҧzSp}k߿OugyzWUCҽ}u_yz_>R)~yz{yzgyzyz_}[QR.D%e%O'ORڥbY'<>?LPNWwԨeBTPrr1g89\ r!.E(\Kr).e,\+}R \qu5(J>7,M)7܂[r+n-K[nw+3w܍sɽ4}$(V >TΧɣ#vN.<'$wT& ɳx6<b^Kyg𙼜WJ>W_85^MP$5YMQS45]P3,5[Qs<5_-P "X-QKz:]T RVF}S߫ԏ(lJkmtv:ԑuFgu. B.b.KTZeu9oAbAUbCԵ􉺶jizަkf9 4'A3 1C0snN3#H3ʌ6cXƙfh&f[t34l3,0N{cvA}>bcq}>ewۧks{A~/};n߰oڷ'ޞX~M~iٿگa=bߊh:KK9 u΅.r˸q\AWvE+J2+ʻ **WUs] Wr'bu\}5t\c5u\sµt\kƵu\{ut\guu\w ~Nrn; vCP7̝ꆻ7ҍs7Mr7Ms]QWw%(7ڍqc]{ͽpoVt?)|7s^~A?(< ?? ? ? ?~~~~(bQ:2QEaEqrQPT8*EţQrT%:!UG'FQ~ j5GMQE6j:DNQk-zFQo/ NED!hX,n[ƭqm.nw;Ɲqk-{ƽqo/t`|r<(>%i|اu:2tl uB<1OSRψgƳxnCcr޺M6/_i%f5tn b#m~f~3Y{ϯAX?kCU׳ӳf?R1Vt9:2(0$e^RJP_mj n֊ T5jS"ݹKւGm7Dfb2~HUQUeTRGɈVWelX5;Ow:2Q7dT-z%+%Gӣ~|AGx~|丅o%swާpWLRw{KZ'mwy} =&zȅo{B4mf{8u^9ah4kZM5Ntot65/+\8Io縟tZWEѸh|4!M&GShA0Z-DKeѹhM6Z.U-oГД5Q-:1lZGmP{7ϼsCn?ա,[GOűPgK/Q7zP {jJUw5Q P V#5JUʥMUi)if:dFs Ʋ yPpX ~Q5qIb\֖dpȶV~vݸa{q?c$k'x;U44{[m|fnwn㖸͝V.rO^= *’2*x;p!%\^rp33LL%{ {Hm~=niF݅9%\v[KO)=1fYi2sYm3kZΜo֛ ̅"s\j.3+ss\^^|^|_̗|_Wy#_Ûyz^Og3rBgUߔv>Wފh#LEpR3TLh׊wcpd1s54S5QMeRɘK$)t/(Q0 e6 Se؆JTNzwWPU#QLjE"ͨ;ߕ)S_-sSRf(OKRAjWQ([Ve+ I%,Y v{Rw_K[m6Ci[HP9%wޭ'mKwQfaΊdU~w6OioPW+u=Z T@wQ!NH-ŠRZRvIP/#. Z~+Y)qLztOaOTzEt h:jn#e'Ϯ[stM'oFhqs(/m1Mj1mAҧ?hCCV kR2e7HKCUXzˈ_P%fɱ<M~E/N|GZF,ְ},?ڀcǐ[2nMp+Po7SoS??Hb}Ptm3 LcZ6Agg |)fW5l-]ˮc׳l+{mcOgvK+k {bowR\Z^hV]^_F ; c!aWaI,k{Wdy##Amf[?{ ^e׉7wcveu-] +HT&H$18r2GNACș'nI&ZfI $ $Œ2IYJ6N[_$9"i\\ܐܖR,j&CFKCnxitt4E:N:A%͑ΐΖΓ.H˥Z:FiEz\&m^^^ޒޕ2L%3l2,J# %el4,YlXV&66desD*;%;GvWȞ69oEer$w}hyHލa8yC>[>OP^"/Wk[;qy]~A~Y~]~K~W*$  )<(E"NKO1P1D1JHWd*bEJQXؠجSVW4)(ZW7C!dfm7$FR  YLCaaPkXghbach04N.nFQa-F1`1v36&GSi dcqXb,7Vk[;{ fqcxxxx3Ed&dr|hSWS/Siii)Քf4ef*MLkLML[MM f1 y%UM3,2+:2̝]=} !Ts9˜ki7+ͫk͛[;qs||||·,*bx,QKeee%ŒfɰLZfZ-EJ*ZfKel9f9a9c9odjice2jzQk5ޚhfckMfZӬkuuuuuuzb=nm[/X/[[oYXĦl6ezچFْmcmlmlmb[mmmmmmvb;nk..ۮnYĮ6e{#q {}=^h_d_joo[mveu-]8T818G/G?@(Gc#ݑvLsr88e*Gccαqqqdipڜg3Lvu;YyE2gssssy>>a=2c8<>O'$zyF{R<<l OgSllyv{{Ƀ}Zi젻K3} Op~Dx!wbLgyʉ8 -@#A ::FFrhMwװF$ sö9:H2XilOc-cCOh$X>X>X>XKqm񉆞h艆hhhhFhVKSM@ZK,jE-%BO,BO,BO,Ģc7Xc7X@>} 'пO> +ˁ++Rt xچ>@׸tVp".]Υ+t%si .%)[akmK@J@-embke "r J`1H{glAalAaJ:XN P C(4<BpL$MB$ؖ._KԶ$ؖے????-ڒ-ͧdn>%s)O|JS27ͧdn>%s)þtؗa_:K}/þt֦ؗНٚٚٚٚٚٚٚ[kq0a]Ìw 3f5ؔ6d hCπ>vgLgB>hs&JeT&JeB&fre\;3vfrڙɵ3kg&p;j׀ˀE@jG΂Y; vg,؝8Rgsg-YhKV堆Ԑr;s;r!򹐙z:NGn:X ,RKÒ$-----yqcǍQ7FyqcǍQ7F)Q (c1J`R`ǽ=Ы\Zƥ\ZɥKtj͢O0er`%p1 X QWK˹KsiVsi٨u6jZg٨u6jZgsOU.-r.\Zť\ZZKPk j-A%uR$˖QZ|2`9& W7k[ѭׂ^ O%5 [! Fh(EI-%h-Nm?Mc‘d,ͽ4rWD9kĜ].HD^,?gs=/.4!+/E}Չz?p%E./ߺ/K^~+\[x䯮^UÊYyyD zW+Ujɪ@Vct(oa'a?DEFDN,.*璑x{ #ߓ;sR Dއoehw>>4|اADx><[ąs_Dra#>uxa/Q~a;)7)=n;FЙ<'(2 Oh3Ј3 Oh?^4 OhKH5 OhWШH{>6 ӆ Mm5놡 M}oAq ]G04<7Ccmvz04<ǒ9eɨW1 z04<Cz04<Ccz04?Cz%14J>oCcz(14b> [ _ a_ a_ a_ a_ a_ a"7~P  M}#3 M/KQy4ܷ$Ձ3 L${g.Ґ8BQ![ t')42>֑o#Fz 祑CX|p!!r)cuߍQNNg RGX,j8*)t B!5>KbRs+m'dw!xj=d3ٌ\W.={vw 8>g)r]dtqlaa9SrΝ8erwIZ/Lu=BnƔ/Fy{GW/KkQޥ+0a)WDIXRmHMǟ1q򳹤UHAQϤO29ad7f??Wg' 0?a3in&n{v_qzWr裾i?2kٳoC;YS7&<ĵg1E?<Rk̛_z]X;b1X4t&ύ]o䥴+ ߹[?t?2"2a.:8 & }xooר }k8;vAGW\ȟ\[l_@&sn|ҒYYH!"SW($9˰sBs*UOfb*ٺC@{w}o|_HIm2Ϭ0DN?씡` 2;F!)V, utF併qrk/W[Cf~Wөoh*j\zט)W'9w`':j6^oknXrgq̝=&[_N.usq~?&F?K#凞8+&`qMY3;6o{'[~1|kYY4;L+7S/ٔAO-zl%G*k d|N^Ӈo%dɣwhK&>oLS5f&YcҸ5#!Ygw5]pzk.]~.8P3 ͙?bL]v ?]{vly+uRT|fUMo%^O $lxAó~Oמ]BABC;$ 7?l1g~>>"kK[o^8F̖"zkwȾ4v4W|)_~s}Uز?>2e]5jooW~2RmxauyaR^CߍK1cܯcfu槣./9]79c1 מ_bѩCv]+]On|v/k ONOPϚ5ffy|NV̤{c3~ʤM9S_;s$2b+xBa{zzvN>>s_PX}wh/NڷI4$Not{ʸջ-ϞH}Qv={ /6D?ՊLcK;\<Ф:ə7w2폦⫍~ȏYXӗ+}9sXՂO>qY[}qԝ1w#~nxW ^q^GQ 䟮ڿ ΜEKضgG豯Rq$U**.婳mկ6곒>ë*S|-g3t -%ם.==^gIL}zRus9?yľI{nѩ[ؓ4jkizsļ87/~q''fOpqoo?|eO5'<::I3Y=1C˾۳J4Ƒ1=R;ndmz_9=7;pHqSPt$X=`7SGXu#ֳtcgm}z oH?ϑYͼHmΖn[>c2;eAIΜw~5oN3ھtY,]7Ă,:e0 dV/C&C2CC>x(.A!K'Y TpӒʂĂJ}raVֵL[ZU?Dlp^=~.k]=QqsыNm{Ծk^dyJ;+7>.90ʊOiNmUNr~Pl7ź7#t9Ʀt[ȼrKZ!DN4ޯGt²e;o\IޠIGlML<@!'F f&)1.j^A5!N5֧ b¥۽ܻ7iJvV:HOە dsq51_ؿٮAL'dt9gl;$/q+gl䎵tD  ӜݤC_KTbbwR2c}7p+[,hFMmYZܗ-~׺}7}ں(ˉA %MIS>gkf/οԹm 'r_chQ~\#o572 Yk= >_HtjWM endstream endobj 2251 0 obj [ 0[ 658] 3[ 220 652] 6[ 573 705 578 551 646] 12[ 350] 14[ 682 551 846] 18[ 695 614 695 662 513 639 676 634 961 619] 131[ 535 591 469 597 531 326 520 597 314 302 592 308 890 604 569 597 591 461 459 365 597 531 798 525 531 479] 481[ 232 280] 484[ 232] 486[ 337] 491[ 452] 494[ 235 235] 512[ 505] 820[ 371] 882[ 592 592 592 592 592 592 592 592 592 592] 938[ 592] ] endobj 2252 0 obj [ 220 0 0 0 0 0 0 0 0 0 0 592 232 337 232 505 592 592 592 592 592 592 592 592 592 592 0 0 0 0 0 452 0 652 0 573 705 578 551 646 0 350 0 682 551 846 0 695 614 695 662 513 639 676 634 961 0 0 0 0 0 0 0 371 0 535 591 469 597 531 326 520 597 314 302 592 308 890 604 569 597 591 461 459 365 597 531 798 525 531 479] endobj 2253 0 obj <> stream x]j }^,9o{`!=д`t 1yn83FHa!z7hlB$I f7 '&3dqldHUA႓5 N\uD79:ngpDi!&u {W:"Do Oh4pISIUCus&(x}SiqC+=e5Pv TV:W|=8yYVݕqSq_w6Noh_Ç endstream endobj 2254 0 obj <> stream x @SW}/ a @HDqPDA+ mRZVN7EhoRNk[̴t]fIk۩J?ڙ?}N~{}= ?dP[V_5טr./-k5z7__^:~zW0WV^S2_XQ 6;S*3n @ś]y'ofױօ-dpX]UCPkJ.PEoY&a~ea@ -s4^m_؆ :6i!/ãDLd@ PSoGcP&ح6f#>}]-?}LI}R;P+;<%#~}ڟ0* eY*ܶA:jPlʟYz@Z g<N9nP}g>M୾: O_c`?ʫykv+x>]_p~v?hg0 0A;a?-Xa(Jq wb{>ZD_ċC GQŃLJRLJR{O@z a0 0` a0 0` a0 0~Q@߁c111d,` `$TsaC',aUo tX!Z`>}LXJphpYoF,%p!\K0+5$*zR[3*kW־5k0١c2+`5b5{ ơ#Ny7VVuذI}0@8^qP'#[djCv[n×gESۚ&~qي+؊zն^K Wc0#C=iM )tF03rE7i{զLmr4zwuk xy]eZUkmA,RUa ` XB+JWc»6$ Ԧ;r5I&^ 9T86o$YIő0ي֖Ak=:j3i(ϕDmfѩ*'6%|Bw,*ć/1qȗxϗBKx6-*& N+5_ ^!2%‹4DJ>Gx i~S' O6#{ {v vvv|._BKKG!|Lg!FgDc>#'"!3#+o NM5j U+؟˄/^ c)b?Ux:zF581{ {Rӻnjjza'au#tQ^6VC- bpeb #닩A㋙3q/fN_ql"Q[)*y36Qɍ|1zu4k5Tj}1uuTr-*_t#J_t _t|g .EOC.SېG"ʓ L:$(PLNtxQ<!-(_j{ (|).{(6[(o:_QC^=(܊Kq J7[M^3p_F9p0PJvCpJń4B4!c(ϝtc;P"X. ӪOj  5j*B%aPN(#iVBBH$$̄xBDӌ%7#{QNG9.?PG(ʷ(~(GG(|>PGQCyQ<ҍ.(;PW_%$ 3QYZ -f,L t4TB00!4\':Ep2 tFkJA$FW$DP(a_C AWQ^A3(/ލr;љt s&]\sі՞U+=nYѬzYiF\rʷV*VT.\eGQh_ ~w8 qsm|<-s<ٞggsgΩi[z)X~wy&mLtNL@}3~K gjKsVx$--G,2Msb{Оx(H؞p$AXef⯎#C6mGHQ:Rh769e! #6Gl'F̊2"!?R81|Vp1"E;ܙ[Kҹǹt(D7Q'^cn3­KM(NҊ̭gV|3TTB@@dVƀb_#T ] Gu20V;ˮOwT /xNkbM]L/Aib7{{bSw5F<$v1sqK2s1jt%@;ױěX`S,ك%y[Dj =088ջAZ:sdg0W达ي6ފS<)c.`~ڋ!{2<@WX_2ʼy]_罉Oqw8\Z o[L#T ~Srzk 1?;DG iaLLt,\M_G9$M$bѸ_2gf7%d///NJ96҂yFf\_$,ۯl&aK̅\Va5٘ˑX 01' ~4*] x"(j`4eea0)=ah[Q2Ag6؆*֊uZJz}8Y:\֣}P9ؓ IR8bahݖ.Hab~ECb։byo,yd}9b$.-Q]c+̈P"YESF4_8#FuԬiG#s(u̘gS?llX3̬'SIͲ 1)גnzM{f&geₗBG9LZqR;6-nKlg!R%äa-by:BxnpRru'OOgnկn+ H߇PTJgɳ' Z ΒoOϳhGt{E֫ 4GCq3?Uh*vI4Xam) 844v.4<>85yae@Sv$&ټGLd.=Oq'r'=Y:NK 䉫gZFjԩU&Kٜi%yI:ָ@ׅǦħ]."8W\VEe8|֣ASggeŨnI֛'OzA$4/y|~nnOg4&Zdhk 3)~((yI8*]c(M}SZ5M]gPP6]dw}VbSG\").w9 LJ< za(7w m? J+,dKŹĜԜR)o459KsZf]R.sz\9G HF؊ِX+tt#a4uؕvFDDosYy`>)"2.ph<("G$N>o. |)r=2}A!iڳ1?6pEͷsYYޜnwdK+d3WXg/L:atd#(j)8X 3 Wz|45]jU.24ݟͨ\kr-n> s}ghI<[S q'꫷q_}ɧ; V:{߿i7[kV7\\lS׌wrq w~k}KT-kY_R䂞$:xjMUnҤQÿcBu`:m9R:p YФm8egIJzA`%K=95x K޿x*Zr)cg]8DJ(_#a]N_yeM[&&klв< =E+Ar.} W\4yIm#}o,wfqtqo\eRm)I[o9t1s]:r]S~{˽AoAo)2lC4du1LٗYbԇ&fi!n˝\ڄ|@zrG:AsvVSKc-bJl v{j,#%jeKb2rC& '旚'Lv0B:4:?ˆ7 OHDqW2hYrxTޘ.5S֌98*<9H9%O4 `O?Fqgj^jWov@ͲwqT$Y[;,Ϭ7J>f_鷵an}Tu7j%pV,;;F!íc7;vĸ&i3!nަƤ\gҐxMrFrb{VI#ggI݌u3&Ktx->1#^lI+HtPb?CNOp>o7!;DJOΉ6<{;?-u3I–aI/S?UeZ~ݙ=LQڸDː8 ѯ |*ۊFLp ^F|&ӪMr%[O EE?exNSA:Cz: hS22 *V7Y i ](_83Y֠]H' 1Z48yU3ʥ¨-djQޗUsj_Ֆ,ɖdٖlŎeg;vlNH`; 6%$MahgҾiB[Y$Lԥ%fhi &--KtwΕ ~|ս|;YPY2_b3VU'+YkMEbz+-xѾ!$|b[Pm-J_JLEz14|d3Xʩ`_Djw2^ֈ~ϼ*5*3+_`-ъ+[EJCf14 VX+gYb9R6B/92EZ82fG!X)=~2WJzt3fXun輘z(,p=Elvyς-lY`+, ֦XҭDNUU>W[Rg%j9iR}n?l ?Tqr34׳+7u9\zw`,c˄Qg~|0wޯVy.F؁HPdTe=GR1?{{hoI3-d$Dѭ~OES)db #b&RdQoΌ@^}$.%8J$6KA'x^'iȫyr.^uSxeFX*/Cm19a,"/yxLs i J -Y8G*ըtd)Tb~ f]Vϔ[KmhE+wN @#Xt8TK`\[j(D)fQӱ[T5\C ɒoMM9<s>1_o>F%D%Ss t.rh;ɢ2rRF)BX~ uu>VOV(XN[(Iƹ+":,I,L^ٽH2K^dx}uxӦ]q.5o۝+qUҶ/pR)Y2mk4n >KK.Ch-kїV{2'1x7F\*ɳzdB&ZZH{h| wdԁvbni=uzrT;#, d`MHc<] Nl1ʮ%J!pU%xʷpakVgՅTIWڪF|awniҡ 4?Vhb~5nͲ[N쩿JKg/\Ol~' ~n.lRv܊JYUAկ '3bf X" qo%Bz+)ތURk}u/\ jr1ktƭꚎZVk2O)Yk1p޺p+aoG@TYK? AcF3 w>iygږ[ {m'3N|*x$ ]_QyY g) 5۔>vꍷlPRsInJV-5ǗwM=Q5/}R֪͵u&T9[;4: o`FjDSr^P8*PgQN$Dnzs踈)axKv[Hi[USnogy'<b. ^7484Hf涧2ںiXE~k݌)$eOJ/=72U2}'7ׯ-߳Kb6l,k3Zբk<C7/nsאډb#{%I4uu˴q)[onuWaNx/vbk/} [L85ױo7=-0k`x"Y&ECAH(C84Cc#fe;/D #j?[e f0?Y*,-fKn%#<)k F@r$ j'KfnPHIe}#{517Ē8֞p;ttՕ黗 ZN]q#>6z&z#&\RزC -{V%J3}ކTbY!uJ"vk-R^N]ZUg%j, ~ f?4v3D%D8Ŭ?eΌX?6uK%\7xL45lH|ο iEuh3r" 7ظ6AA+W~wՍFْX9q劆$X/M׵-Wg;] i)uv*c?iɺ6JD 'mFfYF/ꪫɐL>7^!d1Cåm;CiBİ2LVʙӍEmR[J,2BS WƳ5w(%|HhF~J3I ;fR\\+]%.ڡ|N@v[Bءd*Kj^V2[(v8RzaCjtJ/|uIWZ!{>[i,Ǔ 5墲Vm()XRlv/Tmv<~q"[WxJFD~x_@Rk őCюwt%t!0BB]O =ᢄ郢r{E?~@`._6@h1kjݫ3sʞk ;OU'>^H09uþup%SnEaZ1~EҎ_}MO7l-zeP.2)"7Ϩns36n_= 3ͨ  676x ` :A7̨х$lUdFjQ _-Zwԝ][E17ܿ~[ǪYЖXE7Yڰ;oZknELYI&(2i3-V_Gr=F: u.B#aBm.)\ eVϯs]R 4jWHeR]iCť"-++T&٫}zJ01\їRRR-mn -i7sd1'2Qp rI##AwƦK7#0oo=қhU"JdV&}AcYcƲ'We* 2JU2y#Kxe˗`b5UVMRˮ]Wol_VMZmqRդA+Y }(ZN=/},3T'%5[ZȻi89V})XB?WQ^;;W]r1q4OK9;v-U#QGN*QJē1decrbX ]|Za)/IŲmmRTj"d~F ~7.5Tb[[ e)t0_m.?k_(<4o [^f3K9G$6 [/3Xrf]'l$A0A2#2G'55=x?^΀g* \$R\AVo]ʑKQ9b +VdWff ek;[$iρ'x.f,z)jKz)*g[]HT?rD%%5ݝnBMy%&s5(tnPE*[0ŮiۃЗ;(_Q gruv\Iq$*"qSeM'Z'ySL3Hw?*Rb1lt]O0;9uԙ6نRTbt4V_UXˡw**|"`~b0XfCwH8 ^:3ψ#^Fr:$vp`sdE>ZaT jb|vQT8owL2lbs{P~6ϼf2t+`ư`;Zhvib9r:Ug#D67UX˪|!=矈Łܔ3"02rCB:.$?u M=iWjWFƘq}? c)T8޶e.Z6o܀ܶb m^gsdׁDtŞ%%%!_4v.$Q{deɄݖH5zVZiz6\kJl< MTQz%rOGގ-9譽eVZ8LSu=X3c#2FDEk#"u>q󷷄;un)QarWuVͱ`C e}CޥVo\w۩[b 6=tb OgcYc=ӭz_&Ybn?*uS/NEA?gJ1G~8pJ4]a1rjr f:#c ST#=;Ї)DH:u4;.Qj䗒I+hR02 ZkYeOʵJ3H޻p+1XXfHb}݃>g;˦+3S9_`ˀP?MpK%2<{ڕ^]p߰3[j NgtJe[lvJAwIQH,xEl2pټf(UN,Nj7RʿþDEћnF4%N,T%jARI!z)暓AUa̿Q×fGplIh›Of=_rcHmHnvdA-Fq0NpPj|(F5gf raT[rd5c?/c*Wr\D^gzUMEG5h>uX\;#թDyBSryfp%>&/|bb| o,zyq̗<;RX|3C8)FѿQ/M Y0$n>;0*<[$W׵2[%6,'cƿ(˻+u ZEJ,N.QcWD_e߈u@"-lj}!Bz,a7B^ '$,C2[3O[kڗ+ߧ[U}~VL[>5{V$Uɲ$_mv~ #?DvqYj/DʼԜj-:T+TI`|l"Yi |~F8jAY&zkң exk.bU\$+k iI~[ K,(tN6d=_w/.|%_I|GFrugd#E˫|-[ TD*U [HstWɐ 'dMPzi z̵C?%dY%5tzC7hwoEgPh3HEta&9WPI$*+iڽٳgwi2:2Gs4Gs4Gs4Gs4Gs4Gs4Gs4Gs4Gs4Gs4G= $5`0K}[g'>$N"p%AZ~~p(!pp x '3=4Av%y i9I0R =6`?@j1`tB/AVp'P` z0HwB8ȑ܉]/S[^#R4x;4-4Ϸ#4} 0 :vP젞^>;t5^;ZL7 ON//` jY %~GAቧ Bn5 P%(6z@'HOnT -C}`uH7ډ6 8Lq d3^?si" ^36 yv yv,spZgz =h0pXA;A6C`a n.@;0ȶ "0ICia4 6o\˯'Ve#8 >C[i zh1Y41<`!S W] HyxQ<- c I#* ]zsFq\>ĪFq4 htA+lӀ{]AiţS< 1? @jQ_  D (ߛzozOS` P<'AzmFI0`x$ޓ8 ].~-`7 <6q<~&AkR>D(qc&A*re4 5p$ 2ߎoa8@G '>I$9rA9 @ ˀ`8?"43@/{kAηdp=~߾8 ϺH-W]k0ZwSoI8@L戮SI$ o8_']<6;A3x/幗Ky~ $ ǿhW\!h_WRFr|] _ puWQ1OHlu ^?>*9e@4j= R x ) l7?Hd̀l'-Өpq. ?wĮ$Y  8 \zආD34B8CQu1~p^JԺQul]!n`ޗRr,*Vt"Wke"VZqXԻb/-ۚABׂjqm*QWi=[[V:Zr6ItQUszS.]?9v\R3byD%xcʟ~L- {pjy՚\4Z,V>AΦ$َ,Y߭/趉Qj4h0RUPD >ԲPeUei8pYe(X* UV \R^^6w^*0$xeesBe@a`~eqI"PUXQ 4PZ8|q`QYx^zN$(.[hd>5+EP@iIa:TRQT5Vπ&`1#C% Cʹqu\XEPPQVR5rJuªap8xѨQ-9?Qo$G+ * VVEsi!*rJ@!kQ_,Vú)R VZEʊ^VQT^]LU+. Ӂd-*@J*#++Xҡe%JMU$ pDTJ**+4'ٻTD[ +#$UrQEyeaj)*tX>Tah_XVT"+)3Y KJ 1UHJ~\Q]jMt.gz5ئltY^lLY޾d%˧v{卝'[S(]/3*/F/S"]=Vװ;]-r"O/.xQLowbTE1埨vX%b6CiEZVnk˵ϵ|1mvV?qi>m֦-Վj mmmm6AdOog؂LR}NF ܶJKl鿰[mlom_Zl~X?EZGE=9ү_h Go8GG6G8`8 Gh"]GpT G8 18ZGpN8tz8 G5=92JGc8G7ѭpp"G18Y2[; X8~GUpt;GѳpmptG+yr6B[h˅z8*J8 h- G8G-p9C]__C_mpt3͇8^ɑh(pt;B8;gp^7C8j?\⇚.:8G ^85G]8 Gpԡ 9|OdGpT Ga8p+8z^ pvQ+u34}&63Kߨpt1Mp4J( G? 8ZGp Z_=9ʘipt.pT G gp[835N8jWh1YGHSG5H}S,^lZ&mv8'U8jc8J[kJ=C{X?M{U?Gk+L B<]p~ɛpp>탣z]׿_/ӏدᢃ=9>奔c=?e8z=ptHir/8͂Ept7= G p!}&li"l$.|8Vspmf8:ݤ;2ݯZ-lOp,ѧpԡϰ>,{~#.C{}tjI?`ڗ_Wpv8LNtg֖: MMLN#V[AC8M 9(E{$XhtkCCJPKr?kN]8/:mjnnkknnrڅ3-^N}7u{ZXlQ#6*)9zrb,1uP/1b95"ri6EI#KUjHf~F0693f9J.iP"RQèinF#m]6OaQM^P ZE-R{Po F5? ]5Ė`vn:mlUSqiӜvUqYitӐ#CltA/H 4Js:{ &i:ܢ4:u]sYZD5fk%Vj? $Z̜O-#[F,ncF~Ny ()//G՝bC2$ |mYjCZ bΦ|ӆ{\o[T?IKu8]s iNW HP|MʆRr G,AAMN+ކʂ2lDp4AY6ZJ#vؐ.1ňT뭑54uF5=GoF.Q2i/0$پH+5ێkH$,IW$MsY$Ǧ!Ux[cKv-51anq$OE|$h2&:$wU,iM29b+2*g'̑O5Tkr5|!R,6Թ ͥG ;G4'W\Vt"<ɒr,ʜ:{Jyс$QV(TJJ]W69'uY_Z--Orq~^ ]C8`c5nCs;H~᭠JbSNV/HQӬ%HۦI{m6HYdxOuo*iK$aqTφLVYUjj`q?&nNcP}Z*lv?tPPfɐV 10#ۢ Hj@5յ.Ije C%zNL+';[dgGS$Lݣe8a{4jӵ>Mk(k㸝5 ĤdY]nHJ&kjrs˛^Bۻy-j1IY ~kj2ٵpؕnz\ND Ub:S-Gg:e%W,#y<]I؀iKWF1Hgueu-uV{p9 hD4|n¾VwhٴQI<-9-9m6eV7nGv5WuOJ{j$E4]EE$ mlhWH =)<)߃n?za[Vzodt ˥)m*W/''[-r9IlbNOʡX_4+ t{7tItSgD&} Jg}t5tE7vI7tv5uF(gJ[*;_fM]j2:ݞiTU]&ZLc4$܋jhytO6wp'  IWxm6or7)5r2Nezx4e /7^e(-Lx9Cq% ~&܈;d,|2^XZ`aiur5*_sk Jwu o_zDˏ7^z3D8Myu-.2h1ESx4t@5NKOUYK((ᎎy¼{:#) l6:ݦt7MxNIz%5nVSt ;y*qIM~ -Cn2--}ܭ5h\!w^Moᳳ`gASACAcA} - ?q. N6j~WӣMda[]I I"0v#+7X;Y?PH%XIJ`T o& X+u 4 (7A^d~u05日]2uZ "GqpfP+5ݩ-7_кv϶yqM[򗍳kכ2zRQ+rEWI)jD>kWfMoZj5&6-YfcR{LL%# oτ ⴉ>2MKREۼ'"~$fKv~rRF02rI9]՟Lx@ tNu# v0l.aMKҝXO2u#-}0M‘xD ohˡwK -T%ыi2N/2;X^YiM\>pjF򉮄OT#Of hq\Jn+r_hy C _< ڧpLѯϿJ9}ԀȾ~;7D?b.z'[ #J)8(Xk9u]W?[KB-uݪ#umQOյUqH^5C]HuT]g-oV>u}H]Sקu]_vW'Lp`0/{lC}`C8RLWJxR$6^qH 3>V! 84kyu{u:=ZZgxguoϴO=g?聞-%=<%ůL_aF|A;*ۖ/>kGGv{ }nMw_.ˣioy{y]mqzq-/K_a۔ap&ݞ/1O_BٌlOߝ"e `ƀ BGb%+3Xke\NJ=;{ߗ6K= EFVcc[ƤuGHI}}3.*%O(6!~R.ˤJ{O_e%ۓbo:'8뱬gzֺzkY{u^U}I|oI0xbRfe6R:UL5Om~̀k>\δ]?%̛Vo( Pɿ#?B~(Y\{C{MrS9;#͹?|f즕7=|ڹwm7c^$qܼʲ+Xl_ -(Xp˂;_q .!_KCUTjVV5T/ _~)Rݿz{ .,|x+/~Ky{#DFZX[zuK[j֞_{Kݵee=Ӻuo|Zgw>Qn˗|M:zZ'? "=w_-g޴ZCUxyO{GzLߜK޻mLY7}}^b ?p{7=MӸnPzdy )}:o&vIO_8tvYL݉Z%Vu'Q=;X(,j,A}2GQ72O ='hߝ*wGԘ*Ǥg"&c(1{긘)\ɝsN9cc-7e[KcτIrm%/|*ȕJYMV,}bWֺ9Ă"QȨfE4E9)I9{Ғ!2%%CT4?iQ;cQ9?_IJwr|yt''rHn$ҷ˝&]ndj|$XyR5 ;%뭊E_XvDnJ՞HQ#Fr"ex1mN!,*5<'ߨ ],O CVrk:JȽg)Qo2>Kr͑(H7!wdjfS{3DQRƺgsP||&Cn 9%_{6ٖnO;<~=SVJZ*OIӤQb:H>W4uṂNnvl `Pܠ^$jbv<VChal&eR6n^:ȥA"m~ZK ܠ/5gc}b'sYh3><uODd D/ O>%TcRT`T7m,"K ~p/)X렃.`,M Z0\eb ɓ9B!fP.*ev1Xh|Ӿ<YvA3>;.lNk1L|oic1 Bf1TJPm21ƀc c߈9\pr9`Šȱ <Cs?68p,ŠT~.!r\>OAuF|\ut*Z݌ F&mwmжѶ|*JGD|sl"y>`%vwpP6_(ijh+~2lf=>>1!h;G`'>3?_Vp_68cwc`u\&sz7Yfo:n6[`C "Ip~;X]up}% <y$ky~x`5rF]5rF5r|n~Kn!5eY;G;!9@1(al>cܑ^iHJ4-oַABm͌143fC3chf ͌1JFӎiGѴhQ4(v-jEcјv4i-ע߄%9'z ZCkbhM 51&КZCkbhM d;+*X+ΪXJR1V%j`(~֏j+h;h;,`cŘ-9XA}ػZWMщ6q~(~!}RoDM98#N>⤏8#N>⤏8#Ni??6ݍfwaG#l6{xfw`;,덷!bVvڪ"P.qt⨏#v>b#v>b#v>b[܁-w`#nln76#o>⛏Vv|ĶߍFw].IDw#b#>Vjy@j=sĶ٥݇5܍Ww:?ZgR8&CJT3>b|[[;[7Q|K)-j%59Ւj飦>jhy5GSU3̤f&53ILjfR35FVfJr)|+ng3˯uzbbbbr0,EϦr>۵>m8 `$y`4 X.@.`\ .+Dp% \ &` ^WxO'Zx<ρo:X^/+U06lo71-6 M'`v; ͝mo\Ƃ}prx.g 0\ WI`2k4o~] 7?KK-Xcp' Xw:`x<~䙐` x< ~ ւ߀, jσ߂߁u^/W@_l`x4`3x4"""w+9x\@_gxv<gxv<gxv<}yX^/+U#x  `&Edڷm"3pDFک/ Kd+ C<6n54֐\ߐǘ l0f/m`~n`x)58 Ɖ;h4Rf3yn[V +2/q˹~|c3`jP?6z4MxލqfDu Cp({*xYguYguG8g>'#T^987dsD7"}.ĺ+:ʺ+1yov>5S떺]XGX |BUwm^?2|sqS-[,Xlbb-[,Xlbb-[,Xlbb-[,Xlq/8K2=UCG#žJܫ_  -hU**{ػ%.wQ߆z tXWuuYWuuYWuuYWuuEgq֖@MȠ *[篬dJ罵z'fN9q;´*ˮ [ݰ [ݰ [0gZ9ʙVδr3iL+gZ9ʙVδr3iL+gZ9ʙVδr3iL+gZ9ʙVδr30)0La S`Üi>C*bZ)0,n}#ЧNՓ&I-īMīMԘEYԘEYԘEYhF 5ZBjP-hF 5ZBjP-hF 5ZBjP-hF 5ZBjPc5fQc5fQc5fQc5fQ% e/kD<_r~-:FYtӦfA?Z)g-nw[Gut[Gut[Gut[Gutٔn4:1Y:S.,V}g\^i^4|q u7`zcؠ76 zcؠ76 zcؠ/6 bؠ/6 btԣAϛRX~5O5TЯvnW[{l[{l[{l[{l[{l[{l[{l[{l^Y3Vj)vϪD5:ED^'1΍qn{ﯼIR/TJhGWz?94.vQ]le(E.vQ]le(E.vQ]le(E.vQ]le(E.tf#o6&fGg.TC$p ErHmFmFmUD&6QMTmjUD&6QMTmjUD&6QMTmjUD&6QMTmjU:Y㏋b(c+Qx%.q(+/.tK<]jx* B|XRݳ x4?YS|?_l|ᛸ1R| r|.bZq%B룩2g;O, oʥ y72b.Ȥ^hH8Q٥m(0EhM S~L1cԏS?~L1cԏS?~L1cԏS?~f "Ǹᛸ1R| r|mS7nLݘ1ucԍ:q^H\#F3=LajoӸƝ2=)ZghI\Rs6enQjPJ,1;TCPK ]ѵ}tk]G>ѵ}tk]G>ѵ}r$Jr$Jr$Jr$Jt=Gst=Gst=OySlύ^L8[ɞ?;yf K?4^hv~5^ksyv,ƻ=wu_4aI #⧞/Sc^fl8_C޷+ 6aolrM  ]M׻o]M7|ai ãv,Tu;ޤPuVfTB-,R@% ,P@ŽT,SL2KN-BB,N(NPD+SD2+SL2J*P@ *P@ *PjˤR)5@2ʔ*SXf'V(N3J.-\!ϮK =;52|y6Lt&,O6V3}F8)yd4'pGR2r#hp7R*yNrvX :FgSv"lÎ^p1Gs:S g>٧T>ƭNOV`κvYG荚dO۝oOMSGN~*S{eTɧ2iL&ɢYˢsEyYyYyˈX6IJ$J$d˜L c2 ϱqi|gj>g5Ss>5oG3;5*o"J,"uj^s^>߱tw{aAnH€npX7M jP<>s>,R{niZʑ{ ?aYaN?RoT[(Ӿ@ 3>$b/;#+fĚy=Z֙ygRd }+An|M~W߿¯nJ oE.^4#(8.Ew7b,\'Y;zgWzSM3~^O6)HҷʶiׄȹɆj_ꇒn,zl=_o><,<|Ǒ$r~ΑkzAf0N 7U6rm%Vrml>&y| ?KOО?Ƨ"Uq~O?+\2.O맕}u1;l|G8;lnoGT,'Kɒy{7x;a/R28=~CG(SMƕS0SU4eJҾ)ӭx^\G8x/j\︯zn~鹍H۱^fxMk¯=-ܙg=_ӸsrQ6f sȇFy( %FYܣw}pwsrNW$]S244ՠuO=!CoSs?5&|`;{ax{HG9=Fs Ux&^7݊p{XtwxXԩfT3uJjfryqrGǰ՝źt.;Au_VC<%i*UNUE5 QUTօ*QsٮJnU%T8=/WMԯVX k}'fAzTzԪ*tϗtϗL''gxڝWթ=iS+OU&UgN+ߦ_X=gLN''rU^^+ k}ǽ0t`&z=BWG' + [躣tt{~xsAIy<RNg̓d@f̔^O'r1#vʵrmȭ)vV1v2: nxR~dh)ΔX'ʅ(]2Ʌ/=yBnf9S{:ue)-7}Px]7~]7~]"Gl~[gY;t9I7}M]s#QDK::pN\lI[hu~]_[ub:z555ݪ_wםu~ݩCwН:tt~]_WЕ:t~hn:wuK]uAdP-*Ggz8S9YWz8SU~U:NůST:NwޯU{jPRUy*Q=upθ>-LDXE%*jU^ P-YxJEĪ E;/U@e.cYD/Kx.cY^)/Kd^z*ټVhUUQVWQ& e^ټF+h>do,{ܽb^!Ɨ2v~ј ttJlPd"ˈU} +WEU^WduZUɊJV4hEV4h5%)Y͠ ZͫVQHg^;^L%>9^li5lq1gL1Z9-Ɯy̙ߙi1c>=>EIԛ:w!_,ʳ<ޱW9(qTyEHRH Ȋ&%HE2.qUYUYWW{{=+?&dsr+9+9[V۪<~:IM寑ΰ:^=-B嵂^Kܥw;wꝕ޸K_ܥtmռyzdUrtc q5ޱm]!h2Bz8ǚce#5ְVsz_i59XxCL їodrmʵau [װu [ǰ5 ;s8w[wnuηչr1׈3rƙ՞__:wOf q7Ywǝ/VQWǺt{+Vwsy3o;u)֝ΗrՒTZK5TY]Q9^WvEj=GijQq5\LYV&s|,Ngey)Y1Řc);Čbn2Pz ,S\NQ} ׈}=zq=TzDP?YuEn+.ZqvUHn*wSTr7HnvSV_{]L 3IfQ^ic۵ö(TdS)㔢Z3o+Ng댎vmƭָ;+ߨA:jT (5`[;MA Pd51@J Pb TęcN'9&)8W/S9W#wGŒKJ,)QqđGN 91ĐC7m|h,@'pG=|q vǢ Fg_XMM3~O9.L9'C0NGp>q Ni8gc8$§'8  sZ}b>VXO =Sx#(5"CڇNSscN|-V j~ZUV55|=㹘+qq[-jiTKZ?v'n;@Z:ҡjmZ[VjGԊVLjn[]KuvGv#PZa:P5ӟNa_.Ǘra9X?,ڢByP/ oIK98"G_}/FE\]E\]EUhthin?φυ/+!aebN!q . 7س]Z}eoJf95'_f${kEG$wɝ&:.7܎DSFGLV\І=|q Bb~?;Z}l_$5˫X,6,_/ Qܪh֜d,rc\X,??K5WC.=a^TiKURopU~{^oUkcrNR9T΋*]ѻk(yuU~֋~~ZzuSnMW7c.܍{Kq/>q?Ox?ƣhm^tH1Z\q`!~q~q nmw.܍{Kq/E7=:dz4D-nR;b'G$͚ufݬY7k hDv`A8ww@N k' dvY;@N k'%suɹŮfc.. |7pnznznznznZinZinZ֛s7cf݌1w3n͘s7cftޣuޣ߲[6o-el߲[6o-wwwFPr ]((c4TgAgAgAgAgAW_/ ti{=}ڞ>mOOӧi{=}ڞ>mOOӧi{=}ڞ>mOOӧi{=}ڞ>mOOӧi{=}ڞ>mOOӧS:+K? )(eLI2R&Q$JD)(eLI2R&Q$JD)(eLI2R&Q$JD)(Zbk%ֺXZbk%ָXZbk5%LeT?e#R՛bͦ~XsI֜pMc`]`]Pf_ }TK|.glsLMʯ$$x{1jJv3\)WoeM0lҭ#sGi\)l5rͦ\)l5rͦ\)l5rvY;鬝tN:k'IgvY;鬝tN:k'zo(O]#,xpyy5ָZc֛h);0)Wwt,  I$&>јx%!cT< *hT@EAFM5fV`=cXh`ca[7r3( #+xx( ~x.~B-BP IEyi ZāKāKāKÁ;Á;Á;Á;`ptz_ƶvzp nMf'0gw$0Y/pǺG^\:•y^RG?k=ɕ˽],6e嶦JQT%w4͒;ul"\7y=_{)M^Q/l fy.RL? Cp- p0\жCzh[mm=жCzh[mm=жCzOJos`x E0^%x ,K2Pw{ &#_?[0p8>HַJ>?6s>>s>=  sld`)Xp| blA=آ+U!H" T h:tʑzF A0]?Yocue-_^ @p?S Q/H ]ld\%p1.W2x!=dƁ;x@}ÉNpLps !0c Nҙ)TNuzz00׃Hp#n7?`  n`.p7&)==[ CP 毕K˖1-Ÿׁa`8A#vUcs19?cs19?cs19?cs19?cs19?}`+:góYux:|ЇY|gߙugjfGV zEMf: W+p?eOSb8+y/q%''3bQ=Q7{msŸy{M@HDw5S'l3ꖤf Ԩ+#\eRL-iZR's--uiW*c'׈ܕ@*ÄբmN_k:V?k%VHH= q_ȫ#W3WV~8`Ί1\~dK6v %ZDZ0ʼx(MDXkARp Cȷ0̛8䜕WqF9j[^Ùn˝B)em_Lb%}ȩ Ts>4/~1_LbSGJJwL̞nrPӟV^z4J5}Hh! !:ilJ5z9^BoBGYMm9ZEH۴0iw4iBٴ!T$櫔҈+Y4 oz;)Rq15PE䲍l'ED}>J r'Fri2ueRדM:$DRr m6?*1ݤW6RܪɭK2ZI/W6t5ѴAlbQkۇhacG΢+ך\ۉk:#`u؁lwq;6kC8ڙA b ^[ⴷGcW)v7;6ngK1ԋ+: !mA;QJĬ#RG9Hx7DXwBr ^ 2I]K&Ʊ\(!3mGՁHx8; 7esߚm9Wzײ#@X)q:֙8]Lօ8݉s0LgSڶk;QNԣzRm]FPL Uȧڼ[yRlU F[l}_0;Ծ Ruep>Bn ~BH}\ژ3f WbgPVlC"jMj䎦ϏdSS#V%=`#V;K6=u L?RMcmZ=-ER^Wi^Ԫ*WJNL.@u%^7D;^ĩX'H_[U_-EU4Q{%?U8Nqs2wl jj;ޡ_e4uޓ\'!8JT8Y!g[tۏm$1N<*.y ^KDQxP:i7A,uJbss*9gN99OltwM 2L۝{:Svrřtut==9Shq1 O_';?sOuOus{g8ǻg_}ݾyy)@TBB4"2tJws{;uow.qp'9WS{kܙߝ?ݗ1ݥ}n[㔻܏ggq|WK"])W)5-EX;KdY*we7yCeZ~W~Y.=CV%vcO:33ggn 9Kw[ʌ\ Ajp/G{!11nnv/={}[pVyڝ(%"wq(ҭLT&v&K|f5:2ҭIJv'>NlpW&6&6uwmb[b!јhtN?n_6E~~Kv~ .ey%oG7c[@y?(-/'S%4?ß!W?e_71WK_%ߑd_#c_ ʿ*:Twu|EKD:IJ~z^r:S)WoJG'Wj\.R uP5BjuyOVWw)^UzmT5kPz 5klx=";Bmݽy~!QpwQIޥ))Ӽ?ggyW ~ zWC`wCpCp72n n nFwwxcD`Rpwk/ބ<(  6ޛl zSwOKz}IT$d:Y=llMK$KɎdi{$<#9'?y/ /^^=^^= xφCá޿aެpt7'ՄKp9VQе`|`bmVԣ`񏛟g6S e>J%GLW 6|O2= 'iz^BMk5,Wn\JGAʽ^mf}|b"|If&¸{M?1}h?z9Cz{;їF٭>{ ;}IPaOGWЫr_)}-7v^~~._1 ҲW宫ܿUg2>-s=͎j]~Az]՛{* qh8<7v/٬NJ.04jC*U{MlJ8OF yҧ켷 J?2,,s^ySҴ_¯Gy|ܵKlfv2)6%J{-{/(ou/}>+sLҮvWp~Yqwi|mɸtGv;U_2Zo/FnJq?77,F 1mtŭ یpb4$[#dy==#Gjq_eX??-^ϋw|kObOb:]$3Id$V$j ?FNG;7.ʉrRE9E9EE9-rf\sJ ;DA/hrZmAsaPtv.9? ~\s4Cչx Ekq\W0asWTs==Dw,5yh|=·F;+wwl0bwgNSa ۺ~n~~3 %?Y܋O$aJ<"(WWDR̡oo&亄KmBՌz^gQ+bFF]&E(*h_ˈ~9H;#;[;>}}ZuklOmo{j[S[۞Zb{j+WZZLuY鵊m.h'bۃӃs>pVzVyD,x;D~ζwmH(VǩD:^/ZO l69%QC@-Vls1! H)heX&Rh u U@(Vڈh ֞eTG┦:TTgr:6|G8|G4RMOM'pϢa@aPE 8ŀSؾ0cl?.r 8=)^$ܷ\*]WY-ܗr_[},X+pNZDNAL\\ɲ)cys %\ˌ8a2c`1eٰ[aeNw(ܗD X/`;(}dA}:Z+d?ϓneR;9@ŀB}vw]QX!-)dˤ岄岶4u!ˤ:CLu1 ,,VglN5 X^.diMYFKL2FKX.SZue7`qٍjۆєe4i-nSv5nʲ[A&BZSJ,Iu?&6MMc{.|zefL'-)mnJ=^`{ZҰaZ֖גX^kkykjD*n-Vg,V8#dkkE^^rx8\O Grsx, VZ$|j$mܱ6Qk41 kdJBB/Z-6L26Ֆ8#ZH@x'8%х GQd9q?y>zT3R3?vhann|̽QWx;74_xroy;vOŒ{w"j~s~0|q~}7}TbWq{_>^}gul#ZgMkeb}zwmm>wkҼԴ W_.ze&ߓ74;Zzg=_|]F¼ty_O٬ߣ\+Om~ܿs(ASs? ~.z~rVn%,SE/= 5:c>>͟nڿ__z. =VҳLVKqz.}|N-kojb[73^fk/(M}K]ۻf0z̬_xN{)0ml\o'z-GeY) __2e`pcN񵶬zo~r^O'BgiY>c+B.=)m~sgۯy1T,VEESk垧-=ѯc0rh=Ϝ-͵pr D27:Gٽ9F};Зv+ퟴz~r=p7[}Ce{1j<zFn mOd!v;<ճ1c?~b{ͮ'۹8ykΟ4Z3agɺ^J̶ץIjuT1QϽ?އ<7qzݮƍ>oZxmJ9V?5.+\/o4 87]ؿR1ڛux} o{o{X64ngf*uΦt~VOG1diwj{y هu-  F~*sijjk Fk{L_P]fO}>03,DZ;>t}{:ߜ "E@tHQ)FuY眳 ! TRK:gYksY묟uYuΟ9u֙~DJۭ]s7''{?2^spv{?~_59_:^;'͖/Я?+/%_ĵc=D{sۿ;_5/ m!^_4q%w_noq;=^?ȵ2FWlįV{,9SW;w!/+?cnFo/:џ?S}8GFgg _9/#ڧV -b/( m^ s=[ɣk#F}b=ϟd~>}_nJ>S[=t1 )l|Cg? ?xw5,rw3 _-M/t,tҰ{}u/>5hQHz&$;ZZ~]'j>"$|8[N_w?Cwl, jC^ Y#5?vOд ɣ熟 z"TCgD >| ! Ů☿Zb+\Ǯahy{C;#|͡iݣg/Uܑ*{O_߹qW`"geo~ Yi{oT^>{oPY y<6Hmb$=8!o[zC,#TLM" =05Я7ὥ,Kzg{>=E}ȯk4w9=$ݼCCg~2Gzvyn8?|qKa =WQ٨p5\FgflW8I89.N}#.!.Q 6QBqDiz^( W␉zxڛ1E4CMc?-†1 GFŘưSKdn2e7,lB{}cUw6ǎ>KdXy eWSűdz:,E8,UF|jț})o oYJl}U":rh.rqRUAY5YQZzV#P͡ Cv2s;gG Ͼ&U`ȼPyw!( (&P-;o>~ȿϱB҄煟ta2@)# y)/Iy9 y|kS@YZL=2ԃPu:eSթlY`z(BfxVE"`kǪK%h<DG?g7HMg&tӽ(Jja*dLXT;+ɨ;QYAQϰ;F"KFzmlX!X x6F[ӛ𙀍Lp5}MsTs4okfQc2 fyLyW.44X>sX>s99K}LuQg[sIsgo$UUv55ÿC͇H?MQ`EŊDa*CZ4.J,VcNcZE%:Q8\zam;mb?/q(fNN3~Cš1[F|8ELG98抹m8 m#e#cGϋ783M&lJş?EϛşaVq+}I| mv|E܁wan~% -!67x#yK| :"<*elxL<x+syG7*^@&`}9`:ql6Aۇh}Y6YFkkYVeanppDFhG{\0J; -yh3Z;kibm1ZюA|v,Ÿ!UqFrkZ`-@ X %sR8kTZBZX_Z>X ւZXg-l4Xkv$T6`0 q0T$$|Gl#AGG(i[Ӱ\pvDpvIS, m`8At=U+ڀ바h~4Zb}9Aƃ1:>:aщщ,7;=\ONNeONC?`ElX,.ffL&|;ĝ3%p΄HK:&(f#|0'`Nh6U1!VMe%?𓰜?1' {X,7uN,"[&۰.;Xp 3e7#7~WVXh,7e@~{ #*/C`oK|\^6s܁~~(گWjy5>-?k5,s>6o˖$;yy}A~% 7˛g}IƆ/yE~0E "Uy7˔)Al:Za/79$F|| m˿ |li4Y&gtͺ{HdtKt8VV]+{D"XqlgaD(Le DÉN$&* 30׌,u:q{{poL$Nyq$=T4z ꁆT4z! ĐꁆT4z!T4z ꁆT&AēdR=BTR=  ƩSݦ-ǽlUV}qbQUFvR-bE*7]AV êўsٻedcbW-U/q_`--%:\E5k/bQ`\!]bM2đ.C2&ۻ%R6qӈ^^`Cm`wD\v+ga: }WxuI'K8#?Dr-!IBd .BbI'"]R ZDZU" y1QĘGcNC;sԃGoVgF%=C P]ȆAL:W=LzzzLzqoA[ġg{$roIĕS+DmW\y+z-Gy|% )YȤdOJSCKT-ʈIoccWWNҜќ>yΏ ~|o~D8YsEsDb x"1`A}}N$vkN$%D,v"N$+hY %8׉ۃ~8h"q;&M&,`|⚅/vq/S_l1|q-e1bz܄,[)܆m_L!fY@̲X=&=g), Y//K_,&~9◩;;X˙-NyAg, Y/o"E))lr,@ 68x,%YB bAh r1qqȤ!Vd[ЎBz+[hghg`\uEC+2J1sc"RSM1&9 X+đN)$N)đNU QTc|3_l;vJؘXC"6=ƫ5*a,jaTK \ 뇁T9 C`o] ^3)7ʍxd/<Q0ꄡ"0T- E{^' ۱I CP':a B*33ggBM49T6"yIB.UyT!F3D/Vy+Z,8rF;XH FSm0M/䃈 !O~K~ -ym0Z|ߡ6Cmz; ?U#S) Nȑ kQ6e pt| >WA$tRA&tRA@:jrEl9$.R2# MO'$\))IY-K8WMAk' &d]*rlRP$rLQJ' ]"4TD8t-6Q+ ʣg':Ht+u+s=LcGzL٤42jmLr^eL?a& {_eS$--V66vÎ1o&cd[ <*cLŅ]KX*`ؤ)Ymr.6qU8_!Som;VX[_#.b.VH}ԞU1bX+n{ڱj:X' 5#wvxۃ0;YLJݽ>+`S?Zϯrlv<Dzf^ qWŌ –EO#VV?5=az˼I VP[t `o\ÕEe^BvqXTlD$y֊Tӭsí<|o+'6m̵ގBXbu'Yy;x'V)V8ݺؗP^kvyU̲vZW+@ n.2|uo@vV,v~oWE,wޭm}AjsЗ]9˼;ʃ#e=.3؊Ou;g׺x}oL S1ރۑHl}<GM(_i^=^qǜ[>&1oV=}ߴiכ7{VFgfu19|`R}0Q_FT`yofF6˕93|s>}sʷx4ެ,GhKk7)QenZR*1].^!Ȁ;EF1x1Y[iв_~|ZI=ޘ <՘MJ_۲Bc+GV{q O'o6NSD54QV-[ϙ(וz`RhRxe{ Srd4ڀY [v_J&R`~r`Qc;qq-pj%oղwMO~R`vH/ZdclIPk44Rxp8K2UlXP۸W h__ ֯Q|+Ugϴe9]' .߬k}&bSV8rrENehYm\Yp'57֟n?m[lzIYYm;/_/,U6V"ݻfUWd=[uüw +7 }&}_f|wy{ɐhwx Et9Ǯw0ؾXٯ_ko8p{?& SC}5оNYg?(݋4w+0Ag`)ݡ6W+y & xqwI1.d &CSjdK)8t),nbk]l'o?O5| °~nP엽k VM`C#?vV;yu$ӑgrdK [YI00v98M3t8 Sy l; V"M˯TG915i+f9;YJuc7:Vx;+1SwTswT9WWg86Ug9692߱ͻȱY]̱먞88m88]Wmp:.zU[W.ujN :e2gb3ٻzskJg&GgvWw梟1ۜwrY9zs^WrKW"<[}9'/^#Nӈ~i.1WOĿ_i|90#s.l!?(:;3> V\jLp. s2©3*:{9kmM8Ϙ\fcs1׹8"Ma\Kh%to}Fqsqyg2L.5^y{htҼp<揫2:65ƅAV469bƥ.yqKRv]qی\;Omc\JooN۸5q+h8JOw&56uMi>g<|x8 ,Yvx6sŌٶ$mg\鐵WMvon<2ˡl3^u-j>2] b%\JFp9m\oͶ5qu|ru*k]]];n5]bp>yu$] u2ܧY/.t_晚ׂfĴdZA*ORpi'M)5mdg6ysM[<97{򃕦]"^Oip~:0)eÞA;gFa:gUϼ?1{At .6]NugYpu]gEp]]Y+\PMQY WyutFT|ZlvD϶ֺu={ eguC:˃sei%nE%nʭM\JP13IV6 2M}u6~MaҲnQS6zSr⦂֦1ziBT]GYsV7Mü:xZݺz9xcsG_&%Q|/Kh_KMr]gjẮ&%Iu[L?0%q,˲x c1c+`EDѲ`X&;3e FD SaNESTzDEqNE(Tz*SEG)z ±RwW;- Q*{wbz™vJko+awT ۵-܌!+{&!cnG¥=ڼr/L8m?14\!4wqGí!9qG0~0-,X'OC> >|G6;1\{J1JV1ZG~#5< <>Vk e61xv69xn658Ma30w[ /of ^&y- [5 qNQ\«uJR8TRYC~RsY(\niNE ep9+E VVJـRqa:}n!UY<)7ʆpSYvRٽJ}P!ܫ8*{P;0GoBcJ{Qw4=SJ_x?{Vd)‡ e |Z0{Q9a/+C2{U9>^WN~pQ s6B0<888\Ok:Lgػʕ,GkTn|0ƙ[y.I6s)ʽ2tq!s,D.?:#q%Hl,Tև#܆*r:>1R5l*88O!"[ d#͜#<Edn{HzBDr{BN=4B#C^n(t8r;:9ȝ GpC#cP(g449GNqBTҶCܕtk!4qFvd`EUެF5#r_fGt5/rR ;x>W]E"_ k._Vu+T oT7w%6uKWJcܕب{:Ulܣr[!"wv5J&uoGvzgՃ]yQ=ҵǺSJvk~C=Gs]nӅJڻM㨏-___;Njk@xKj{v:9Ctma_էyb~2m^}UXCk6׻pyS-_]7!`" #dQÓT!4yܐmxkɲl"YX-YˇN˘err\؉_*8%:DI3i $I$s䟙D$Q;1Iaҙ/dmWl`O0=g !S)4=oz3`*d~mzT`4U6LjSbِar,nxɴôϴewM {iӸib0M˦ˆ6Ӵiڰs 7~)6ӯLsiН@5| O%f10>DRݧԸT򙸴4;6ˋ#{Mqeqe$ bz6n]WH6㑃{6>ObRhH -扅T\'VUC YEb7)ăxB<%ωExMq͉w%"W&%+tYT+K1G'9 ;2E R@%sBr >O/y,IW/>r&y<'nKzǜdNOH33q2=a`+G<|s>pl~\LZp\\J|rs9247NB6r_Bw#@"%25!Mr|H(ʄ* B< ^" ۅO#Cp\8)FaJ"\n;=b-j1]sX\+ bQu 6(>Q;Ĉ+Aa(Ȱ8"qqR2#ΊEo`|ײk~{{cdd'嫑O"Sitd dy&,dy69dys\dy|z!r"W_H UgL=ev2r|O5d:dWͯ:}[ ̟3@9])lB6[6<3mRk7ד͜o'w$@?%A?B1B<=>>8v!8;e|#~`@go7 z̳wH,Px}CswswRܰ3;-ZRψoT 4ā%ߞY<7ӘB0-Чdx~,!ß+B@<!_0hݭ k5Qꯠhݫ^7>*6_Ih=N ;,l7!YD_h=^wRMj=^xOrx ǧzzK :B}^Cp #`y[yfL8_pN< O>&V-o p%.VfWon:1}'- oc}A2vc {%K}e݀q9ՁRzHRVƹ+ bR 2Ĵ@ B*ln+6N* im\YIlF%F偉Ŷ\ڒS`Sg5^uz2z/}˒-pU \7_$6pg1B%/h`L"47) PNYKE>KpL:\vl:m i8Ni$hJgX^6JAt)葦^i&I :&6 JtaB*i쑓}8Dژ>Z,BSc9#O,3}G^  Cq4x1|:^q> j\;1':g[6ҘB]ct\BvnQ,tر2vQța>-, -5Ӕ2yL),3xE^s;70% ޡz+ޣuP1G|L^D@Ԗ'ɧ6:"UҩݢGmL틮[ j7s9yBɢu\S}/*e@וM֛$ R!Ul^]ɣu=^|j{}=m1qR EX[IcFCˡym6hI if}:fz#m}tzm%ey})moKk+@l/4'崭巕WVAm mFAuԷηgmkvWD^|xM]ϣ(X^=u:WԷ%0A2mozȁD)/hgSz0 [ԧA(uQm׮S}3{_]>+扶[-i L%Gi@R'WJSK"JLWԖ JGU jޖzeW,[~SOţ x-r]^Q`~в]iQδ)c-{񨾵S&%!euoHi9b|R|˨r>d\?Ы DT(ڬ+T:DA}ʖkl|[;BjhZCǔh~!T5y-JP7+ٛ-5{C< kC2-<Vo B݈N ަ^/:CBG0:FB fйMx.p*SxC7#9]Jh;zUб{IMex45wVVjwA-i5ez:ssݚZ[3lֽ5Oml-T[רRKuVUv ͥvuG-fu_+P{PZ)wi{tkz \hVOTGi;a,K! _PfpU\urNn7;@x;U@r]qE2w^7渻n5>xMƾ%u|[Zo䝼 o6Gr}~E~?AX?Z#w;uGwYQ 8:$)IЧq5\ ,fj賸jp5y\ p54WC_й󤐌Ÿ ~WCK/ȫ_@JqMK&e\} DWpMu&$&VWqMtkqM-\b|@6f㚨DkpMm\ M!5wpM]\}cio5O?"͠ףinaA i_*t6e @ٵl9[ndmlۀga0;žaqvIJVŰ@K"%7)x#1rń\Ik櫀!ʏGIN(<Dِ \Dy,8| XM~$2 Y-] ?h?k@ YL2ػدa01sأC$ @*L/bKw$2'Ha%沥pw-v5\;] n*.v{]˧ {T Y&~WHD+ƻ\QaO@=2 {s<(klQ"Ѩ,Y.iN׸k2*Ҩ.E:DuͲpdHSmkdtCp-F61*-6y@t2$&6͐nK=g<(Q+L.W>k:[JS7]ERe2V8XG㜉KxV:.Kc<(\&<˧OL+J2=n=.SbB d6knՄk]p^N)?E``L YVW֗iKs!n;ΝNQ<}r+5+݂pxo-j>s~i_˗F Pcj97Exy.G,Ds? <R]|?UB٣ ti? (? I겪 ?Чg<6Rw'ݩq;5Φ׸Kܕ*5LKn֘ʮqnpoeN6[GǀS9[很 ,d |[(ch_/o98p߅AIk#]$%sF2ލ2Xw^g5gdsV- 3rfv%~hlZu=~,X` Bp倐%Rj xP̖ krwPV P'4&3s_TCPz]BýW/ °/g1a\.qDma^X|(& ]#b*npM q1ݙڿ7gyܝq-н9$wMߟuf=:ś¤86%]:\d:Vl@Jۘ]ڹh!R;YߵaZPߩ{uvDwxћzO3?&KdՐ !q^#vN8gmx9 mwߝv΃,81$ѕH57AR][lYve} 33e5\&g1&ypcY*<3$y->>o2YInNpߡ0nai||コaP HP5ԇD {iPu5:JuܢU7 ] zU v|:6267/e \݀+`2}88LHֱ O#;9:.jpiǑ ˀNyvC9QEVi@[TxB\(M =_Cb2h67<6AlEtc\h&=f"M>=ؤ:\σB vY7\Oh_=+~lڿdﳷQ{cKe"Ob5/6:ӶiѦr3Qݢew.5`YM˦KqLt4ı 6v,6`oVVt~µVJ퀬thkf/ZVOp lʲҲ6mOVjiKL˲29+rkViY-'z?Ѳho~ޡmYy1H^P\_cET`/-Vcasi 5^Z[iYl1$MoS4}U ouQ="]ґ~mrZWE׭jSWx}op}5ܻ_uVoK P^G2;bhWNj'S)N162&׶5hԞs@>6qul:oᠶntn>cl;@uqppZi{鸠_;\&bRK]z/>Le\svzk_l3>> ؁Y u.tEncܯh,y\Nצ-IT{ϣU5pz@ڼ@^}Aǔ_OշV7j`nc3KfĤWH@uϖ%cVǶQY66DA}JsmXvQa1% 0aG.S6ql_`;g6c6!lgtimNF/almF> |ۼn\Oؓ=CSai^}6cJ+پY+;!0aӲaow<שMzۡ_0wku>|GSf?لE 6~N+gv:g;;Mh>r Z;yoi̘oL'bz `Ll0>㿍/a~ *P/Kkg11)^jc <ߥӿӉZcɭހ1uǿGއr>5tfm9>v틘1ELsXX_y c x\_-~ ӯaB{1k~ZE.6bX% _b+ƻb~%Ŝ>,y0=^L:,x n W5}9 ?"npwCOaT^#4ct}?Ӑ8&0l1TH%liBʡ(rD [ړRʡAHg&IjEm<]z|n~ޮZ׺ZZZɯR+zb8 ˥Cѓu$(]} |Ǧyϲ)T+F]d ׉a=,k(ͥ:0wZ}HVhcWNP_6ީhՔS ԇ:хW67h@OB4aD7X>k8R P 6/Qh/d@B4Yv}@l4}.E 8S~¸`ߜ^ScZ]."-"-R }i7t-fP+~uwQ_){-<r<G[XhHc&"< h߃=NZdl_EcA໵'/ѻ4ީDoUI}(8M2dɤ0ӕLsȎVZôX'&">d%سI;Qu'nb]4m̗d'\ղ_=yw;W2~Jeh/“}ԃ`\m{PyٲI=W=w +YGϣ -T˟uちokد0yNE m? NSXyV)nfG!}>To@==u%0 ^p{e7PƓbLlc? otA/RMnẐ}K,bΑg7dʇWloD=jlò#a^(9İrZaў>[ZډAnԊ5Vvi^4OUOA:Zq6u[pUQ#JyD)#Jߣ?ᢍ7U΂Fjݺjtk2ՕsZ}>uҽlkzhzhMs̡w;%1%<"Fu<($?z9gZ _\,K{{[ZԽNbNzwÍzbS 硯0~L'jWÝWfsy:`fe4l2AVySZUݠa'ں\90\7aG<L^^݈g)R:̓zBMX?_~ ǚ4+Fo#Oop_+z3&%, ԧԞ,qK?˲u|[xx(ha%OR44<'8t=wOy] :J􄼗{Wij8qNB4Ogݔ ʖNݼr)O9#>/0_=Zב|=3z~_y,~ˎqDZei7UExv(n&\J}ڕ<'wx̝twy^ųt%xna(ó~DoYs<k0v u^aDAIC7tҐVbj8'7fC*9J4~!bǣ]6jGF;f5񈈵|;#=u/_DGEH 0kȕ%4Y `(z+]8"e5[QA y=6;`//p I9-Zq[Zi9J=mVQ )ҳxS֛WtxQrwnpJ>zm 'CyN6_Uc^Cݯ~wֲ1No 1_>+0=:Wzou6/?:_|Q,nr[+߆{#1N (MЊJ}e >ɨrݵպw0h1({k 7={fjŞFf.^s E^$=X%X'l܃3OKƭwЃi9:DNxڟ|.9(SzC|\Dt"E4O-ތ7?uzZ֛EꮡuD NV3wq|Sf9s͋GnM;1ڊ\@n'rvt7߰S~FQH~.dYqRsR{SEѼ 7Y1`7nfQ%}ra?YvE~2e#=@fckm@C7]+kȮ|"V!OptϱghrNp=ћϊ#b dg5ֈj"%_`:ED WpVY0X9I3 Me4䎹r?Q^ayvYϥkDޛ%0 Cg7߾6 kF;'>`?n"H)m'o,f=Kz)*J/㹓aܕ2z`Ga57z`[5r=Z'YA.#ޯÑd6>ݬp4Q{!Qft:#/{U+*6|INsma)Mis"ΑMZ"FGo&9q'g J!“eA<2"4A\}&~6'~fX֪ y9‚'.s)J ˔ ƂsR[7GíxV3 (ry.=̥'buDn.siKlM[VNX3,x1jNGa}>]7`yUxh>5$pKV }VfR[Cg_-ͽ^/w\CѵM.Ce8ҩ`")}7򐽔\F{GBպ ET#af#Gl(oQFt;Ik_b#VE)+eE&:jik,d+b=[ D{YuyX4J(b;WggO^˰>98T-WVbx+\0ؔ7 &?bʬsKEg%ÏaQ m[Ciȇa{l)+ne7 п'9,Djkz⳶ːp<(K: SHz[$Rmc{7#GI>ЉI|m|!ۡ|S&*ѸxGr%?_w$ F]?ȭ'߱oTN@Pr#Q4{ہHor㛿Zn|j{_FBYz{E6ju7EFFo;;~n-~N&A]1ۛ>uǠ)#K~JwQ6S`~eg,ҏxN8mjErd~Ql{hoaYiM9z_ZM:R }ў W)ۇKѫ!F,gV/9b^md zl}#b0E ߤ{Ak8|LӸ}dHm n`gyp! p3, :~}.,* E؇ZKs`FfmcS7j mc'Fc%H(8zxȓ jjOvwJ*h_e.թדXgZM} } ~yJMwdTA i׭[f ; C?AfcC_zCS1#VǐoG~®/ebTF Te7a3@tSz%}c 55bm"l"_ [y'E\ ;H@uAtd&'YH2+x| [ ~,im%H܋P+.i9gXːOh\ 2`<Ȟ!3/+lk)) BH  !Ku5| s0gX 5D>M 96>&%nƞjbdZɫ(dQ4 `~.^f9t9mzi߀c:ó%XBEHCNs7J؅8$Qwkѳ {?~>( 3kjF!&7_5dе:*reBw=D8S;Xȕ ;%vjVqveDÏ(%Û?@߈Σ?6d%;E>FvM+b%\N{=Sjޥ.1S6*|A'NRMQ1'GS  ߰1NbN!ߏ& ׈vȷي|5l9ȏžhџе!Wl;UGs'ԝl(Asr/mM_]\~;'D#|nC*`cLEfoaHa <8I؛o"aYVEb}0Cד(ukgd`Vy0t>@!XV |[ 4ˉif+*Miɠ^uAtd7[ѬBf^;[EX2Ľr9Z/C&cѸ.0 +0LLWؒZ7"bSwS::5> `CPBC lVBV9\ǰ!#ؓLL+1Y02#Ƣ!,C"N ѫ,.@UN{,zu Ð\j]C=uG=;% C0 10nn~ɥ1yɸaV.۸}#w *³+AvA2w$י?@a"j8l,;E>FfK?+b$\Vy=)5R}މ+t^{k(}:9KZ>,7fhLۿc=7i'34T+M!1Ɍ6*9'|MdHzKf};ltV{\?,,_ҧaO19DenRhmLS~ޔG^ $2)}Zې+:ohK.EMIY'z}YBeZ#9]1(<ںyǛU4fw6IMU2 ,rѮ!ie˱ vh/`lPZ Wq!܎|4բVc[\7o{[z (Lݳx/f632 lPnӐZuO%WXBדz;B6w=x5,<|9P V=}U"_1~*=/|`3;>Ql^ ]4:*̖}|v7kv$k3al"ڶ"E[iqv9z3IbwEpZm7lb-E$e,ѷ 5J~(uQ I}pꊉ_58ޜR$%0Nv'{mVv7osٌI*oɼaZd~E+6/%jekf~Ҥ'T/U;1'ٽV#Xiv ?/_HK7ˉ*8 m;Y'!_|NZQ'͍1.}ZEɉt,OfMuJ;1VEZ3| Jg祴> lDZuȎ꿍n!gӇ~ȭo?@ϥ?/1ꖩQ7sln~r+ Pdƛ(JGOkҞȆV~$&4N1l[,Aߔ> !jxP .19FOpJ7,+xؒZ=Fħx1mxf'oѽtz/̻w0/O &:n~emŒW֋^]knλֻc}y{wzw{Rg{ |wka\]V{o7ƛ)ٌSf&\Ļn> o7*{5ݺuހݯ-Ku-3ǦI*jz ÛM{üQ=L.>˼^Czmxսf^+Tun~7n&yz{{9zP+]]l=xۓw7% \o7ջfỼq;y٣\w1pb^awSl.+yG ߁ǰ£ `yX6mO# ' !p' ?<<,oZ&1,;qp?0)Ff؝yâtXV5mᨨ̂M` x)vS~7apԝ')# gyp\ Ep5|nmocp5Qxra /٣G7i_ ΰ̎8> Z6e0peN!Ý}OxZL0 }щ Xֆ̾F2 ᵰ̅zsܓ}~WJ#gF{6/dd߫?xdh\f֫>sJLݬy`4_7~+oړW? |?.[IcŦi.{yz+9~{?п˟z/&t3`s#8 aV&6 Dž3Åv4f.>(Rg)UmKsKϬ_3g>s%L2J},eߩ[J}.5J;\R|ϙמ~R*ρ/ȍ5W̔Կ;RI6oԿ=E3Gg~n<Ӿq3?7-5 ٥>i[J}Cg~nV7 -2J}nq}V>.f;(gv=3$p9I Y J8$A` Er$ (AQ A@AEDA2Hb@P{ֿ굻&]_WW}3{ߋksML[ qx6\G( ;ĊjZ&}E+ho )<ǝ3xρ x4UJ`QqӷiJRmM~{tYp6&ZW1Vy Ay5F\sk>9 g 󔣣U,ȵęJ'Dmxmk'׃%h?uYZ:r# <y88Hp֑֕>"/{ܻ6H 7I ٳE|/{Fqa*_&*QMͨjWQ_A+ mZHqE- ?ī103K!0y?|U#M-X!4 K;x"bjyqo0.Y}M]%EaUPvʮc)')(7))/թ(?qT T 4H:-b::=R:PQ9Sy*RE*SeU: դ:+V:v:;:u:'u:un:7=K<ԋzԇ|<= @  0 uz]'қ.B#i.Jh.Fch.Nh.Ah.Ih.ESh.Mh.Ci.K3i.Gi~]ާuGtEOu%Z@ te>Uh-Ui -3LWs]r]VJ]Vj]]:]#6z }fڬwnH?H?ƴ&vGiҏ>ڧ)::9:[y:tI?ZBWً[=ly3[YHƙQ**GǷBp6vvv;@vG#=k'ɐm@*FxrQ.HCy(|Q*xJyJQHũ8dT2Si* QY* YazRTrRKj -ܔDI:PK] gOݩ;dJԛzC!zԟCD/A" PP(Ji85(NoPA6 h44BO,M'dxT(O;Pf HhTw]L{P\JP>:}LC ZH &-P>O6-P2+w~wgC޶mboۘeoۄ}g/me/۔qhF;8f48f\O[_X_>maЮmo1;3ln5P*Cmh-8_f#`$L>| Kal'83{z@GzF#ϋyAdȋ"DL"#D$wd>YL +ޑ"DǍyUdk"{G^'&>|["#+2Rd"D⽃u\7-  3.@f|̄"D&L  N"Df 2'@"D> a(ֿgd 2SyDdA", Y $@V> Y y2d| 2@dUD Y uȆ" "RV"kMD 6@dsȖD~ cȶ";D~ =2{d9@`/"D $|/K9o"r,@xȉ"DN 9 r.@ "D.\ r-@zȍܺq62d " "-i /~꺺n;iS}U~E҇}T }Rҿ>y}!ZGn-S:(]O$tG Ba!{ρez"K7--. X,VV+arY}͸Edv6_Mwn]r<)݅gc8+Jk[V+#*1VJ+e[!Xa+b9kyV"+Ɗ.uYJ@ӳ=OkZN_ zޤylgVs\{f?ȭ;O=,>j.]?_ezR+*A},gghi!<>3>B>@@h]={3j! aCa q*&o~ނ(Fhca1?&dSa`̄Y0ޅ90>!| ;| a,%)|ƾsrVJ+XkaُlM | a |^ ?6;`']^g88cNI8i8g\KpU܄[lƨFjUjZjTO֪jک$^uPU'Y=MuWϪijک~RnGU~:_!uXQG1u\P'N_N3:~SuQ]RuU]S uSbCkK:nƺ~BOֺ~VC+z~[דGzD/ԟzޢVަzIһWVYNpknvZ?YkolZXu:nNZ_u:o].ZuͺnݰnZ쨝T2MST3M S2MS(> d?~JqnuJ/?e؟OUOeCK!%}VX_#p.cFhb~f,DD/G^)E8gk2YDlrN8Y/_BihZB4-orQA&ZtpTQ-9Zg;Ѩ#6qwe*nS Zx<rc#bIۂKHp1KXp0m J{Qi4̼?p5~32rr8:_B NCysC ނ̃Ah;aq|.X2b_~Vrt? 8߀C-styMV\&fV¯.RY' Y?,4ۂ^5 ]W$g{5G~h9ئ\={Lrf/pֳ]q}孒gnOViIB%_@,C!#~(,~("~?CRJ%~(NPjCiOXx^Hwa:[ a,66ֵ{3w ſ: g<?n-n(*;TJNeV9T>Fc0E˖XZd+,#I,+),'5>, +l#ϗIXId{*Vم#/a}촾D.]_کž/C3Q$ry8Fpț"oSK*bP~3eOq^Z[p֒muL),uk,ud: Kr+~`j\waX\wZ\?up= q=юz|\ sǰlլ0 16\ bݘ+@^UOpq/`&̃DZMvsvp=-)z,ؚjb=-XFhȖ8Od+@8_S6ȶ@dkXd;Dd.>ɗcf_\"ry8l"oK8 8Eo4wK͐>)}6Kzqܻss#'itxzA<^ g 1_4xד{@L[K+6m,RGߒ|d؊2eHcZ:bSl14ajuA7g3yǙpf]rV;_9k:g=]"E,)Ds͹pn:\v{?ܑ(w;sǻ%gRs wu_Q{="㹞E=b^W+%x^W+Jz^W{+U*z^W<QJJEqtU@ɿK>LfPcZgՅv2gt]T~&b$+z^)C>T%%:t)ty*UuA^?ca63cwAζwB]θw#I/In,G%v?&fMͽXm$RHH2Zz?Owz4AЌ) cѼh^B4o(7vg;vTFamu+C{VRXIggg ϔҟ??SKL+N3g<[Z޵`c^NQTໞsw1+t2 Ēmd#Y6BQTvWײIverRnK D*F%rT*ReJ5ԑR7zzQz@BhNoHEchMI4tIiOh>-Oh-sZN+i5u5moh3}G?Џv.G t{.K۩ r9;2]5=2wsU9-uyR|DV_5T Վ}UwzkZ*u{ Rſuo=TC_As[XR8WXKFJP:pOJ%JK's{9~X_YvyʝOBo~RXk9v0~ r./gG<c*Ǻ4=8r8'cyyϷ™ExYWα7Ay^yM^)eKT!^6Wq*F 9JåVix992rF)T󨼼O_/Ty6QMIj/OVyy!Z׶SOLY_;]ݮڮi6v'^쿉cu^~C!W3g*+4`K^k=Qzs+yyUt /eyf6yK2<1*&8K(h3wAP8RAP8 A (pAP8 B%L0&DP Aa"(L0&DP Aa"(L0&DP Aa"(L0&DP Aa"(L0&DP Aa"(L0&DP Aa"(L0&DP Aa"(L0&DP Aa"(L0&DP Aa"(L0&DPȝ}ZH:qLy(\QMsb IxZ!pPIִ  ܳ%/e9>Ѝh$ǿS>!='Wf}mYxŗowzڠԃYӴBR&=T;K ѻEGBԣS%W©{vLn$&Ѥ2uL -Nԏtjۣ[n퓳T֣{;7&<שII'=K*2&M(ZdREb %& ?ҲhwSYo(1wB۫ҩ{ǤY6Zze/R`ђ%K,UdĜ ok5NѻSۤA^=ow DذwC<6l w]ׯof}OsvY2*R6k^WGV>.viӒstڔZT}cǯXys& >˅^/_djƘkX6]geڎF˓1|Y +h 0"vB&41fʟZs6ćK,,rfPV4/e/vygݝSIV$&C# ujM1+U:&'w/Sp] uOvZӝ֮W䞅vߋ҉lf0L6V݄ 5'W?ЧO@R 洼)uRVn|M?ݿgZ3f/Uڹ 5  |֏#禾xY͏/cFK$1Fcnm Ύ}c-אMuɢ/q.ڄP;[Cra1ƳG  ̋$Ԍc2~; coA0Fd.ԥpmha⏌+X_&=vG>SWg/=!H$ ? L9&hp=yPhœԔr1YagbQѼ z pCXĔ̍^U=|V}{6VT,qe\*+ʑ_vI-SSY`Z$j֥tYhj ؍qaMpTO} r,[1vJsaP5Q0W Fw@ǺO(4F\|5i2yMz3"瞨ӦA+ O7}8"MT=ZY.:2xAs: 43^h?^0CvBr8 !#/sH EmPpi[[0d(ii[?y8EVV{,0! sd0m^#K==gE߾?K<> ܅#nVwq$W]rWiŽ3&h{k!F#eU-%4C̈́zmYR 'k .ﲡ{nP+3nvg_NAb˙)v| :I"3=goطXAon^בSο=IV9Sim|~k)'Smϳ"/ k]jz G.7q0( ,A xGcح?2g uŔe 6Rp?v]p` ^(W'W{[_G>U?_o/n3C!H< b#Dٿk984rgS78ݬV:#9Joc!24[o_r)5Џ/l֦|yp$/+ ˇ Z0eJE]9bϘcOؔImxjc:cEL|aԫ[ɾbcRfCˏ=vZlF" +$*TG*%(0hQqr]=pwJӥTZn8aәzZrg1ϘRې~$8"'`ಗ _SIvf$#30`ci %#,#eM8P.R |;i  .g!4┊HAgQ4ˉe6WǫF+s˾5c!hW1= {O  ?*U>R6 U6g7LBv8"_-(#ߺTIؽb>u5qukGgUC[G]^o=6oLշXNSneqaM!eխ4ĜtICL y,ԎryGgǴȰ p&Ikp-0r@d;2R/D1z2Jb:W+[$[9uHOu;K7OaeY{W(:GTƣyb{wh=&$1 &R6>ZUGyJ =_{I#Mc0$|f*s6b n$KSq}2=Rޭhtn:weljc:݊RY㧕^@iwwĴ`?W*'Qqv;2TT-kDH ^7\o@@ePN1DR rFIv<006ޔi,hT1-ĸ}X/1JzBtK<룴EyHc}})IƹZ>S,Zcy/cUx\jz=*|&'գTX\vbybg9Zx` ߹@p08og  Y2tpŗ>)@* Y79^UrEr(t[ 늂LoH2,wHDXa&hVe +uf{fi@DmҢ'o}'Z|[;rш׬t7}KڊzQk={J6)Yu8[ڵ+ɟmkNH#jxąוɑh!L)&sYVk3&7;+u#t8 *)qc>eʻ1 JQ D5@Dw2U?"''{S(Z_vY9܉HLJs-kV%Uh7.Yɕcq'-J+w[WU`2>[4 i̛w$꼦.:p1vzfͣq!s1Y; ~X[mM-%wZ(^rP !BEOHn>)$Yr9g@SJ<yiV5v^^콼:]sy·F~Txbu_KaT*ke3 k0iCWpLu'Ob=hA땒I捹SֳX` !ߓ endstream endobj 2255 0 obj [ 0[ 507] 3[ 226 606] 17[ 561 529] 24[ 630] 28[ 488] 38[ 459 637] 44[ 631] 47[ 267] 58[ 331] 60[ 547] 62[ 423] 68[ 874 659] 75[ 676] 87[ 532] 89[ 686 563] 94[ 473] 100[ 495] 104[ 653] 115[ 591 906] 121[ 551 520] 127[ 478] 258[ 494] 271[ 537 418] 282[ 537] 286[ 503] 336[ 474] 346[ 537] 349[ 246] 361[ 255] 364[ 480] 367[ 246] 374[ 537] 381[ 538] 393[ 537] 396[ 355] 400[ 399] 410[ 347] 437[ 537] 455[ 474] 845[ 463] 853[ 258 276] 856[ 267] 858[ 258 258] 876[ 430] 882[ 306] 890[ 498] 1004[ 507 507 507 507 507 507 507 507 507 507] 1085[ 498] ] endobj 2256 0 obj [ 226 0 0 0 0 0 0 0 0 0 0 498 258 306 267 430 507 507 507 507 507 507 507 507 507 507 0 0 0 0 0 463 0 606 561 529 630 488 459 637 631 267 331 547 423 874 659 676 532 686 563 473 495 653 591 906 551 520 478 0 0 0 0 498 0 494 537 418 537 503 0 474 537 246 255 480 246 0 537 538 537 0 355 399 347 537 0 0 0 474] endobj 2257 0 obj <> stream xmQMo +8nu]MmHmhI*ă8m, Lޛ` R)iijF^T4ΆmD CI2Y*Ս$i撓5 ݝ ^#UOwep=k(KCRT@.zjs3 жKWh qᣀI7Lz yVAG J3j;T: YX *z7U>Qzӳ'=zQ> stream x `E= 1d˜p$! ˑIs@ 5r ."TTQQUDALP/Ptw] * d{k uouȯ@Bё=l𠣯z $ǯ,DIY>QsnXI8Q1#@6#תIӫ_mn'JJd0iLW E\t6 WQV7S9pgqis'?>] *-"p]muͱGz ]sMknDȱqڌIծ{=wQkzQbprozzqK&zg&s.\_Cm}ǚ{z%.%VV #3.xl7"T녕꧚5B"Ǫ?D[_UQ4lgUJR~El1[lal%i@Dp .fUwƂ|d9j-)dZ]M@K2˺Ăwq ?6!BK<-/!mOehbUr@VqRZظwwq4\Nqlh 0>7~G(?Nm ' %DxYV8i""%.X9Ӓ+J߳W({=Or$*̮v/hOMAk?~[M8kum#?_(ۙ׵GB%f(qpG8 vS\)yn?˝Ve/hy9J\;ۜANI*htLvW`|Nb 4_U[{asw=%hWB.;ZknL4]JZ{ BlÆҢGs],a~"jb^ߥSb*D//>m$/.I\M ^PI_@n?]N8ĻHRq"MA6Zh.G1,vwhchQ2G1}~V0 cejAZb݃n{1gHv>!ipʾp_bjsV;6VOllr: ~p itjE+u-/JCQ)xrlyI-/jٗryUV4]}V;fv-Uq$ :P;1"d~Qה m,T]OJh uk7&K2.f\"%Q\B41%IUv&a+Rj1j5,ī&Z-nswdO4VTkepmۊ%]Ҕ:5?PT~>MI :nĴ dnw`j|+R}&>AXyF^8cn%!5W>0)*/OpMNM1]%76^X2슺͆[E& I㕦]Ҝ{iJWiH4Ji4Z9)͗|!͟\ϤTO9!4m#i$͇Q?H{i>}iH4JsXCҼ#Ҽ%͛Ҽ!Ai^wҼ&ͫҼ"Ҽ$iK4/HOyiYivKKViZyFf4xi-6if4[yR',l1if4HA<$:iif4IF{G-])*iviY!riIs4KE%,"inf4 /\inf4)M47H3C륙.4iJs4SZi&KS+M4(M4ULf4㤩f4ҸFҔK3JRiJ)f4#.iKS(M498ɖf4ɒ4}-M4ɐ&]&MQne)a˔%݂[2JvTҶin 7#^Ϸbgc(d ꁪ,䔷(7yr||e&>8'EY@`Ps A 7kFSж6Ufsp}vesrˉ_OI+6urymjMԉUiUUʄcQN-/.gRʳ2^)M-)/NY^?dX}[f1g+L-(O+M)w({4e'=ZܷWl(|kҀ";_7Sݿ\Pآ y@H.䂐󞫒!|/䬐 9#;!zb BN ZWBN RB,s! T'BNXq!<Bڄ? PA| }!G']!#m!o ySB y]&U!yYKB/E!/'d=BgKHOt!;]H&!n!ۄ<-)![l'lMB (!򰐇/dr{r)d;.6!+4zAVY.d[,r%B~#f!,rB/dBn2Gl! !R/dL2MT! "NȵB& R#dBT dqB*2FH'rBʅR&THb!#2\0!C 2XHAB '$WHl! _H?!%'b"B2( ){I]H'S:K Kt.B: I(j!!${B2!B: !W AHh!QB"D &$TH`!ABxBB,BBLBB BBtBT!&>( p߃ | )5 _/3)hGGOCG{xwJC6x w5*x ^~"xε{ρgn  vx@Sx7O`K`q'f8߂: hQ;?X k wUkc6`;,,QҢGFQiQQmQ3*6>|q[Gukm(:NlO0[>h[-hO'͠TgB9(؝4*yhW:m*f݉e|,6,wS&hbJ(w_z;W6V u/Լ{! 3g5JNnhh` f64̤~4}ߢCf7`fΜ<rqL?䱙ZܐD9>E˅ a><8g_|NSk8 _?gS 8>1>8x o7A:x ^/^^<ς`h-A3&S`+Oq <#`Xp?X k wUp;h+r %-"pX|0nft0 Lׁ)\ &ZP&T `<*XP\0Qb00\  @  =@N5̝ tB448M㭼ˑRJ#M.3 - 4386g~򣠏_.u=4D #pKO}g^V0wJqI栛OH;_߬Qh TvLzh%#C4_=flK9Л7n7 E]D7#u付qR{Uڱ<5͏VG4zH;Gh#=LOE)[h+m&oRw񧍼t.tBYl8fZZv=͢hh1jPkEZ~hE)xVDv|cT7^< MjA͟F="Oa"ݡ}foUܳj[ _):MgGWp~JEONDoekKXIDrk8_PP+)J[CUN5Yd*oΰClE5#6AWT2R~AWua@EmĂB:,Ԥcw;C%v HHHJrt R"CQ>z)]c Z;޺ok߉NRFI736XsLwtefN$͂6C=iǣ$zWf}l+o. ]v0UgBorZ sЭht}y;3CjK K-]BڵwiPaŨiݩ1ZZ|<wݫz96ddgd՗ee>+ô`EFy88,\6F+N33&جu`0XCCr,+cdϩ|V CFH(5zz`m~ͬQuU',Ct}[6;~gٷy[/|4|&%HYۙIo ++FJ!0G1ǐ@IZ -:dei &fa!/>.~ 6u&\>;sʳxLg4Yaԙ~µ+vӐK4mR q͗K#.tie?7,tVLj׌;"F72IY%cL37iVr{V@wlr (gMF~O 6spqE+`\\ߴF,+n}잝ޢ,~hpo>6jnmwn2ڥ!h-z s8}bI.XKvXr?&^iXG ȧ,_Q.}wbg cd$_FDZ{`rl*1ۆ:?{ F=Q2v_n8*5՞4wk(-^̵s5-nl#I1h:J H3amoV Kbq=cxܚccɊ{VXyk])n>W6JI/Fv<蔞WgxKl3vPgGvc 0"6abR-*w 'KTؔe|?q*mw.L}{!E}OŒgGaKݴk~AOt3A, 9İ{z];aT猞;ѯjUn]0|?Mw۸yUa=3k@Y4XL"&ֿge4Ħ=5r^eU_:p:⥳yn.Tw閜_[t9k}A}c =&lmYl=mS eƼ'Nv2{yڶyY֪3.>sDGU'щz:#Ld7 ֠tjSP6_B,N33<0?*P\bU^/S_F6/>a lhOw2#F;M̤ ma N ta6ny>R- j  AAF`D%?߇'m6otYO7hū޾/ ˾}h?ug5m.tvѢȈf0fF@3 ,hC.O_wuC^J6"EevD?fo!Rzg(S:e7}پB'v|/h%= UXvMU&=T=9g,ћi񰌧`<.Շ&{;ov>tU.fD[숚ivttF{b TLo Bv24w_62/߲]S Q?oU6_ooPt.DmZ~R T/M#",\й 6x٩ԩ$!<)gt1JA30U!QWĸF&f?J(31}ݵ}3\hg^VR2n}[\SDZ.>ڡG^̮уGF|^/ Ol=bN[s>=\I dԦjDe">\7Ti薉JD蝐?{u=O/멘X1S~wڲ%F2>3gIoLxTRjþoԭ9`:0Ӽ(~o-ƛ8ZJ#7 ژ2/ӖNuka_y}CnU?beEysjzhҁbrv C#c6uϨjfр `CnovP'S>Zb)N_MB'{g0Y|#- o1Ǹm 4z5)sW$eܱ-~yŠ@篛\e3;-|EҝX怀xwx-*nnWݡ8[XSlߦ PwpGDȱ*4co={WP檛w0iS6ڡjrw+ɉ?aFaO@RNBiR]s==K|BED:т^OvF }Bti:,;ܺinAح F=Fr@3rHHaϫn J!Y( Iƹ&Nu'i{!EKk|?(b~?r?gfxʯ"{N qȱ H}*kr4`~f@u8RR%G;cV&fC~={<%N2iD B"w=\(m.}Ӓ̙)%l3fxhOC kiBYxq.m^Kr3w%'D%%'X[vEeU`M9t#a%FdP[*iTG Bp5S8aS!Zmɯ>MI}Xwb*{@}]|'?@)@) !}9H^\^ G0FP1!$T#cZߑh|5, ``N0A*r#+ aৰ,k4v)%gl|qh4O g> vvD:IEFpB(bH4cͪ@Dv5!2/$*Š!X|8Z{o/-)wzZMxǓՠ{3rR}3Y;ۓhǣS:&/̒hLCr * !PLőwd⥱)÷A'PH4$bRK!3cYc&oԍ*[n|i1ǤM ěT;GBZ$HR XLvP-h-Y(#ňղ? '*x9LP]}wzV\u.JzmyC+7:}ZJ7Unx ӗ8ѢFD"Zբj-^ "qtc޾y)5h=ᆩɮWӋ-"=]xHg _'- ? 7dU48$g.ziind{4q҂%I]x %ooB[Euo=>Pkw>#/νC ,#C+B+|!F+h5VlAF8EPeh`Z Ba‚0Z .}m-c־S꽓\Iܹ^z"f\y{dlVgӰP@U-EE ; K.gG4gh%^'J:FS ;a3 8m&J}i\"gBBDGDH/5G\C$َm&3Ə:chXC&luTp~2sz:W|ӾeY+jv:Mq$ TbJ>0טdT{BImAiJms):CsT*Z[(!:{PR ni?a=عpAQ |v,wɴYk^YsoT&yT45_&I=D $PKMRvɳz<[d>q> d;r8돫$hL>d|I +HHWH@\.qz3[:ńЖ? |&ȯ:$v v4F>=Oq\X E" 9!L.WLS8ҊbBI$<˫&` ;~4 L,GV,ml:}Nc/Re1.1Vgɂ [#Xsw;c3cf#qV$B<X?6qߏBlOyMq&!3!@yFi|F~_#g1I |E@? d79Հ;$BYhY_o/ p-4AhT$jM_O DF Ʉa@nJօ˛ fyy Ay$q섙CEmHG\efza?5&gI*:3]_Gt 3$'OPP3Jz'kL2sg]DZEb5qiǣCN6>#F?O82H(P@7Ja,U$W(!IJRGE.hMɞ~ ׫l>/ΉD%qv#G^GBCBb{Sv++V=4йHӧKFA\lUyZ(up)>*L0&ūFIuL?#_qnRU;64+a›ޤ"x;p(#RtU Cs\F L ?-,rwl'tU#u-çpn)%JP)!倧\kq /DLG_W>.hg GvX>7hнo" 1ep܈dP}T#(=.j5I9* m 2ٜO倾&RgSBI)Wӌ:H^!59nsaAȘZɥa|&p.%*6gf+y]buF`6Lu1/19xPƜ0#L1 h`N! )ԥ˜͕qH^u 6Շ '7fp{Y˦ bzcR\2@w a0#TS@V *Z'ߋ+ |MAɼFE^O^P| 8Q;79%XV\[d0Tnpz?W>TmG&ejsiӒjmf_wxVxgj$.%:f%I#{BQ%Ba?ŏST"i"I`A"P"c2㰬Uk98tr1 ځ*/ 1"grHXq H<ҼGV`ے^*}Y&/$6+Y"6i[7 WqS#9sK K#N#Cbb܏srӼG#*C:QpX'EhmՂ* ',+"%?ziWLE1(}ZwPFD%FuO&Cw#{uu緎 'qWPɒtB6ZQ s 5y{Ö@6U x"7/pr\\j'䡊ɯ'C2U{pW.=H=&1{Z '%a^dsx'kQ| ~gS_PP׬x&u@?,SK֜ZZhT\HMbFr{IT,eHި d/[cЄΙ0FH:}uSOͷMy$Jr߬,9_1u+TMӽfkw D#&4L+vB$"Nu %ȅ'BjRjOr9jc<3 JKN+HthTѵΛ`TD_Hz?\iqWd_ LSsyZ[h$pDQLC&@GQZ4 %G[v QƇW$zkg@"z֚;=5ԕ&$iRɓCL\oyzҙ%1E[ KW4zҪ:ME~אkm[ʈS i33l:wV -dc6J녿?Huƨ |1Y6Rf2Lb(u9"QDJl Q$rȀb `eKD.V:t '2~pKrӚ/]HO%"['w|uS3_X=1sgc>MQOR=љU5G+t ^yFՓSkmb3-^-mY~by"*9IҤ9ti9O=PqM4%J3 HAјGͤqC2cÏu7B f$I@N1op!5|8k2߾SªPc\frqԘ? `+  Sz/B֜T!5jleH˱Y-'̀kY83,&H_Pأ1;Ɔ74[pN:E>LTƦ )#JeNm'}XxU%!y \γ!'4t|;L_B2q=Hp~3UoU^8&MIy5gt4B,EmuýH6FdD FEc@(:EC7%%,12CB;Uk,=*U9& E.g#G L?*/,ɩDew=Ѡ7C-yhM8:EW*Jx_E3[w qɦhks6u Q\;C>DhCIx!'F64,Nd$Ѕ k!prMöPj 7pg`dn+Q pq(mLc{@ jA{ =8^=DP˯ҹ::tṯ<~\ī n&v~Ox>eޱG2]?暹gd+7@pZЎ9h?1vz@QxH@Q]v5ԋiJ%t;/O0ftI*녇BCn!w6mAJUJ훹IebQCK1`?cXcz!ҡSJ>w9"47I8?c{rt+wXڎTQQfb1m k,m}Gk ozL'8@lWf`f"Ҧ,WO~1B% N6F;x0u7b"J@?H#F%ǁ\AJza} Xʤ""+C/Ry=:b^,h#xvMEv-E-n/B/}uXH)]}ֿɽK^7Waj"cU 3FpZ6FsxeR6%=EfU@s; co^soEnߎ4, q]S_'ICA\>p6A:~}oػzYwR?S(i7\|VBp^|ЮOod5If]:gNz9=$9|M{|P?pך&p2,~] < 󰦶#Smg>l.;muWeM[\h#xQNY8=ZgƑʺC& ѝShV_|4@51ܴdLbodFcZG}݊7b㥭\S>dVKU'Ou<;Ͽ; ?(OF$7emSJK[V~T=l_Lb.OĥDt4W"|ѴdnԹ2@h?;:HsB-O-JO:$>Nh8ր^"$!Jdm5^׵Q\$qd.z2*Y|eXu;w ?WTR4ב?o }~_MS}C$<+;JXHҀͳw/=²Bڟ1(Ӝo,/4:JߤI=+@Ƕ.) mK: r : )قR, 'q:Gm> O1r)]@B).j]zQ_1tFw"eHC/Ҫ"xieA/I@SICBj~`FaWygT5˦1e qqE)  0!lL8@"ac!1sc8[1-:̋)Ax1?L6< 5&!Noa>p S 8 L|$YF30 1h #ˈ uaX< r&깄\!#,pR 16PpS;L%@aƝRm+X4= ܿ4; 0B^D*c\T]\.50 ~ Z-0H} -F28\" ,Jwmo=18FkLT9OwHory%Tpn[i닸}m0bĂh\cν|X?pwKd8;ѕaF_ߠ߆Q X qp{H-SfźYhw#o&B6ai}.+KKc'ĥpX5;,O0DW*DZ9N hw& $*TMѪt3]sO\ڂ.\hȱކ8>}Ҋ5Y ݰj,_FӚ䦖VWKKC6./|5Zռxr=E\Kln~Pf2{*oϨu1b8|xvƒ5 AEjLtG}c/ r|cm!i@ e{q;7y16ћ dl0@uѓ]`x'OQ Y tRr!>2,fJ&ȶ99{ 9vtN+s;|5td)sdG :2ή/Gz"| j.Ǟ))isc&EB0]#x.=HL+=uYϧtfuE3L/owf/Y>^eٲeKJ8N,ۉqȂl+Y2g#@!,lQkyl'Nh }RZ6@QJ)G[J;#YY}̙;{{gF:c}mw7lٰ6!6Ղ"#ʝ1j GO4ꀑGAԒ%el跓;,&0pCEЕ+<Zm\^7 <ګk5E~%JcR(Χ$~Sa,xPzlYȜ'}<+*<#K+8NP13zy!>>{~=Ύ$aa _!~a3AK_iQ;R2,;`O]؎~u;Z1{oo3NA( {PˬܺLc|RY`*ʠ"cz~G<O̊gϾCPgؿν:j?G' mP1{fZQT80<`bXGHǮ'0 'N+kkG7ҙ_d̼Zra)cl% pF6(fJ\2LL*gأ̵Dڥҵ2\0er[J~`D2hDoU ^,NUgOm۷s[oe xp/b*#."R8Yq8'|] ]tZhZnV(' uIW'c9c\zD|zD#=֟[}zg}^%l*sY/YǽSܙ+YfTc6X8CNg>c3GQ&:gfW]2@|3>vGtj5b2{i*4c";|~B՗|ն@XYs>`*k*&o⪔$Zd'HdC,"Ϲ+ftdߓi*eZIORNJ?$JUDSG@}?|@v`ӊ%e*Vw4{i1] f~zTR)hT2.ղiQOUqDTEsEf"V'l /R \=/:*d?$äeR2$RC"@)I/X-LI}+5-kAtgjMv/01KF'sЩ:21o 7͈H-a5bsG\MB.NjHD>$II* rVbMm;}qC!ROT-$;MZ'zT/_ s b,Z4T6eTe eME`+*DVیF\idHw;+*CJk)lq]wzmT !2ttHM\IHgHMOפ љ0)a܆tfم˭6gXrJSC} Vg|=-'Y)9^*Ω-U+x]Y Q:qeP x<-MUP@.5=["+i:?;[%^ 1SV Zm9 ҜEM֭Ȱ5XZ,9c˓Jʒ{;*s?lt!CbeEj^I[xVvTAt%WIh-Cgc!]6cMo2usGvLr }&5UK$=2I<ϣJsX:6ԔPXc' Y(yr|Vѧw?PT"+Uu 󺜉EML"Iu{>Pf[؜St674J4$̀*`ƒT$ &)5rBih8NT210IqCtV<Ԋ V^&-oc$K5ؽ1 ,tjع/_V_aA_o^:vr52CkjZ Â22u6Nw*2 )oXEc7[[' m_~)~βU.\&Sr(I2B5)H)NbjL'&6 $[mDŽO? PLBed9D p'p RAC<+`p97ckeduRb\( c( /8CyGqd.zEi Z^jf'*d!2ze}fYbggHʥ83v;̻T_2qݺgG_zyarLVcs3VG`pãC괧q5dRk4L8) [m4^VTOӃۀ$\4jB@E\@4=,u[j ̡l&!w@' 4JbyHqe=[uWg^[J+-gMl]l̞;rm{bCRAuFujeY3\y凴0+{7$JJ`sX;˱?욁] qq]Eqyb5T OfKSmJvID[:YW .T_9 WkA]|58*kB!=n,#P74ݖ2 [k"/itpnFI^..X|Kb}nM.ѯL(ѐ'Hh UFv;ѝCu@kǙUd't^u i$@=ىb'SMD{hO, ْEJRtETj)(|u_xi8'(ӜaYziBjUuհp]t,oqskܻ܊l'29ZPd]^k.i/s겊ee6Wte؁oڲ R SYd4Թ8H}b^aoUl)UfP0|V*rw"Y`2N//sr~{8++'8M vBCM#z7i+n|b4Q U xۇ|J* h)@Z >Xy',bFK؆Ku)i;RS5)lM2Wdr%dY3V/6' YZTֻ̯AȂ'Po32(s& \\)="< "d0dgwrk{ -=9ET޻ڷsX^CG 8I,rbTgTDj]Vi`S EY)=?k8;+'YQ|J2oŪ}ule9N׳ceL)|8KV\)̶B~#<US%d%ьTvF0%wĄT$K9V<[sڭ[jo?W䏳Ao jF$$ca5R ixAS@QkSRN~>O9نm\ٚF~DI5+ՙu}uVᆛ1y}]%#e@rZs281Mjr,scnZ {;a`)9(['"̘+=FeVZ6VywVmp[7Ykjwm]Ą\6WOnLNsvWuVS%,֑MG$W]ju^&S1A[$%A7^--.9+MC'N6ܷf \Nٱov k6_vbXvP`&8`<(⣄ƊY'l35 _"|AxW&&阭pҋJR1]ۛJ5۷[6 j2lg7z$.spqb ,d&~#(kFw8|ejL>Ybnua=Ddbo6;Wo֑YZ[+˘~Eyc_/~e/,Ξg@*X~>+[n#Gu.6޼{A翝O E(Pl)ng *h|K'q},Y~gbXW %-\+X|ǔ's%%;J\j)] ҇Jjvپ_VYvmٟ{//]co/bX.+bȪT.ʃP^sC%7FJZ'Hʋ!(߫H,Յ՛.bX.*c-VB12#3H/{BYJ8F̲/$\W@gz W^ W!^p'^%E%+%\P<$zW/ߴ R3H np. iuJ<^vp%2 *d;%\<kAV "> :_-zT*p9$g,⢜E\sqmD9<^rqQ".YE9(g,⢜D#(nT89OH}qy(Q Q´rNO3Fb2$C)jl$Lў8B%9A-bNdGډgzh/dX*DڣȧjNzp2Du^ҏP}(F45B{o[B,= !2Zytd8ӽWTOlsZOED%T^6c {iI7u8mफ़<)T6"I+/f4vHo VC/c7!HLG LwH^C8hHҿ(MH0x S;{^Ò IMIpLb(姭Ώ MG݆XF>fO^1Y(>i,D_R݆$IFϹ]NtfnȨ}RG$%g88{FR F$%2uC0*JчGK)Wf&@v(S9l%KQ;:M@۠ Q^io,Fmq3e$i棫;&ǩ|-1*% ?7[~D#T&ԧ(a/Dwh2#|Ѳ'H}3:sM>#d1e)zr8_Fb1n3|tlc8zҿ8Vq ڑr%hT9TMJ󱗮% Y &>as@9 﨨;}á`81·C' ~?o)o A'¼77CdD(87 ƽ8ბ1o'O`槠{`  yx;1O3ggOF"c6>m;6~ܳ`p h xɰ/ `( O#ra`0x~ NEG| gS}(2FD$r>A `h(F[#0O<#> jBXSkp2'DX? x7п70QJy o$oz"0RP۰r R ҳC@7@70(|;bG*HLv/XN#APOx3`ThFDc0e< #^~hF$60'$G;:bGM}u?t rxz@> "\f'p}8nUGD9;t 9Bp2͆ݓŞ̇_ §D>55U>m&51>&"5%FPȷ NoN!FCFQ {KVRؑa}j7<w/f&T#1aO|`ZQd{A=#]/mNl3,zP:ԗhu>ч|@<4zSb*Q '#-$$@1=x7z&rOxbk@7;-ah_}h }5x1&܄X܌o- x!"[b%6⥀ve/N x`qއWޏ`f1<`!>ŞF,%%g3ϱs P iՀ*BX+pK8ss 8W!(R|Ub%QnQ3Wjxj][ȕϠ2 /3/|ytO|}q8gg!Yd¾EE//|} ?b?11OȻm!?J y7# # ,I>R1LDL1HRlŊvtw򨤯GUEC 鐞L'B?)<@R3 O9 )̣F12cZ" ӡLTl h1\w%+ܝߏ{|BܧvqoM%)qqvQKao]+g6nB/m#l~ntUw33ؾ%{W Hۣۓ6OI1YwnT?Չg}!g=[F ~5)t/)lDdJL䇜&6IaLړc5Es3u0X;؆:Xٝu=(@kڝ}b{fMs3la[ lc=Y# ȥ#v9^iQgōo~5[a; `ݒ=;=cR? xB[3̩hwwc=yֿF_Қ)O)<?MQ({Z'Qh0 K(@w Jv"V.1>.gB=/`,PH;0N%,=k٩0<}V'pк}thofhys1a9+bX;ε!$SpnHP3y$_| >;ot!P+6wju~y kO d@pCy$$B۟Qŀ-iwG?Ob?ju..S;Ԥl<5g2v/p:Zknr_ (YphVR>ApSx3a Ek@\G)P JkKf)9P py]C>B(RQZ\eڮY%'5LB#fbDB 1%#f&L&31H)F),S,M)*"),Y4"#ň4"S2'Y]qnw9s=s3O2O'R}2<[Dg48`<[61OQȟFs>Zlϛztn'@smh.ys ͷ@gҼ\|Aed%ΩUG5\y@?{L6zJq̣柑73chyW>fFp&GlRt;iDpNÙT9'09g@_`2渓<. Rt &X#&>bPT NZ{S^YH_gaAP@ Y$]UWk5օ#uAǃ ~Sv͌ry$9^ ˈh9+ =![r`'pW;Կ7^>k*qؗGc vޜ9)秐Mqi0hM ji m!On߶{]~o/BxJ^XY`|u<ӓS:'N=% zԋYmFxk`uJɡeL ,N<84z'a@e\qYrtV]XY [t*p'"N<{  LNE$.PS04:w Ơ+(8L$IT:8a!=V@mE@]ĩ/;,3wBKJy*K'%YRL`ۆ>*V)5< jusfNׁ(D;Zzv4_y5C5\pjщ:-h)y)j*H_>8T3 JKyUu?Oc8+VGG0vb7 ln0-YY8jW!N݅w )I⺅!Ko&y43r sd#9$, z5p-qٴxUn ?Xd07"`|Ȝ{* wBUnJAWx| uN,<\ܑQhdnnfa{d>Dd!ܬ3e3 {"+ʝY$"E:gE)*U䈬cd?q(J#)Jgۊ콢ig l`a$pаU Ednifu(}FEsˋ\ng8@I^n҉%wbjXx8i>Ik0}z鱴ύʋ|_VwQx|񥻭b:.-yަF/K(PSF+Ip%EIT%M+({$*i$?P>+*uTJ= }E=FzBzZڥJTi6LKjhi[ ϵIZo WKگ}RˑkZtLWBPj"\R9 [bmtVҪоmtN{L[+i~wQ(k&==)jOkOCV9N|K-'h{ ~m}:l >g K>BYy}}>_J.--U|+}5j}uz_NMu.iKfPj:fjCV_I2X"_7EъI4vci}]|_(J{JdgĿ;sK4C-^  ?7E@s"WR-)"$MDIyQ].b&EuMħ!1_.>'ꉢDIO^K@5 #[ٕ(\Crz+7 O.T,^ ɮͮ>[Rj1){;-efewI+J͸vffG ҩⱖ#Ɛ7ŏ)ک?]h|ܵQqjQrWէz}aǟmiW!_ڇ ;kI ա.w(ߡ4.qcblxp-FƾVcq8H#q̕b7NfY㜫Ըcn+=J +rEsn;RM ˿`Æq;R'v"%'jkt?)S&zĝ⏔,E F%Ih&f(Hq-78LQA)KM>)?P#j/R Mm$;JĈlJR.G(ߠ/Iz(XKu։oz-~)'䤾#H^Lu*]UWUjp5\]ͮݮ~!WANjQ1ӘE:骄%#B)TZy_2Q]]$#ZG2Ɋ+(V6^LH]nW/a+j.#j L$:H1R,aȖFKKrG2BFd5T3Fz26S%\te"&c"RA-?WڸȴRV`̱37cG [Q0zkdw"_)q>pU=Tjv NcIs50jQnѭqGNwh>uiKity4gSJc W=\fe\7߽нͤfb&qؽl$t޸XsJFJQzܽ~v nsCQ^C:(7bu룖dhLܛ[x]Mgݻ{ȳ4?}FƖlliptF9w̹y@3y#t=I,iY9^ݧy{M]l'}cìǓ^3xJ⫧ʳHxhzF=4z<ɶjO3iis4RIFE=it#N5.OzUW7;ܛY%No7ūz6uzFtrUy31\Yx’ow[vxRwʣ]N,6kNk7Bs M!tiz&W{H>}{{{NS3oT1UM:jc8OԴqSӱ~ʹX(|2]+ 1y& (rRϤ 'LazrOTHQ@R&LI>igi_Z-NCtN[baMHeE,]|-_|-_|-}?~Y̿{k#u'~ggKnۈxZo^[ď%PC9BKy:e%s5XAW._d]> VkՠJ5k)YZOruMʷSnM1PAVm+RIkЕK9*]k~>'RN|e)f'~"gZ9˲ypF٠̤<O{F(Rg^nˀ #GD;K ex"G yQ먳;)78ώ&J͜vֱٱ!Gd;.GuXpG3љLqs^t93Yv95,us;+l9uRq^N8W;W;:;787Inu@Ntԃ=t`:jШ7:ۯH'''mSG0>e[IE|t'))"Q1"ӋbCiU. CUTP!TDw3=jZ(>a-ѫ'}IRdO.q#h%5eL+g 9*1ˢCȴbFЊ1orʼ K˭k⭥mPGDFq*~`K!HjM:efJ&u̡6zI6:V4|ācJ~%WhKBV(GUT$517c-==VH-jci5ˁnM]]ʨso}F:p怃R)pnNAgVg=A @o~,G_AKyi :?g!Ox02w7Pk -'Fc_Cm<'@QzFk'_Bnr^c˳ 6kڗI`vY?4iu+{`!s>c[(y[̰Ǥ?_X wip/]%2 U7bQ8@\X5eU7Pіi(%w%UV%J- 3ӒN!k[>ym{lCO;З1J@%K~B ,IT -2-۽_us1^a/7$''au0 Lgk-װ^Úz 6 MR^(Q#-h1ʻ6ʨ|>9u{Yȏ|L2֬~|D|`.?Mc}m1]ح~sȣ_;5oaE00:syV='5b`uΊEoa{ +e ױU_aosyӈz/@(pM|QBēXV4hnS~},'Ri%d>57yoaoyG5zqMi>{-x% pu < O|>I1uv6#Oƿo=HǼMX㯣u.vE D7|"{_=oK)83wYHĔۀm]?b?M~EF2hi t"R((!n|So>}d&lzw )|\d/TK MX3zB>QlXwmgxn!Aٕv7: Z~茳@Oqsq%Y_x@K^I>z#mb8@/ $}.p!`F4>L x”> %/^adZʏ+8I@O?@b *(?%G$A.cZ K`CFf`7;r~FqW>:#ZGv@)fVC=vqq(Ik\Kj[!AFcM_$ L`=Jś,s5w@]vʷZOtܫ 2ϱB*XeP~=(e.p-U[ ]3(}x 4f`.(A +cf<L79(݌Z9UgЙ=5 {Qw>&V@th܊?̐'1W7 rw@t%}Xϸͬԡ{HSg@R ~g*lzSi̖[N6_I \Wp? 덌yl~t3t`e <r Ln6Z7u V`@`DrJ4U<Lg "] z=~ Yt&|gsQiV3t+ ܊5;(ϴ㠗}Fޯg!8hsP֚gi3pRV!R (-eyu 4\@i|U7sfވRy 8[!% fA^e ҟP$Z\g Ŀ+M5o"t~ɖ7Fc\F?bG×_,UL'F[@Ftz؟ 1! 0=h?:,ZD@ifKb>Ƃq/4jX #RVFi 8裐b'j|`z=4I6v9V؞z ~x+Z 2oУp.Q^;4WCtX^/g3 f%,n]:isd/l/%xW öm6xrx (ָƺv tڰ&ƎG"pRA㹃mp:p?w[d% ~O`B a l :8wCxƆJ6@A?Zxy99 xBk~?t(Nx֏Vߏ DTw t [gTm>#/-//^?h,[4gi"GNbX,ޝ4NIkcw׋hO#ŝ/D,E~WÐōn k}zR"~,4,FT1Q."(E( *jsX9NċI-]"W䋰o)w}~U|MTمP`"t @0 % X\nn6[~!`E}Aiv;]n`/0:gWU`0t-|4 `\/,V%2"`%!+5Z`l|hEjp;y yO l_IiY9FM^$}f& h.48 XH+ˁ]Z-Xl6 m;dDz/ǽJx7'ɊWïO8+Jv(n3c]GSD1*pU*yx5J{iGմ{։ bh;."#MݢOX)^#Hi)S!yT*KURF3碔c]Yuu~zuMc*I$~9˭zluug]ZMS.ikL.;$JcnI.jeIӤio;EeS b#o4K_#&|HT QOZ= 1Cu ´;iEN7|$%q(:$vhm-f"J&$%*O5>F(ߨF/>í4R0ԀZ|A 88,O3%^N s\d.*2x5K%^Kg\p7,^rXj Vրcփ:xM Q'! 2P/ܑ;O !F:T)T!Q#dPjt BԌ!Π3P C]@4UAU@T5U ZSG#P:Fq8TLN@j{=ؙz@=]CJ=C5)SRB jRwPL 9԰+ uhui-z,ԧeiYh@АV݅i5Z ZF:Д֣`wڐ6f1m iSZf-h (qڊV mthCЖva'δ3}ݗ i7 :I{ްKBgڟ:@B/= ]9Ѝ 9Ѓ KAOa Y!fX)JЗee+CVUYeVNpƪ@֘5A"F`P$ER")8H$-+~ QD]N 8@JRYˬYEW3AAz_'O 3+C6=A_ܺOz>A(2B?nz I-ORaI}8KLRo@W8H%JRo0W8>Q$[JRh _NR/aIcI#GR_~Ʊp}a8'O)#3G&G&G&G&GdHHd)<"<"SyDI#####2G$G$?0 2 2o"##2Gd|<"x,Y#Gfr<"Y<"xDVY###GdH.H”u|M<"yDl#GGGd'H)ϕ]<2ydxd#GA Jb”!jZ<"GyDi9##rGH3H 3$9?y18ep+2 dqsəIxSDf*j n[0 8lVۙ8.f𛞩b1=2#8=140 |C@"*t_m0&d$fM38=t\` ԱvMxZdKKW:d|B[)1jg3`fzCƓFJ> ` )zLf&3n`N9,z%S1Vpk+n`T2[2GVcژ6`OHUz(C~٧ Xs\-;{R@Wx%,ìm  |^f%f[ 2lZlo, ވT !A%O)ERDR< e(0"\opM5D \#pMP77L춅N0K13}1cm*ƌ:Y<ļQe7,قHY)D[~gb.jĦĦZĦĦ]MuMuꑧ'Ok@֐ԈԘԄشѸ97q "r`V-Y[OpW%zEW=h ້NARUP]߄X %U BWoz!WbSuf V ~Q)+ ~iū Z &bwPL~߄r+`܊n@+jR@n+~HSbu5buubu buMR絈vv:G>aa!1 G7Sfb 5XjW#XաzԈ)ԌΠsUAUQT-u:FT uz@=SO_7;LӴfiYZVjCц1mJF{#ݓv}i7ڃ}i:O,d)a+ʲ"vbXc#DҰ ]~ 8߿|}kn#+`rJ ܪML\c_ޓc9_{ίf[Ypi 9a`>O}V1 | y}BQ҈ǩ 9 4&4 L3<3B!K#%b)]B  DivyAbG4S4q hbDnh/fzlIh\{3[ gu6J4>B!yP 9Wuأ}IJ_K qJ kL촸ȱtLºHt"bc"t\cb-$b.ЄȘh+wRVv>0&&Aer¸Ȅib.vbD,㿡]d+k ( u2J46TU{酿I#mz۾ҷ}}sҀuKB&3Iєs24G0}VGdg3ZhV-wQ=*m&f._=q`hQZDkqД*-zך0!Lx]`曭OPeRg|:=*j*)]0xiH]>l[ΤtΩtC%)+KOκU=nxglL0L'Qy DaS7S1ZNNQ42nd~?o8p}E/W> .%*bA3lǻ/ ^a7_/699 #8 wCL5ɢ^ +ڕF|lv8T;w34?Qi|X`w : ,v~JezxQG\kSnR{u~pP&J^x.I޿;\xgJh߻L7] mkb{&s;]?>OSvt(=Nj{E1sܭg*(TAdCjO|J pXH1Fg"PF$bEnU =6FA,* DDR0џL_[;96P>me6Ew^5n8>is L j-:wksx)riYWm_"p̰{][\ ޏ^{Z} kOY6OIiõn"̡vc-{'̜wJ{7Ug_Xmie+#wDf~uǩqSƌkLT?B:#?XX AlZs?9ZEZu';4CzYm%u[).la NK^S)6չKѢ><^N*^-h6exrg%XHЍTJKG6xQ,1dɜ ˋ+g_;= 'L?~gĐukYX*_Ptēn.qNl@}`Gw;9j%v*wit#_̈Pe/O{,d_vT^kފS%ks5WBAM Ro}6KZsʏwAWIgga=.!!2,nEZDYNZŌof=Cz_(Ì011Gu)wM1Ac7̶rw,~x)ui WS} :E&_4؍9?t{?Re%svܹNK^~Q`)glAg=LlogA֓6RWcM}[e4¨agKsEƟV]Z5xM/s]nn|uM?קg!'L%hgqӋէ6X8{Y'R[uyӘEUT^F_RErf6M8'VXm|Q~GF'FvTbI֚up۵s-#e3Ԏvf`jnkBJYO"(7=Cn ls CkOdŁ">l~1hSȥoͺ-ۄWo*V)2Ld=Ͽ)yQƾi:!et̄m /nsې>!]R2QsoEΌ?41իv{AuCʇ,^K_ w(^q:d?Ilccǩ:_οқvvZ9fVJg?v%Yno٘]iż}:ЂK"c#GWt΁OR$^7}.5|չܘ~)-g3 6^3sJR'iC?/eؙMnkvJҾ~b0Ini!V7| U_4:'.Α{6%GM!GLiu۬a.CdEv5lq9,~ӛ4h1q ?RH ק* 0u?,?Eᤀ CPnaU|찬`4Z>mm(5@W#L@y<'*Io } v{3M-Umz2QC'ŽhQխr)L#~K{(/|s8;('dqg;/=;^:S]8&%L@z\-gx=]}JXQD4jK=,[e>uAͻ~?n+U9M/Ĺ-Iwbځ fƸR[*_m%B!8Ɣ$2qiIKv -{Hu-EJSJ1>"#$3M1~ 8CF#@`{cP80mQ^ƌ 7MwFA tSh {d:9.kF&Dn)};pckv.S;2Pٛr W̝#^u N.98g]K^ؽo%Gα3x9Y3KtzG,>V02=MӕΒ9SgFVX4uεwws-m;NNV8dsXenqz?N8Vn74FIu]CS4oX#} =a$Uk/Y+Nb5DMBL9NԧGoݤzJP?Yu6 endstream endobj 2259 0 obj [ 0[ 550] 3[ 550 550 550 550 550 550 550 550 550 550] 14[ 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550] 131[ 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550] 314[ 550] 345[ 550 550 550 550 550 550] 352[ 550] 355[ 550] 360[ 550] 373[ 550] 383[ 550 550] 387[ 550 550] 391[ 550 550] 395[ 550] 590[ 550 550 550] 612[ 550 550] 616[ 550 550 550 550 550 550] 623[ 550 550] 683[ 550] 688[ 550] 691[ 550 550] ] endobj 2260 0 obj [ 550 550 0 550 0 0 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 0 550 550 550 550 550 550 550 550 0 550 550 550 550 550 550 550 550 550 0 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 0 550 0 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 550 0 550] endobj 2261 0 obj [ 250 0 0 0 0 0 0 0 0 0 0 0 250 0 250 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 611 0 0 0 556 0 0 0 611 722 0 0 0 0 0 0 0 0 0 0 0 444 500 444 500 444 0 500 500 278 278 0 278 778 500 500 500 0 333 389 278 500 0 0 0 500] endobj 2262 0 obj [ 226 0 0 0 0 0 0 0 0 0 0 498 0 0 252 0 0 0 0 0 0 0 0 0 0 0 268 0 0 0 0 0 0 0 0 522 0 0 0 0 623 252 0 0 0 0 645 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 514 514 416 514 478 305 514 514 230 0 0 230 791 514 513 514 0 343 389 335 514 446 715 433 447] endobj 2263 0 obj <> stream xx\ŵ7mJV˺*.rܻd08*:&z Qk(EGjHy)"@Bb;Xz޳f&4s3gʝ9wP )"Wa-܂[p n-܂[p n-܂[p ?1qI¿#A% z-hSd 9ԑfl&CdmjJȧ"&N62,RSL9u-SkoN(H š1-uR4rQT'ZI R{Өԥԕ C3sDL^qG:74ێy·|1O%q_= }I '[N[ji#kXj"ޞΎm-M zQUeEyYiIqQ0';+ݟKv[:Fˤehd| ?}MM|7YT sD=B2ܔ0/%)锔SI*q/,_}(Aa/T3)&~?W3׈S7qLud#k =q E~>D)HLgy ?mFdgO*| ekn9~W_vDzp!@?4b3oH4}6D,lQc]C|Qst?4Y!wqx\YOx^(䂶KH̷\*Dh(< VBK=Z[PHo}sʁZG1|ֺ&ϋoT(5*Uu|a05_ Oh} )T`ϯ'"b!廳)Ť *(D|}}>C\gook[{|]"BoGIƗb(Ju0D F!<lݜH}=#|x3-7\R/azFƦ9q#CM|u#HCkwd UzJfgS{G]u.YyTKHھC)yC'hi^+%uC@*w<r@e^;FA'M(vF6AǢtNnr笾M#}"fJPQʷDiߢC-VFQWjԋye84u T8( _glj7}1煡dY$* /Jmt1z`_y%k`& $Q )$@| C_cܯD&9}Txe -b"?A7xcL^+#eK?Ĕ/ #C13úD}?f̐)X%Vs!2 v aŔ+hB||ZF0Cv%@Ӯb)B#DŔ *i p MO|W;/ O5?|YX@>A~qo@ /A~?yҽwAy-T?M uA^y¯e@^! ~^**}= gTӪ-TO61O܏<r{L9~Dr!AC8<i rȽ Gqn~[qN~@ r 7r"}=7w}- ׀Z}\Wov_.}/9IuǔN m@٣Êbc3~N/>#|}G/&苸i{{?FP{=Mhx00>0f+ dM=}xjrg ;à [K77n o(]^?.tMx?texe}RH7 vGËA^nm 6G 4$iDiLnr({O1==5JМkn5? +iШ*L3 _bAp+pCAsN@CQ)_ ny}L(c֨sy(?eQEp^H5DosF=S!CfRXkϮ@`*xڵ; | DC^v0o&0`.p;7wի$2yp/\d E e y!_6rg Oj'N#DL LȘH=KsB3N}8O)XOB^hH:NWb>L_~c-L5:-0YB>At.NVd%zl$fVl';@6A2Dvanq O'dgg9`MihN9 Eb !K?/'WL\-ￒ|*r55& Fr=H% [휴|L-6r;SJ ߃1yFS{< gɻ= k7T*'OXX ύ MXl\;C{+)R^q<#B?%S'ʚm/M|ftƒӚvͅflo4sc[v/6ȝa~(f8/%^s&G'Zp&#dl: fc&DžQyZqA>yL?KUEyH~UZow# ayODjJNYky/?V,4Ue>;;J+L^c3'rsы飔YznD)B2m(%"<$[ ߉c0?~$u,i"yԘBnR9+v[է`h?89nv Cb*ʷe3x։rrx^mjFUN!MFO\\MfSlJdgp)VVYAor]WSWZlA蘕+u2kPk*|#\(~a1PqDcZn.EifzF2&QPZq]qf' k:;cZQi]FA'}Hse)naS#yv)5  pV<̓KO]"+֦+.[X,9/];ru+/#&w>iߟ%]/lB|כ͖f1z]UcOqYhK{-?-VD(-wXSF姖l3j/Z:1hLKΠl龣Z/e,gxNjέvߓ*, b&?×=FC;dNkzAB:F)]@diN6gL`aa'(Z~2Llh7O̖,w&M4ڵP~pEESu˥}}Xѡe/sk@`ަS컞6.t˯tzV̀  nޑ ]Ҵ h'&䦹V JJ˒ʒe:=핔&ci-IzU[mG9I{bo[^=! GOaV#k%TbQ3JG!l;+漖,]v _Og&`qYShK*SΒV7>߫ϫ%[k깈NՈJJ~);%yz_ku1Ph vn9 QXv )"IIDҙ^tl9ش6Z،ǹԸ N.lLlMHϜs31S, J+[ۜR-YYXZٱ"[MHo)rJzLq߸œѨ^˖4yGUGr=g)[,R=.ܛ] K~%:ꗜkf%7*?p蛚?R: [ָ.AT _uzK,Uh1և)؞CbbovɣT.@UK{Ab2ZQ]yPveRI$*IYp*< WNmV̹nX,*au&nuR{Io2Na=+M-)嬁O0 $`Uzj+wٙ&)"=Z8V.༙*(t&U%U5ۯ I$4 XnKSv4>'?:D >i] 8>1Sd.HK}nmqu=ghHʔ)}5Kk2daŎMIP/wkV;ҽA#6n6gMmN_7T;ٛ{~϶فWնKa:Dao!/ǖRª)dEc\Y&')9bWFM6}(%<8Gӗd?|oʼn+ϐ''UduXEÉUIdUɈUk 5J秆f]& (g'fN[sdW"{[q$QTeo(\^7-.}8{UIN@W $9,h^34hY3SG'a^e9X*RYU+^eqXTVw4;Nz6Ys.¶ݲeZN> u6rI&6}Q,+WCW~5l{zf֚¥{;MI7!߻exg رlJ$LRQVNet4%2 ̣D%Bhm2C͠*`q4:6Tt|.XZ\^"Tlgr)rgF[YH"D65A,@k'` 9B4#t$#q"F$?µxLm&d2pϿK8?bT?R4.;@‰QqNȔܺkQʎW/ 媤Z,*\]UQh+XQT.ceBl{=fh ҋ23*z-SJN)5rȮf2zڝ=9JY!-sHkY@TV#)% ɭm*f} x4G9\L\V˼Qe ;>_8)NDw[=} Mh\j=+:ҝfTԓv:hY_+ ("*+9(3:T+2FvY%Bl-h/V:=5u\ePzoH2)%oCyn:{1Ya%yy()y6_e #欣]4$5ur yf8/&3߼ vL\,JwjC+Wd,C,VgV}Hm`MV.=хy|5{} tTչsf9'B/% 1A)D &$db\kZJ->jZhTި1FDI URrosf2 vu'gǙ$3%\o ;\ XhYwˠ?0oIc2iEv}bA:lcm ޘLD'#qnq7HIhwR* MMUbE5M+5ѕ+ yn&",Jv%Sm ٹld8絤8'KόC/4\Ը̂= <^̏Ϝ]4(wz0hQ "0p~{V$pyy/K^6 Y7n#%e&Wwmr<8{->#5=.2Zғ?t)-13Tkk˄{/`3rs^om1f͜)fΌk/_PQ K\ b5d)fK$yW#?yT0[\zQ<1l)zl~<%l= Yasrc&%a^QH1t' wY O2,V?,A:D[RFZzV`'8m&uZK*M8}>r Zgh1^%ށKĹͬ%' )J>f;elW~DUdiCI#FSƂwt_RJs3$iCc%ZgQ~kⰴ1£dˍQd,&[Njl r1nvx>yMv8-SZ%gĤI2,5-3(t`:r\xdqZ2 §>y{7ھ9FpYbrLJ=+{i5;S0%=,G?x I0H:q4 fN0=5NsbCӳ$ FnD>zЬxQ2*]g%'fKQ2ư1GKLE+`'92@l$.)͋&F[8Fswb &5B tÝ&C-; n1!%%}/{ońzcĔxvdk 'M&˖W7d7=pt9pHwkE^Џ2dGX~huM&8WԘ5 Ħ}>ou@Uwˀ Ȁ Ȁ Ȁ Ȁ Ȁ Ȁ Ȁ Ȁ Ȁ Ȁ ?.OaR :h VUjҭHx%6CI H]=~CNL8x:66җt KRr iچ%oFw:~߭wz~߭wu():|MV6q[mknm㑾D,H+Kط"mR;24+aneN ud+,騹6ayff"m'P%FnEMbM蝥bMA}ҭy,V]53!(󠆇s>*uqUj~Okp럨W+ /V(\_?{K<)\Рj(c ﳂ.Kk%JS| uQ~qN%^ i^|,Qj:8Q X~>akkYO5?m b#FLEܫqpۖ=GĬF׹<9kq tGۛyLƯ%j=2_+ᏌFLS5 Fy>%77J}20qsSO16 Z$ӫͷς SΣq[Onez#YTkPWfu:nHlk#ǜZ:MWO,;nv_h<Ţ4S/|6^1} re֞K^ie6m, Cռg|]sH5;{T[ jTW[󵁍"Yy_5/zX3:}'W獛jjk*5MT*3^eg`"P_Q{) xOV|5j]]ྦྷRt.Wj\(TVuZ%P* (Qj}n0(sgM|uޠujVZoFڽޚrW<>,x TJԳ+: V gEEsDsWV0xwp9XKaۧY7и %5ِJw\@nS}bz;$MZ7/(^iux]^nZ ^k+xv׫u>i :^ Х u{W ~ ^;-:^x]4%D^SZZ^wO,x㰂 =' kT^eu+xο>^O gtA\I sWlݒE* CF? nďl f*[!wh!>r%* ݲA4QQ"4LN-.=GB#"Hf ,.)^)s|-J(/=ReN,"C ,!$2/M ^b; KŤ;yJiBNy?Z-̮9÷"D$ l7* !yHqz[g.,Д5-)Ѵ0a5Cf#5,_jダڐ% YsRlg —IC'gMНUP@ ‡L-2 NQB3Lr;az.L}?C;89E J+`. ;u%N*+Q^\Z{nu:djdYWX<=v7шњvسVZJkTT@XD6?Z:o5[YLD !׊hR@v|j%Aep WłEU& t/9=RpUKxTry%Ą+-v-Lqum~O%&KY'M{W͸OCLRyK3i!U6l*;-v^]<}/TxC<}yzbsRӧ"^f>] Y!~s+3AI.YC&; |C3a?.9:U{]SdATۡ{_a}}.)KnkcYS u&F s]Ղ&mTybrQa]Kr4>D5Pso-oZglmw=d;aXm:8\s(llbv?ːL{NEGD$ r8rbNr6J8oW*/%VMf]# 3d&NIXH ˎ$`גGqYүT&7Fg".!'OEI/#) jLQRS}„RSԔԅ[RS[h=z?}L=IG4'ׯ0 %%?#90swf 3w [8˚!]YOBvX>6`# Y?r{F9!Y@cSg_%iu|'eÄ N< T|We2y{bY\z~2di횞3s vN^kVp7W{mNU2[:t~ ]+^;˨y R!lwa~|e2oQ7wTk'͛{ \Wurè&[J'>_~-s@X>cy133UΪԪaU&WͭVWVꅪUGVԯx`S+{Eo7;ٻԻܻ{'T_o&6C|6VgUU/Y3šjk^igKOݚ_٭KnuH_JPz=}R﹠s+Gx?Gllmu0k'ɣwRMiQ5}Fa9i^l=3vsF5kk; =n5 kqXVbl=euYYyR)jlqXLs\zV}Vm=kyjna/Y.Y+u+^6mFlu?Z;mV+lSabW=>Si^~6ciU5P[]yKU ޡ4'cIj+?n~_w$7bؑ+#+}lS⎞]A,;X ]%cr8ڒЍ5e5e46s4fT3fT1'O̬5sRObTYiԬX=,s4h{KD [}L,J{]D.mH.x-}-$~=)}OQr!JXkRfgvjpX;kLvಘ\1ųӇv켢&MLN/-SZɄ^Zb1N 2 d+;S:jj:$)|\?;Ѱ d;;slAp&zOB c'%es5#>:_Fz^Upӥ3.XhWDM]"#,!6!^$W]m M=FM۸)1Kb@"5C~^ { hھ'-!Mh)BH&-'vġT,.BĈ6ԍG]ڸ?m@;fPg~tLh+rc|ZQX"|/ yŸI1%|:Tz;Ddv[wwAaR_C[iԃjTO:X VYv:!XAN`c`# lHfx& QBg!SCGIFiDndp;* 1J}ݸx8H#Q})S}7"Z}]- xZWj~wQlT_&4 ( %Su@K?C6$]x-opp(Lx}+CKIᓈw d"YD2||>_E]ۀ[+G!jqNw ׫kW 6Cl/ q/A8~.|Jnu IbL ۆ<G MCWRu/Ϡ3h}Z֧ihM֑ :Zs5+ h;0 w]}%?% { tA:Ԩ3ݤ'AB迊zG@&y3l6IzhKPQ>Q0\Sz:N)䠗*2D/Hh?Mc;kG9R?'w m6?6]`zZVm px8_8'C#mr3B=N/+u\DIRM Z0T#Q}獟_Si p+9pc7{LIҵyX,nPKJ Z@K=P6?CBy䛁6N_I_p8Sߓ'|"'W|"}-L=A=#x$]Q w"qJLbk*\-CԿ"EF.R@dv 2;Df"ف@dvv'"<"<"<"<"<"<" ӅBtM$RCLQӁ@t j:5DMQӁ@t j:.x ;x ^:.x W:X<~V?ê`Sh,vb+v|ƶ %kb^$N!0WpWamd SSSSSSSSSSz=u8ᘯacccc*kkkkkVbϝ9zs#$K{pa؃3+w]w]w]w]w]w]w]w]w]w]w]w]mmmwooom/]/]+]+]#]'m']'cat![V~+b#Gv~;K*b ފxoGa?ua/ua/ua/u+l?5o?ｈ%Ċ~H%e_BulVnvbC۹hۅvKqV[݉|5}ǹ&]|h*,ٌ?/xڅS@v/Ɛt> l&$AJc)O[pla(|sG8m&4p?NB&< << << x xx-$;)iNY9//ޗW^7pZY]fy1c z̔#1(`40N=&& ?~,]LG*`VɊzJ20 d#蕡W^z` q|egS 1Rc"Gǣg%, O8E,%fz )"DH"$ IC!B!i4DH"$ -\ Z-h@KZ:ҁt-h@,Yh9n9Io9 '\s !&y |||dQwFI%ktH'ىDdv"2;NDf'"ىDdv"2;NDf'"ىDdv"2;NDf'"ىI(((((#DaDaDaDaDaz@+}hRhmE_U?36׀ׁM000܉hwQ?^Dxm0SP+"߉DwJ9g  Ø 1/ow_g]}9m e- ʾEQq] "0:gjXBӡ(j,H-%5mH,4I49I9}2՗??>g~DЦztCn6REaXWduEVWduEVWduEVWduEVWduEVWduEVWduEVWduEVWduE&-nǬТCZ1x/̋Xx-袬.lfơl!70:EgLks2c~N)8SqN8glsq|ǧ\s|b\Kq.DpD ?l܅nſ0!Ѩc8XqV&2TLi8gLs]czuuo,l~x{/bc^NвeC^1ȅ /'ꕉ_׆ޱ%óſc~QcyuȊSW{ڳs"m^EO'S&Z|" &>xqx'qIX WθϘQ x؄&lF3ZЊ6va—w]؊n`2vِaL$WweG$>ǜГ'跩zmw)"?5 =^ƫXz&=yxaՕU]Y@'>ɿO}'>ɿO}'>ɿO}0#////////Kw};///////////;鍱!7*Uuw1c4i8qL1c4i8qL1c4i8qL1cr1c,Xc9r1c,Xc9r1c,X@/}ojQ!>>>>{[g~U>ygTU~u/<3:1HިwObG;c9DI=Ai1PCOXVb>=⎹~N:/y΋u^\l*J+-J+-J+-J+-J+-J+-|)_ |)_)9ΉuNsbO*zXUTUNUTUNUTUNUTUNUTUNUTUNUTUNUTUNUTUNUTUNUTUNU}1}GCOYJio*ܚX~ėdE&+C:99 $T+cсɯEr7ȱ8*M;Uq5mשvI&6;6OGjKxU"w(<3&87L6T.T<*=~^Q=_*o{1؄&l~;Pv< b7F!*+1%VÞh6TZ*?~šrm+UYvWnvt?DSt'ECj6Qs~57PsbQAE]E Rn6Pnr(D& Rr;)r;)7H! QnrM (7D TZvQmz(R(B(B=AA,R(K,vPhvRhBCE]EltlbaaJ^IRNthf?< S_P[o%aM$Wε1r'}r%8PaooB s͎h mjH d9*vn('q/yNML4Y/ Cc?m)oOi)=O=L "s^TI Txϝx_ uŕ |8 sI=i߂t',&-*5~Φ'kDjJl֬<Ѡoo[T PSr4ͦ~s\7ͥ~sE3L9?Ãx<|QI?9hNb[o TӮDכB*#fvvDc7z lG_t{9xĐcpsbrĮp`Eh"טk{ğCx=9 $1>ܜXQ''y\2=6ʻʻTU:~jZ=/ydx"A}GE$?x4 7邛t-=?'I8S15|̽̽))O%?O0;IO07ipn.9/ãRu:R]i^j^dk_z q8'e ka~ŢPWZj"uT6GͩXu؀h@ctd&4aϷ{--wz1؎~dütns؉]*]zv*N}<܊=s!7U&}IuU-*OT赃puCJ7tC~Gy׏+ WYי7U䵓q NTqY8D<| Ls/ʋ/%޿pIsIsG<9Wp5|oV;V;o:߷v=Pz{Oڍ^50>:וu;&GimA:=r<=v0Y0pstIrI>^k Ze|Xktw=n[kusun[ukN}tY.[Sg5霷u+:j7qDrc½7u+ͺ̛/-&rh_3zX{a6{܌ְVfnY_2ˮUڹfdQ{ؽf̠v#mvEOE긱:dX!BnB>O{ir^]W{2L.Bnx*bhѧVˍVˍV+F>]i|FWi=Vi.6cQûd3vmWkZ5V]_;<_vM3ksEU+vwZU* jO߫6S{* TKj,AՠQYQE6;jM4)&ӽto2ݛi'kj7Mޔ7MzTo2MVS3{Mӳx;{ʝV f`j6 h5)Lӱ{MVӯk2ZMzӯk5&_ڔKrMZd5jZVoM&Ӭ47M&Sk&Rѷb*<-L)h4(&J#WӤhjWLFѽFi`Z4 Ei`Zԛ&EIdR4&EIфh4!MF}AHtmoLVKu yPź&L11_fXWu|u|]1_hV U^ F6]PY/h)h)TA贔NKiPǪ}J/yW_ jfD4#MhE1">wE&[~lJK\m\j wZĴ]5OؕAwWpWϻzGTnNJMnvWnn:mfcӹd}fOܽkƔN;]}~ϊu{6(J!*kK͝[(bi("y@MS4MO Ҕ!ebC:ZNNN1.jZI9E\rMDsrbﯩ,ė_N<9Ēn1CqǮ~캱Ʈs܎TXMuXg.wݮBͮ4jw˾#67^|㋿`6uMX]}6ͥns\6͡n3e,j,6K͒n7 O;E0o/'p=r۱z3VQkPkVV=fgST{J^+FvR)J>.j>WZJ+JʱK]rr]]]\+ŗP| ŗVwqKD8Wɻ]X}mo~2AxPăvD9(A*QmTnr(JnnuۨF657*y_sC&{a^^Ut*:Z| ڒeu>lG!ZF~-$VQݨn}}J7jg)\žת3j,fY^k;WO擯E2}jmCxQ<+J49PVPPp|G V>Yv' w݉܉܉܉܉܉܉܉܉(Q t S{)E~J^J[Zw~knX9TeT.rlw3 \+p߱M7nUq w )pW clrlGg:Uxœ.9srs;99wg]Οs?9>vFq:9ɹN.*phBM# o üJE,G=mrV#g8U;;ʋ1vSbV#*c;uSLc/tB;nEL=ۆ v؃wb4eI8TLi8gLq OS8gp>B>E\q .eWK7F{#,2Ԍ{k6oÊ ?_ 3Bx`¡ Shʄ#p$>ȆM(x7?*9-[qnǬ0')%Q4Ldzpv)=_@鯱b1Fӥy4ƅ*)e`2A8P!29ɩLNer*SGpfew?cj&o"'~=lwzaqNI82\+%\i2`g} U|;rle7܂[q~UϪgU\܇_~CP3 j5~A_&|:ΧϢl܅nsp\u'<8Gh)8h*WLLqTj8j_ ǩq*p ǽEX?%,ψ&'"s?Ì%ertH`?& ? 4yC]zNthrSttr[sT {2I^ѩɬ@tG7܂[qnOO1 tbY1}|c4y&4a3тV]#-Jg33&Tc h2laL/QK%D|Tsχ<^rǷf c1C㆒EKf.W J"N8붔.{L=fG4t&T*_{}VEb1Fݺn]5RUԗyLt̲D4죡c8XqY&2qTLi8gL<\*{<_5aEp{X)_hrlDOyZr󴜧<-i9OyZrw]؊n`2vh!*XQVI x؄&lF3Zцwю4!3\r4';ōQ23vO1:֣&Y/A)P'.Ǥ`P)8'Dq >㲐 dvY]@. k dMțMțMț!nO G3wQgyg73&Hp+VFT<ˡ'b犜SЈzw t B &қzg?ٙw63{~;M AaӁ@t l:6fä0i6L fä>Lä>Lä>Lä>Lä>Ls>7Ms>7Ms>7nM{$7M{$7M{$7Mԃ`A0 |6AA |~ z>V}`>0z'o0zFq=a80zFq=a80zFq=a80z<;Gyhyh<4y5MĬ`)bxo ^Gs@?W p^ ܮ;;;I[x oF$j4MF$j4MF$j4MF] ^9U0^olx#o|7jIZD%jIZD%jIZD%jIg RlAp}p}pxA(:NxH.FU'P <߽x{#mt6Ga'\OQG}'P wSn>$o+Іځq9ށ =Gƣ*=JO*=O{/^#>#>#>3ljT'7\VNh$Z9VNxAxAVo>h$z:N$$:UDc'I4vuuvࣷ$z;N$aaaa?)5151515111"⨈8*""⨈8*""⨈8*""⨈8*""⨈y:88U*|TO<}`IFGmĽym _1(a;CĉD,^C&TM7`jGV|ԊZQ+>jGV|ԊZQ+>jGV|ԊZQ+>jGV|JZQ+>jijܝ~itVOquxĺIm,γzk D7vm.lߑc%r%1*WbYkrh z\7+zZoZ i Fkmh-Kkh-N3h>s`Lz9N,Wr~^ @ҋųBҋDm99f9W!㔚㡸Vq}Ec3=܏9/ħijd+tk#vgb- ;L4'){8ޤ{3<־&Βr1<)^3B <<#i)ӱ :,Izj-+" x b  UA{HtՓ`x< A)4x^*rR""*&j:.&4Gh ZG1 <'9o=^/`0D@B ˽jۚrE˱2|ܢϑړ[˷mvʲ5rΒk]׉u\}WN|-_Ĵdq|gu~ x< @0\/rFGc % yK0x0L_9z3<0, A,TOv%{q{q'^`'x|؟ a{*|mB+@wWslP^%>h#ujZxDOVlUaj(K(=ٳzG/"/y2ҖY:?z-E{Ew؇c)rtYl f` ` ` X `+*B@R^X`X `X}ͼ0~&'DSSDZ.eꋪi(<ۍ9քc8֜kɱV؝Ԧ= ߩ^-] 뢅՘&7 !#\zNl8I&:9 M7HoNdUe }Ma=Z_DҵɱK9ߚ6W>ץK#%cyq Ǐx37'[rY$5RF#w}gCc#ι1y7s$yPNKbt7׵I?+VJ?jҏ kی ҇!#+Bn:z^=暧{m6cjb9J9XP/ VفcLQUG̑ĺzaMNm\6\c m\6\~hŕh4&_ҏ _SHhh /d"2Q5`0^m{gLT1Lb3;w"ؾ}'bNx2.XjJR*Rj}RL7Ԋ+l=hD;-%:{;qxZ\D?LQ1y1U/|DXcY-+j1Vb5ڈKbuuXduV̺>/z[wU} Qh=m,ʬ>Qk(: ]k[㬙V}}>>jj[-3,}}udm_`_lcw;[m+쫬lufb{Xڽ[[[]V~, =~ʶn/ۯX7oY؟ؓ{)|oB{5^k޴Kwl4_{nk)-T2)Xbeu+O֖/eS̚ WlmM67lk}+i$y5Cٲ<Ӛ+ϖZ dgyH^-XKeWyRwZE*G1ICrnOV&r\`zo#]߉8vss}huu98Ýg3q 8kmdF2ᑪHHm*Ha$iF6D6c#EE~hll'F"e7ZTWҞF܈=Un{[ͭk/tnC6s c܎vf=˽B :>-Ϻ3/ɳWWPy/y;&;#Rw;R^~~./wG_+q8y;ɝ,qqkݹ\͝.׻Kݕ&wZuMv%U }:F>ک);u|I./rT])_SרzuzՍ]uCSw?U_W~WjROyZ˩*G%??rzW 5B.RdXPqY|ZvȭJ{sjxN.n׻i9^ON{{i>pFz9mq8xo7iMvN{3To79[-t{K|+vw6zsEOw΋vvpΏ=ù zQ"hhge˜DKE9F{DotrsM; aaNGG΍Ob:7FF9by<ظ8 Iέ?d 2993q ˸=c3-caƚH2߉\O\wG}"ᑷQ~nd珉" ?G E_Y~/??DZG "h) u#FAHYpD4RpE*hʠupgՃ3ݺA'ApAp8(m\\6 ݣAwm3=>zI$C0%]0#,`{QUS/*[\R-"hZy@ QɯLR=~{-]@%z)udu@k:|WC Vߧ˕.ڣ}lm*VO҇b=C#v9`}iןͧ.#f>zIҎ~sRiHO]JU:;+A01۫Q{}{ܒWz^-_I|5wP[(rgߓlY/s?B_3b~4mX1?Iݛomͧ ֻtѬlONUqxY'eA,z/$.gsyޥsx*|ѓm3)wV2C)Žhٷ_cD8H } e{޾ӌz9&e,*k=bm=v(}>OG鿤wA_gϋ3q#N03b> b3i_)?E?N B^%#^+zdKAf{xnoφ{KXZC6MzyxE7WQ(QGjGjiXwNq3PR1s¸K .PuS׋a%w$VqX]bmwdwa%q('l "^WoY0qU5jja.VwY-vXmbe^WjYݽ^}F5nZzGYwxG{Zwzmv^fXMͶ %0 cь?5[X* Ial` c+֒06" Ual` c06ckcXCo~μ, [ev˼U9ʙv8Xe,bIU6);b>=5bOy/V SE\dy"|lKJqj*ֈ?i&~[đOsU-D9YXd#cXo,"{إo:vTԶD {/+핢 {mh쵁׺^k{o쵆m-jHڬYD-lWIOԓQ츦kn5dFlFRa9˜a;:kb8EcgYTq8eoaFod.S u\8 Cp )*kյB.u#'({=%jFKF8K!uc&1{TݪnUvB(fFQ53,F&#QRS [W??S_iQ O'?gszv_R9rHyUJj(y^W"M&=yKE SI=w)5L #}N=#rRHL}A\ureƩ$5k2YMW3,z;[ũsZN*Wj+TIqZ&%Gڨ6fj&U*mj-nW;VZ4B1vgyhٞ-,1/ED๞+2=)QcQżD4 ل5l6a MX&aְ k؄V{Yf;ᄜ"SL`=16IT EHF~cMDՐeHeD=X-jLj 868Vm8z\p ڊlDsJp yNNg}A~<3sfp&G 0yw :(%:,v\\.jWW*Z#kp=5n3& nϿ~O=}{p;`##eUV BJ P I VȆBl(l(X9> _fUxP=\| kp@)&o·_{Wkmx̰XUoumz{Xd aI:dɘaIϰd`8]d!V3 gw]NS$CSj uq +`;djvvmحavP媜R!2Wp\4)L.|g۰RlLlbcYOM$8(BʷogX\؆Yj')USD5#U ԀA:}F%2sI jpap!)ᩐ/Sta;d 9Fpsp3[!j#j8: J ֑? ;T3` qv8S\/5y+; SDz"isu9_/%&^h30;=/ֽD:&G-=w޳_nO3{ͽ(v[]+ftBR=[/Y6[(HGϾ.Zajbb=s-Uel^Xak;s3KPy4w`~3;I:|^XWc9V8?R9k"קfJrDK[*~Eo/z3jffw9`HF+eg? EmiVi{ie}Լ(Rwf.2hQlgI22#8'7VO_ &?i'{ާ<77]I$G;3xK}lƏa[Yϯݟ~{{S/-KMrP֏ԭBU V[1:"|H5YC.WޗkJ?},HgXݟ&^uyߞsA{M=;|~276%GwShn¿ɮ==<~/=ӌ~zZzܧ =7<8.ytևyb')7vgKٚtwVE)>e67NO}΁+L*̕0zWߧ_w^V! zMƕySZ,6Vϩmc$ Y2J|bpPv?|nڲ+cB"n/}T~2531w.3QFtG{zǣ﫻}sG+/_e.x!I=f3%R@%X@Ꮓ_fOs!z65;bbIqg~XI~^oE -[)z] cUs+,z` x1[/WAA\A)KT`G^~,7-o 2:,ěN~F-8^[tIox`3}M1i/Z7k2WLmTqjK[sKo7ۅW!sNzlgH<*&Z6yp4onWV{]v(PB^yG3`UFSEZONϔNJ aAC~{1ŬGVw#u2}TKobS*rA/`bd'[Dw"ޠqVS8it]j]<\ԯ{fKou0 HQ ""1Ѡ!XcFaT 0gtk=xj(cc1k8b1ZczbOo{sYka[zZVשe|x#uϰ+mx?濓K_w yT׿zh;_3}}x^ꫵ+;9p5y;k6m"_qIDwt|Vy|^j b?CuX'~yW*:QJ_kPA||voPz/Կ?W?X)Ld>R[W?oW^wԿlˠkMG5_OW owUa?*{f?*lk_ib:Ol2wUa''a"ְWEq5q!L:vevZ|E|;#];')ɺķ3}w.usO.Rz ˺D]"Pا]dut3].}tuf_V ٗw>%/ܧDPO0.#$S"L$B&f h!;ܡDx;ܡDx;C;^xJ"$B5w%,ܕDsW]I-ܕD>w%+"w%$YJ"]I.J"ZVqW$%J"|]I+ܕD]IܕD_rWܕD]I{ܕD+(sWqw%+]Iĉ/GdUV)9J|T.ɣX1Mt9Q'>&O'3Id1Y5D]C"rq.w  bsqw U~I,!"|X|;K wYY=K\DAD|;XʽCD#M;D\ͽC5;D\˽Cr"Vp{"ڸwh!{"@ Dl^ A;(^{.^ m3:•(u nw. ,]@t9D]@t. D wѭT(Wt DgP>W>/ۺ2[˽@tU DgSG#uN5Vӹ#N :w5p'zT)WWC|`>}>6X K&ok a܀kY K$pID6Y",G(S%YRIɒKe() 0iIR4F. 1R `a1ƹq EDi9YJƹT)#L&di2?"MEi46LJҐ.Mg!R1)ϐfL)͔fOsgI0Zs9Jqq'3z.P7񜟕׵B*e\}TTHfS-c]ːIn\#il|!^RԀg^ 4J1wbM&Yڌ'}GH,,YlKR1& ~*e) ,Mjq[ϥV_qfb(fbk! c|IdޒN|VF==令 ]HZ=҇E"/}$}z^̍W+SSnҗW 忠rSve%,P[ 2`\Ir܅  bF?BOpu63`f`1$Nh$ (HgžA{iR6<,K [};l:آ l|XQX 6 ,"|gN&0h ߅=,S2o_ebYEXĝAɉM DDN$P 'OHIib*?e^fQ~}nUZ%%ٯG_*Dar}~!f@9"D9Cʗ[ʟYr[PDKqpR 5i C&ZaIXx+:ZCPUqlg/b^'M$NcwTjzŪS1" K|Ƣ81|Dg,hK'%>̤ -xzIkVV$"DZÈ?YO{Ci0isaf=aD{YO{Y=zri|<0?A{i󓴇y!aDaSPHa$_:)!,g|2fFȦ 6 Xh@~3A~hW.s{b`_  Q|O!Ma:b>%{$1eB.!e=DFH"‘D_`C)r#"ho %/~PwqExIOO"vw'x'}hI_Żhޣ{b?]:A'~':hx<O Bf03s T"(],;SuctITɺ] >եC;C&f2T. T9~xt17Gng s7n;CB^b#>CA3@̐7BNĠsؗ}*KBfĦD1D }JD`ϑ9333s3\bJ2r.1(E)%Ihr8Q\EH1Hq8\B0p.X1I8wl̑rГS\?hO"“E- JT7.n8pi͔qzː~,eJ{=snFܖ-\"4Ė)$]#n)Il!d^fJG#8[Ǥc8u s\:Lm4FxGZzWzIЇ]:Lb9Rԍ8e$›EK7MDG?>8I;pK'CEThX(СQ1PN{3A{ hsΛE: ioD{9DxDxO : ͅr%Λ1{J zrOP=A%='{B>'=A\s:PГJ Cay(,$P!=y(CAO *y( yCA%+J 1䡠'<x(CA%=y( !PГJ 1x(CA%䡠' zPD *y(Ca zPPCAO *y(CAO *y(CqPO CC P''Ca!y(Đ<擇B>y(,|CAO 1䡠c`1xQM,>[+Ly%˔j.[U"ol1z쐿vn(9Wbz&ߠc6y&?S#9ϒ__3'C '9 6\",ȯ_˿f9ȼ.)wbN#ȥ&>S>'r%ϔ/eϔ??FSS\b8L R2gee9g f屧gٴ ++@[ VطПz a+VaυDB ÊÊ1l v`7{h%ބ̋/6Ѓᇡ5c0f &׌5!rLiE57 2m<2([D!ʡthm0^9 ~z` &`%+ەJ2| 2+o9%@?wA))? n?!F? ,UD)sT3p# /l2#DOU;_Dr=~6P)EUR5MTñ6L*(P#!8E UG#Г cxVhX! a&Gh0EMVqt: GI 9$%SԩpOx5MMG;$I<9I<9&Xu:]NR^' |ud4%Œ(rK%Dr?I!du y&-CYYdJVW()䊒H(I䊒TroDF'oMm*b][6"d`A8n`1q;b qqqщ888A\B\E@bO`o=bcE"(11HBWs(xUE7C/^^@ϵ;ת@}zs84}>-/>Z+>nd@QxW< VM6{݅ǫZHqfu^+h*‹sCoBR{q2 H]cvn,K]]b {xK te )oo\ڨ%d=\-z-y.44[@uKCd~ֆ;.ެڮM.SKK[\g!:Ənj`UMskԹ6Aڧe=R'=N>Yzn;nIgmݏRuPY[zn?z2sֻ*r<4ңY.rZ`]b|U-w1ԈÆEڕUZ^]14/Ż]e46@GH&yqSp\]7tMxn$UkRqgZf,N+dfk7jWt_"Ѓ5+k=֘0UchvAϚ5<+W^57UgkAFZufǼ+Zmhي%Vz];HwCoPV^ݚDi5ЈКcx8yW10F9'M"M922[q%S-Ќsly5qE͛X_stie芚k>3/|6 -1T܃Z!7σupϵg"_Rzk4P5ԒM-d5Y Ԓ֗Qۚ,k̈́Xsޒ6s/y%cm?4vP 7&CSlG}Slct۩c߁pc|g>Ҹփq lhrۍ a [ Fn}2\O6EP:X>4hA!#]Hta>su}q=~?_vz'?q=>@ͤی쩞&T0~q=#{HI[-Sp۳rj?@zx>/HGG{N"(Ȝ/ Rkqғg;Ƴ`Qi} .b챛X%{% i_uқvNMz|ye6޲oyӎikg&n>#2,m~,*jǔ veIJ$iTsT^ ˦/e/˲kDVG LΘm*0jW_Rfl/_[])[W5g}m,TZ|d6 W] [Ԣ.Dv1կ)NԮNז%|ծuW7]5+b\uz췔]3>&v/Wo4noͿUrv^ӿp~S$WTcN%$=EzkhgLZ)')5|38o2Z&r-zwMiDn)sՔY{Dnʩ=W4DjO)CIziamtqmwp0Դ7874ePYS{+OD穆\IM;17dxC鐼1&CQ1D>G7#ͧiJmDoi#g㘢05;Ut *]!T$¡HmeTWVv%*'G&4]Df+'b+DBmYEkq@3ĸi +L kM`!e\ Q  [Rõ-V۵rמ8b9^jEu`}xEPu$pxD Ӯ3s\] h9suc\К₫7p1ʫLNe\|:u3pN(Uv+uZ;z֘+]|玹u;Jkw"VL5A17Wthy){tpC*cYAVi Lpjdr12ͽ1:t/oqi=ޘ\6bMucP*= 14w * Zm2+a͕Sqqe=^FRcq WPVqͼh'uVJ{ VX6*kct3r{ pk\wVnv +Tns|;#}8ll&m%=)X9bx݉u"Vg*Oi{*Bw}"OťzgIU-Py}CY待ZՑհ4Q׺M +L  {#%|}X`2状talBahL8+3: MWM뎍 [M7[v{tDZݯYnҽ;vieb8ｺZqlh[8NAu pbuh:kuDǩ Sg.8pyud{}93 #JPJ%RK! 1pfXC-A8s9 %^K,룖RkYJrzuYZZ38ij;{g};3C<׮ϼ40mWZp"p+).ȆU]ԇ-냆p> 9֣,-\dq3™@0;c _ nMotW4P?ٺp+,V"7 X:pY}kpmx;X6V8^ YzkaK_CuCp0ܼ2 7Uධh ;,;>fpbp2<n wYwYnlh}dQՆqI\WL ^x팘> fļX>".WQ:Sby& 狦PrxR;qm(-|Y eĆPNxZBPQxFJ7P~,1,1i#к6#xqO 7}!3-I<򵥈%PK[x4ޖ%moO:_τ^! j+/BK޶b.WBJkPcБб6Ϊ ZB[Cmd1lh&l[65'4nmm"m֒Mxk&][o])Z)F/miCwQZQlce@hlJi;Da 6Bv\aY@-ԏ{5 ҷ 7t_entnm;<[Mmged)s!̻u27 Z=!:6ՑEb6,f}l2I`Sهl&<!oo $%SMRc6|żI74ɇ +$m!ۆwˆ_%ĐCB!ABQB)-~{@"r?%Z@|ԑ I+$$ad#b{L 0Lo12KIc,Leڙ.ɼ3>Gefm Զkl־}i~Mufo1~AA[6O?a:okƼߏҞu%okվ1b,e:=ӧK3gtOdftO3ѕ3AqVgҽtAgIlΡf^յO辢~\K~J]Av }מ ,ԝM.%%vnJ7nA7~5nYw ӷX6vű)뱏fߌ͌gdl{02ώn}7v&>';bc<@ޓfi؟jbߎӤww4ٱb)?,ѳUzv'5Nx&-N'+Y XA[Vה.KSU--) UrylurCU_Ո_uA6:꒼DN3l9jdQ~.a N>o{~>;h?&1v -bɞ!q^h<zkĀ&g>F5$k5$EI&iR4)$|X!w5RzTSyd)͍ǠLD*#2i1N 5J|DNR.mR/|Ҁ4$I)i\&Ҵ4#ݔ4#i9^$9EN\@.Kr]r\Zy\?+l]r Jȭr Q2&mw=r#/ASUpEyJ W]oV9Y4sH`נc!i ZM>LbHH,(}K)HYU (߭ Y߭5<@%MDV_Z|'1 LyoU16F8Ffdbd3-ejn%^2,R )[ʓ \Z#R IVWS&NnbsbS Ue`λv=`tIwH^e2QI)v{\r޵s i_i.'2{Zt{.bzA k MsW`F!֣Cy퉞$}~'{RӞzDyҥ ZΞɲxrwÞ) {XxOu&h/󬴯T,JG:Lxj <<)\|Z \ivDžy͞-+Lzt^ d=g-V{c.\ׂ9F0t#vyvzzBox€=c3l?cQ< ilOz..8']mXg0j\Z-yܺzNxYĻө}rw5`{@6$y|<\=}M ތy. <{O.Ԟ͓ P].zWJoy453~/V}e&﹈z/DYDϫ:'cT4; +mB_r| ؾ[wj`WDO']7(ɀ`QL8}yY^% -|Z;8O&}6_2_N_ǗCy/v3]+gD~ˇ}XG}w:'|5I:o|(_%CI &1뤺7`m_CLqGמZ5GuRkJd-mk#ٷ͑뚝gZ=˰Ѿ92}h# zM.Ue\z `欱HwP56F(("k$V޵FdXaqQ)@uH8V@Xpl 9}G ړu|/rl]v[-"6B >Yۢut&pη&#cy7Gco۱7ݤ>}?q ux ]!ՏGҭ2jslG}z<ͦ}`?F|d?Ĺ278FG9w~6tiL. 4n&Hht8.wcݎ`lwonw0&S%cHDc5F:]_b"]$`D$QcZۃ{i ^O41ͽ+xh'ޅu\uXsH@lޫc3{E_4]1m+\sϳqR$rLStfecڟ|2($Rο g7gg=3ϋc |@;,ҿ%b&Y?+z77g8m>DNº8jyg?9/ru;)Qy9Ns򔮅9;O 8^gK99Ȧȣ[.6ƀG|K(wk(h}%wWj`+#PGy4yt{=bow %3I>;e3 >ˤ3wFWj}wF+pgy];/h%yU1[wFkpgӸ3"{yyyǝїqg39mKA;}4u'D+cɐr|)_W |#/oF9Əq~dO3M31TwP#T(oǁ7OISư0GPha =+:J,0ep/vQ~,F~n}/+0!: X | XB~ 2 ?s/0:㬧N#0S$8I9~g7uh9<3aQa|08 f1g |(#fF_/3M ?ߴ+"Ŧ]+TSoEMMuș#-34rlhө4s*04ʤ"挦MzŜ4t3"7r/[OsVlAJJyWfGSV6bGϦn̅Ц@DwF""r~ :+P qL|'J7m^י;# 󇨘="搹G`ַ#{mct|VӳRy'yr׼ϼ9v93: vO@(֯L1,q tk'vπ23_0_2_]k0V#qA+ĭI.O BLIs|^(J2h1GP)T6MMaE{%[ܜl6=BcS Be(VwYp@j67Zva%-("  A0$kU,V8&N)h8Iaj. ŒpBf,::K% Bl s%ݒ[r-0K1_*dZJ-+-00: ,Ԃ;- Ap\r,-.?m XXZ-N>`;dKY!˰er2fF,AE˔Jz!˔h%GTaBo[j =-M`:"TihAo-ݶN[7k mg Cs7Hu8niO@]!$zdp&_`k3].ZzlS +cc6l.nYs+_g nN%cͷ50ea-ዡRk_sJkuu*ks 6.nnY[,k;1]v!a -G ^k:X/YcQЧ 1:ilY3P:zSlWg)b[-Rl{pHac:a6֓%SA2@7fquƼy/UG">|aFhbYFo,>Yf>,x| &`䛈O.3IlLOb4N8Bbþ{A!8& *+x!(Z% *ñP9**U(PU,@u Q @6Eo9h+ؾb7Tӱx (.S=UPMԽ  ki {)/磚r`QA㦂JAH逬 (XsPzo2qb Uԩ{D-`X)P%- 2! Cu^Ѩڦs2 ^pܧ/ܞE'{,QucwK,O52/1:5'nӬO]3TWCtr$ #RuIɧ}րa'n7 pq oT1Q3kTƁQ%8mh5FƓ52ji=R=zv͝9s4De6%Fugگoj^r2ud5Y_Y56^g®;k`z77`M` `N`t@= 7"nR~59[\S~ε9v5_"uMm:3Q{`m2FXt P}k1E\?PHdzpEAch_ᎏ+ksTw) okvyc?Sj91Ѵόtx1AOT?Gkt5W 4q I˪T%^[p'nG.l/]s<D0'NUߌ~F~> yQXscܸn07h,+NcѶYwdmەa62BBErFNᵱVSďQʨڗQ;#ؘ1 ތԮh~Άq حb=Zzc&G{3mV֞h3'gYynOWX<Ù %G~bS* CǦlxVʕI'Z S@Pb@#kɣPYg(M!eM L۔qhڡ۩ֱG&M 3Af23?/(|0A,dkF40A,T Puj;1:'|Luof fގ6W{*;J$$6 VDk&Z@ $4€m=}*G''g6\Py}WT7 kqDmdzfEyV} L~5PXhTO3C#cQ)8U~0&_Lf7 +@wHgX$@ }sY\@X˿ ywcQ ԫl uщxjoUoՁ#cU:]թ񪉪ɪUU3U79x.Kҹ,\+J\qz5Vusjqw1Ɲr繋w2F`\bL5fyBr cqd\k36dCfcظ͸øӸǸϸ4OO//oo8S)ٔfʤic7JLe A*A~ySIqLM-vvSiit4`213NMIXZK z%8%x%C"C%d% xg] E(Rd֮&x Bj+ں9*ooC Z× HˆXx÷ }0o~@1 "OI$;M`INBLB HBaB!oY-1nЋ1m"L?W.`~ @V}&ioh%^gh]2}*&+A2ߤMc1 L?i=8+1MqHcW{g*^J}-^z}01cNEӘ~Jb/Xm=1-|/|.jԋj?h? 'bka|:28_16vMk~zуtܠ %YwUCF}?P?%kqw:S5ևQ#neW|!|5f#^~?ױ*,eL/z}Y۠kgh4sx@2:Bc5,<"-ksX=,K!Vh#.'M󙆘QГZJːl.%5IE6~R{xHjvӇQBUm@QGݎz-ataiN5u;jzX:9899{yiHՃnG=^W27oȫl,'Nq<|\V] FfTE~_E<33ۚuftXsrF G_aَ/پ0"l#=Œ$rQl:!V.Зzt֠Um}L\e+ؿfBYl&z38̧t7v72pw(E6 6sygK.I'2sM tbo%;3Y]eEJ-k<MXUpY<Y_Ie5#u23^ oYq e >$NV6Yp:Z;. eFd\K##=2-~>=:wy8\BGQ9K֪WZndI 8~Wֲd/)2JwdE1F*ZXxfHa\пè`?-Ϣ+QtK Uw̤9ФV?B,_ߑYW|:-m|vWC!#U?'yOP"bL;\:7G4_f$,a݆i :~BS^VZR6מ\=>oh']Mwd jua|o9׽znw{ |oB=k寅vQj#`"uj ]4o0-l<,&w=Xd7 2+d'UZA'O{AI83#j!6W[O0܂li=Qr͂v?}+6sv [ЗCYl f #r@?[ЗeФ2vI5.Õp5\~t|3L'JTKS|7 o^ب.uAEm[% G; )c+mh`Lre.;#eSbNC875#pu;f݈y뗓~BwظM6p/';`WbA~>*QYhpVx;bNeԎ槬> 2Rލ8Ej,byy wo7 H-W]wVghe\|6$c193%#ؒ'w͞kz,Gس<1ko_s[_v"<.%[bo&1, -p6="֫HixWad 5'a&ccnda!3[MfEXi(LiIfKS<U9jRf15;Kr.y1x~޴\hơylax?g>8=8;Fy< 7=SqU0fAy=.Noe?hFM!a`SA4i++O`+8LOxmkV`}7YQ]4җ/] UӺ!3glk2 gnwa6̢Tz7F"n9R vrCJD4ip\0v(yl&+EoK菄̀NXCfB3M[N'x/ G̙٭>ϴBpO YMIЇ QzսUDB<X R:fCj%o|(qkO'X]|[eFߦ_0:#Z,gOnQ9AN&8L 9qʸW N̖E~~9-9{\{pgcSw0ug {?qǞRΆOs=Zpݳrfw‡kh7yf}nɽQvvbfQc2w59S="{ѴJ"EBd9)B7W__ᙰm=,o33İ0$wo|P7黟LZr*?MGnJ o2'-\G>I{c؝wϖ^9Y%9G-o͝lɥZJT4)VpmАi2G# jpslx bIĵ!ӄA"G|RU${lGnFI+妌"$<4My?`)̍e2gwf5r؜ըU&1R[.#@_i"rre)M;O" sryڜD ̥Pf7**p_-AA(u^g7 -߀0Zcє-_=k_Q䯂_QW88} j5 cpBuMm/<,IQf6Z!'Qz ^E]t{4x_lZeiJ4Ѥ#S YŲ5r.%c XyV=ث٢1AdRahzty3܏Mvpwُ "k1yj݆bNB|#,lb]6!Ҷ<'ag e˰%V׎vׅ r/tß|װ\+4X Lm8>%koi0rC݄_(bL0s66nNV]q%YYߔg|`86i&H [S:ϭEc+M+𴔚*(jU%P1y\\f({e3#'rS>)xAH@[x4 aUnfVE^}6Ii&%D5ej!CYWFOaw|C|nDS9ȮK{g22R d}Aʯ#1Da,cyK.г݉ȿv{rraL67@.dlvh[-٭OY HsRcl ;15{=2:T G.ny`>c<͊`/J-qXa2G^pD&E亰 qہ\80r 1vEIn|²)}j2v@cG;gy)l0gm>s1U;#99g3@>'%,ނlv ܐH>C~htK12{j-KdEx;֑o42J K0c=q1_@{9=Zl&K$"gf܀-Hb*rvB|g<߆ yeo.Ꝝy|wq#/$O#_rq;9k_5뎗/{<!'?Jf5U3Z}AϤ"8Yx+KO9'R+x)ryr9-9y.,4I9c*t%t MWլnkە B-N=p:_);-\Xd>_ [M .)NhB/5vh*a?eؚr=;cy zw0R"h+r䉰-pС1"=>6a6;ADOLuo{ᓰ?S;D>;E4֠nV$3f2YE=u }hv#+їŬh 6/BVa ͆g3h\C zȬDw<15늞咵\&}_fLd*<֑yM9s)n)d53 2{#q cD;B}J] 9ԇݕsrL><\-_j>6 XV)-3gѠw #e+R!"Aۢ G ZS))c3fS}AQ7> XE_78y9/yoU=oF^lD-M|lDCir7H_3xqTZa#kGJL]Fߛ wa A 5}du ؟M&Xc}7Vq%h&$J!33C܊g"chYGiM}虽^0-\ =6zo)}2:8ap!ނq6(ݏ\Z9+|?~h];Jp$Mpǿ`L?1H$M)8'8} n.^"b5eG7q֣{p% F>ݙ /Qys>l_&٭H g* \Fߡj=Ud֎;CϘuEv LcìvLi 1A漙{}#{UFO!?B5JoK>%ۀV qX9)OhAS${EѢD?qE,@UձOC0侰969x;o6n̕7'z(\-?xrGYޥFyg282x"y+4Ex_JUNq4Yl$">.hV]06'_G'ސ;IVٹ M rrrJ?4ohNǤ%aSZ5aOJ4*/V >Om9"_f'lEVB^Bss;(t4N\F΁5W̄UJG҆=Wro /w/f#p:jr쐌BhF_m2#}F8_27hؘS1f]Mſ1Tk۪"XC4t?U2;bρg}tUiDkz-^{;V3hKY%y}8vKdZ<~-a>;/- s"o_w?J|9h[A?m e$}u>52s)Zn"1l+}^叧4cgEV9&4WU`aݙXK3O D<.̜R@m2r+ًUc/_?MloK35+&#e}~ v2 J{rEYbb+/*W~(|(TEhb/7c[t" }|j).m#ND9 栯+`/|/&m/c[f'+@/"V^"v>gy#UW"7_F៙J;7i[߶$+m,~w\sAxA(r&d*/7ɷbX g~D h&P44g<~c}?y҆yZ(1:bFxwJwβxnv nhL1GyLMc`QٳNS6Sd|nQTuujRTghoFqjR3UDQ⪆C5TwۼW}cjPOi9͠VT|V^%O.UW TAj6-ڶmZ/iodw 檍zHPFUQգjTczFͦVJSTcuOUUs()қUnTuT}D5S-T[UM=j&jz>lGQUHSUe+UwtRS^ST'_ Q#jzZ=yjg2aepepӽzd1K0Ƅ {eml{GqNYp& ezrWw6'y븇{ ˜s1ȋE`2L`%X}^6m0}@8 ")p:_!zV5p}߇.L;Rx^0& , [aA2l ΰgffZ@8S 8ײz ^_F4QS,o 6Xփ3Ǧ4-a[ {fȌp8NShGf9p>\Wl(OcWw*%gH\r dGfwc31$;/,Y쿱ʹ;JK4vǺPTI۽voo~ʿ:`?7E}VgO1u^:qNISitv9,g|s;:NԵ#z^z>stDMYS46mL73،73l5s .p=[ \oݵ]7}2_'^_?޾/1K \-p}~۟zŮ.Uz-?@IłV\AkshmŸw?  .zkz#_z \7/p}_w \W(pw >u}/.0sF-6Ry]O9s+auo/K [ bOx.1!afb|g5]r.)LʍNN; m5ͥEQM SԴמ)l^j"1I&֨b(cjS(ٞEj::I'qoI /*03as /Yβ1(b4qk!kX]]Ķ?kڟ%u-~&$*mZ&$YJdާrOτJgτYV -Bw6C{*KOQA҇DE}D >&*Hԧ)QYgD}NU}ATEQ]_WD }M_I!j[;6: u<3D]OzR^Pl Be}X*> Uq}$Tקi곐PSZ U}:7MoPisOxRkD1N `t1z62`M2amEcme(ˊQQsF/挶^)^;y堃W+^E"t*y(BY:935.T S){X>s8c!cf/X>^V6@HP!G?yxḠ=  X9 ssH .&9?Rs$\ArAGU$W\Cr~p-P֓I.nFBrnp+ym$\8]:7a@d'i>'+2{" /"" r8ȑ"G# r<"" r&"#\ KD.Eف "DN"MDDAZDnDAvW X<%XF #b0" #bÈXV#baD,FˆXˆX#\&Dnb|D,CĊ #bEbˆXÈXYˆXˆXaDDrDA$w<D}A&d F)A"E" R,H"%ˆX|DH.S&"""E)ALrD# R!H""$FAJDGA$)H͈Ԋ S;L2u#ԋ S)K$"|Oߴ7ѵ"l@4MDwC`1T ij9xA/(8(8*8)N8+ΉE\ܑ;z}Тh\4An" SC@ @!b01 aH1x\x\@" \Fn#g7 BCfxGh?WrD&Jl;}Q8rDIJ=`D߇+lm,FV#eD<xF�! e ˰ p FF6 o?*ՍCV1YLbA,+JX%V5bg$1 q1MLC\8yiw'bX$%{A6OSU>C/C>@@3]t xُφ') O3,<G~^`/_]o[6}]x&L1| $ `|_t_Wflo;ḃbXc),`9#Ƒհ: U6& [`+lcv. {`/q!8 G(N)8 g,~p . :܀p ntcƛdޜ-y+ޚmy oOvn~~a~q~䧄O3g9~_̯o`d ! aBh&EsBD'YSbxZ<#^ė+1K߉9bI? b$6-b&b%v=b'D&cjl3;.ck3!q8j3')q8k3_%qŸj\37-qhf e#X6Me3,l%[6Ld{Aʎ,ȮLeS^#~X`e*a|T#cq9J>!G1I|N>/_%|EC*_7-|G@Nʏ9IN)rLN/t9C~#9r'r\$%{2\.WȕGJkZN$˟QnUnSWyPyT yRyV(/*)o) eJJΔl-(PLqkZl-Zˬ kZmKer{^e{loA}>bI}>c_%}žj_7 8QNбq NF'ʉvbN'͉u;9\CNS)9NE'$:*NUSݩtj9:N]Si4tEbnq[-8[-snVrn[ͭpܚn-[ǭs ܆n#m6sn mqۺ)n;Mu;nMs=ܞnq܃!{=s'ܓ){n>ͱp4s}h}H`Ha'eb{0㍆U*oeÔP:Jy- qʨh$0xnjSmF8c/88ǎJ*;CXk['mg= /M]h}2f Ccd@1,_ayԺ@-M 9?t0yN_uxLx\9N^3:r b+ut$jnlkW7oOKӊoO*H{:AZmWت+92H^7M[!`ݲnx7K9 w~ɰ~y33r, gΦ3[S6kʓ]1G1Ŭ?ɇ̆`-ޛ]ˆe;%0O/+6Ds0yG;0PdݐqL%LV}5wMiuRvN{tt:9.NWtwz8=tu9̶ouT7KYn[Ⱦrpf᜘s;yN_n;PN.Y9yYꎺӿI ٹ ,0DgY*KbeX:K7 X(T`#Pg }~.|a1xY$^2ޠ79F{/ >EfQ>E)/DMXLe4zb|d'3e @Xpa3r^ r L`>b> |ʊfRo YzV3! cìch88)I.!-dcduY}'l%jʖj8[FlFhlzZ=VgճlƱe2[^Ux5W& j6j϶[Sl5͚vY_Zs>k5ln&ٶ m׵?^;;|ǗWt:=wG|s cBfSOӑL"Z?)Ɗd%1U`uXL1 X0mZ:̂f!!Y,j3%̒f)3dƙ2fYo7+hVf&ma[6`;.a{>`!vaG1vkq! C\WUqM\7MqKwmbpo0hlFʊE@,4 & [LbA,6ԄZ@,Zc- KLŒ aXa0 x,0 K6Z<cO,hLnZ1{m gg}X(@f lbǰg?Ǟ"6W+Px(k(%P-g+ ak :O̺>=S3b"3b5{E6ٍ4udjazjwqւOl=X$DG Kp"\~;Edu0r@|x8ۆaIDu6Qsb@29x9 ?7L Gy!K0<`>yc~/K0Ǘ1'R a2T؂AF3 7igc;1㤁8js _% ޡ7@µ4y]{,R7@ rwj8F"guvULVm'/I(%_xfLd!AqȠ8dR Pš !Mqȡ8)y2PDq(P4šCY(efnso,z=b^󱢬4K`5X}؅b01cس%:~D6}fBb]1v]d13</"(bP)A2s/;$SYɎN,dgVdVdWVd7LcIvg5I$`^eքx3/o$5sҫ̢20]e#BŒ\<*y2C#BHv`Le_Ȧf¾$ٕ}E3IE2&]%{xԲ8ɕkIAUBDHe> M$}H,1$dܧd)d=TB$$US}TKU[UW_"V|h\\z1I2IZ/$*Wy ~S{RsTUѷJ*S-UeߖoEUշ[Q*]j?*T Vd~SmRddNdd.d{1jL @!^6pAxiL(9/KPYȲm3f7)P?Ie0/\)=XVeTYUNū򪂪T%**j$USRUUWSUP5RUT5SɪjZVjڲ5kڰV>|(?T1e6y|f~Ք̫RT;^uP:.ꪺ4]P=Uz# 8h[G1u-۶۵WYt}@7ԍtcd v ;ɮiײku6{iw{M}۾ wc8y|NS)wJ:!S։w*8NIv;-@g3 u9ÝGGH1qg3<cPV\CyA@ *W`fY)0'0@R R.fclbAo u9Gڿ F /|8?sJ5✯|89"6qwswj"|i ba~!5 )M k3B3H8f"Hy> 1lZ^]zǺݹxwlCB/MGG3<&GaL#X w*7&{ o ~׫y+ؾncߤĹ>g%l^ <#3hlBٱv>7a-(b.΋f.{=lOW3,8JY G&f3'!lo%llW^`Ȁ8:f*vW33Ag{==%0 B;ȭCx2)HmDġKF|abaGF|aGF|aGF|$|X #Vˆ0b%X #Vˆ0b%X #Vˆ0b%X #Vˆ0b%X #Vˆ0b%X #Vˆ0b%X #Vˆ0b%X #Vˆ0b%X #Vˆ0b%X #Vˆ0b%X #Vˆ0b%X #Vˆ0b%X #Vˆ0b%X #Vˆ0b%X #Vˆ0b%X #Vˆ0b%X #Vˆ0b%X #Vˆ0b%X #Vˆ0b%X #V_bW(4&v^ XO_q~pP0`ӂǚƔ̘<,T-9>DzpM P`V bFtC~}='W U|ˢ3'c, & 8*c2pÐ{n5nS4QePFZw3_!eii-.W(ŊiuPɓЀ:I3rETHV}iT=+W&.X.TY;sCߎ25iP`c~Iz Sy<7NH .[LB|jW+(5j6hXz״^ b z1nm׳ r##N~-r~rcZ-]hLW4[/}lѪ7]ϧ7W%6bakW۔~ 2/uי;57|I{RTтL{mUj=[St?^]`PMUR}7\':ӤqGs_|fҗճ?hHo}4vfkzgiz믎ؠ#k;^/<3椾I&)|]x'dz϶N)Z'Gm+ڜ GaAD DHsjs/f5ؙj橹ɇr72?ɵXvcV/Z6M3I= PTA}JN%[j@tkwuRw[^Y (옦)39ğN|i+ E[pB֯wR^|q`Ʊc~)Zv@bcxYiߞ-)r"}?oy`{pn,V[վQnCktm{Ę $|_bɬwK+Ü%gab 3>k[o$NUŹw_WV{ߖ7nWmlٷۍxIM>f]bj2H#uy#ޛu[.sg =WGO4sčGJ"-S6ƾ8za}vSaJyz~xY(tҥ˔)SdeCe~ ~#Er? Lf(ϰu!DқŀJ-T H*%@X@zq@@@QX]@Z@iADGex>>W򭝬Y[o| .Y/1S>:r[ <YʛEʅqhxiLbҺhn|@o#\8m#*S8VǏ␦-2չ+,4\|%tÂqĔ|FZoNޖ"xo' f<ӸÒb2x VkG8u ulxUv6QR1nX \{Ѩ4-{wueOWB%ߧOdꐝ0 `{"W R"dr r..wdePGsw L-=ȓdI$A*}  sd0my % =@7};Lˌ6id.80^CL{l8Aaxښ G5AC%g+Hh^d2ў%~3b#UĸYb~&H0|bEb}X:wNmp:-kV4iiɓ=z$Uq8f;rB9^ ZO4EֹTxڧ5_#(xh25,2Z(Uo8 _|p@~p,M5l^F}ZC9==`BV$!GXHm^(@ ]0q'יW a 2 fһt? voi}pjJUK7;ֺ<{sqlURYvFa^!Cr-xuז܊ }Ҵ_oyF@jʑfk?JKDܒ qˬr~[ W]OQ)w]!ϱ$)ჀǞhf[-#aĤ Љe*fI+ƴ­8C#ǩòT1 1Tz+ZX3[n?)%*ipD]M $Xq1PP0S5a!,Aw{Fc{n$'+D{D 1u_,TpIo#>,'s/ڀfzj?e<ڻ)fO1DybM!`Կ~A JBZs^*Usp)Bs~P%t[gP >bE)م ʏUJ-y鼨M:vԄ^OTl~^M8nb"uv8KDVsb3,w#B8<U Iwmy;"r|tՇWoޑyk[{KU_)F/z3l_ B/1<= %H^V^kI7;8֌I7Yk,0`bHV.s=׎Ւ}Q-X^q%EMTq.⚋+7#[ ߆Q6E됖X~xm T8/b[?M^L<]ˆ͸uO&*M䛼$jv6?ZQO4뭸C>Zf n?0W{N- Ϸ\t>E ;y}0y#(6twb w.9.fR]`whV>CX{!Qө^f媉B_jl?q(+-eMwvBB2Yi5M|]335k:m}!Bb:V^u¾TL | i'=+=K^76~|\3iO/=CÁWYvo@(1lsBb r{G@y;9MX{tT]^x#W{룹s6t񊉼'J7m$2*%Vt{Ц+'l_'yJZ޵CRk>^|ùΗHddc9n9fv J;[`GuNjKvȭA36ш'3eyŸѰ wb=s j`ά kR%?q-ڤ*ј>2"%XVCx̿d- >1\0M$@ETQ Pi/+o*w$ ?%Y!?J4×S64I6}=^Pr"D\o^ F,)VMuwdE9>!/2]{UFH__IJQһaN!Qoj9O3]gzxmw3{.ƻuQ1g5`+=r%`9^VKJvs ZTrN+1%jاծZW{Ñrevq!xwzFp \~䐧:aF+Ӗ endstream endobj 2264 0 obj [ 550 0 0 0 0 0 0 0 550 550 0 0 0 0 0 0 550 0 0 550 0 0 0 0 0 0 550 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 550 0 0 0 0 0 0 0 0 0 0 0 0 550 0 550 550 550 0 0 0 0 550 550 0 0 0 0 550 0 550 0 550 0 550] endobj 2265 0 obj <> stream x| |SUs͞4I4MIz) m)tIBYB ZCl"H]PVdѴqQtAW__Qyq:3{=i-7'yYsι `%Sʫm//)-98Wؽ O+Y{XIym}э.@p`ҙ) /{-?Lh]ymHV8&`_ɟ(Z:tnl_ P~q{K;/}=#C}D"۰xڍY8U-AKD,]Ѳ3@ߎ+[V_b84B]窮n\9/Kgx?kRYt67ŧ#xq/һ%l'`2_1d T} aT':8ЃK 3%dHA!=(bЁC)9Lq'y.[%{zI{c2ț8b RՔPs^~_HMH_QWp[2 gm eC1Hc} ѯ?^e?龟+5ƶ!"Kcb¸Z'ɔ}Ca3|}}?*|e2?yi˨1¶ [t喝_I۱4g7ȷc6XKci,4XKc韗^2oT^ m\V}-}ٖpU24XKQ% XbF?RfB2&t`68OOWgqv:qv;w9 zpBҨZae=T\^M+T)gl%/Im#~ #=R 2~A/}EߜȨ`n%ݣ+qk% •$8֯ n`; ;G{#@:z'X\+[0^9 u5U3gLV9uJEyYiIqQ ?/w򤜉YԔ8!a1uajR!I%_UPZbsE}e~ؗs nve@ ݚ6Ϸ`&۟,7Un%~U֌ @xPxa¥Gh8b&? %D\.*>Xwu+;a|wkwN߉w4o\U͡Bgj Z_;|B[{f3}ҌJ,fn{NI(b>XR 6 5jP=%L@ڗPp&8mǽ0~s1:%hp6\~_#Qhho^p88 upe<^ll|#2exr%Gr pP ,OW\.A$[H&i_1/=2Fdb|h6(Y^2JK: rrb<Yԋ B(U5PݨEV sDofI%%vȽP,sۆ}*HSo;{BemYuN X0扆 e e-S,iv/z:KO}Szچ\(ZM&:*Ie]Qj .4~^W E_@/|9 b&h 4 Hlja]:Y` YҜҍ 4~*+Ԍrwk h[yFb)~% 56t.bV :PlߍwMmX(e*Iv֧4i1b`boD٠qlXU[NZkqTecv\% "l@a*2 ;/ͫhn S*ר"НNLƞ0ӣ^Dfam ܍X&az,݀%^x]t<CNFAZ,w+׍mb*v#qǫpX}3Vinơ67cWaMXk^#q7n#Kzzc XSW'w-:V񅎕\cIEm [2=܂9psޚJ?]O wsut-9,~kRRgw$sJ]S *֗J] n9?ÁeDZ\JV]Ѯ?&1@ۓ2b z0A <71670uQe`ku25 0j\`# 3X`-.k"t2X`% 3X`)% 3XĠA;6 2ha` 1hb0 f0A=:5 T1` 1d0 1(eP AB> 1e0~s=B d1d0A x1He`\BdI $08&ߏ N&A 37pc 07#8 4, bD31b`D0d`fԯ/A0200ggce@@@@@@@@@€U"p )."}A鿐>A#!HG_. }?#'?"H@zm#9ב5GzH ҿik/""9go~ HgBzWHz _"=t1HH"=0CHǑH"= :~VgH"=HG~c F:#D:tnoQqfc?>H!Aڍ iq+R/-H(uZR`iȂHp䃑/(4u~gz$6#z2<}\^;b:u䔎>Ԟr/hky6%8n&RN_]]9 TUsd?^}sx3[x[\ by[o/+v< 7V1㣙 fgFwu].Zk-uFFtj- Kk"ߣhZZZˊB _g.X5]BKcyW,ȈLʍ$ˌ_ 4"2AݓnM#I`k`@Sd9({\ }*^+W"%[`LG;,EK4<m[-A|^j+E5`i< #лhݛGcw;EsXw7`/agnqGpc8 a;? Ã'?_焊HgL'3`ehkPG-(ugH}8! Jzr%R%j1OQN@IDP< x>9Jw18 / 8OQK'j(F -JMrj {$,n!-P@>IIo8\m[ejPK *{> yIv!ID e~? XȀ@Oƃ$ $ž49nNK3y\Ie8'@_;v>RtK{8y_Lz<BAG?M`W=crCϙpo7/ntB\]<\4N.¤yY؄ ŋS8?$9Ojsϩt4fn=.vڦ ih.w % ??D/:3&E%LN6%Hi+mFe?!HCt˯o LөyޠR7Jun ;U8yD)urLRC5Hȱz^3>?F`4ʉ'@l_x`wa൫g>7"#kji6>W>ofP F0[nҞ9Nm3_Ys嵼\ȦʦqT[BU̗dgK*ZS8%Qj ҧ*Vy5ph{V͔Mu\ͦ0SM9v˜?m6q]COjX> |F1 lU'sao  Dϡx9<'g0y 2YȗZ]W7d:ۚ>nX9@q5_G\m? ~ e#TJQ#yUhԿb9(ꈛL\ytToxEMq͑l!m>6c.guҜ2U%%]Ϳz1qMQԸ4?gA61Ι$[lvS9ù1:ݤɲsU|.ܩ)bgT몡Z܄Ek0@r7y^֫VajSIEՑeeA[8u!1EO\[{"$A6uْJq~;4)dGr ђ%hh YR)ZmRB⊫ˈ5ZEWGTfR5[ q)ECQ+Qk4( ȅ lKE˼\kKݧeWl_]mdnIO6O7&t zC&$׆i yXM*LkPސxF?fb륁 t6LC=5`RWy1pt_WpuzȦ2q^kp{>B$j&"a<҃ē%iA4GϘߩ+H?֓{'>x$:OkuC Ip_eGGZ!l06_"CۯW.ēdS?t{ߖ8WxpZ쓜YD(Xſ>}O+(oj't'P@]m—(pY/RԬ6B76tNe[w?gӟVVC =J*j81|"AF$Ӑko3  /' 7fl*<7!߉&kBG4Onf3\.=L5TRa/'BP {]J2NTǞ)zÑdu 7oDYk3Dز񵮳P4^\Dd_OM&| Dh:3(Y9[&Ϥ-Bf 61+5SbT %!3ަ6&rA;i9ӌ R:4 YSݕE" H%b*# #JJ:hg4Jh'EF$7ۋef&Mhh-zŃauLˮ]ow_dpo\#Rf{ ˺j{~Px__ x)>d}62Bw*\Ƶ:^Rk}FN)_횴'SJ\lxjQ0*Q ( $^.GjLDM)ßUY95-&p|L&#?;+Ct8=C&{nmTf3j5GMSGjc#yKn*6OwR;=1iiFWu.iYJ=-wAɤX;Nf 6^F|H<V':!* }*}Ф閭CyeerdLr#RrŲb,bbr6KR=vʽ!r&pP&mF-9;8$YJrK  =_&?;b61!C$WG(ش({F|g'/,xxǗ?UY8LbcdG3Bɕ;0n\~v~[kM!$޺7ǟ~ !:/1 Vl0q \"c8Hx!={O#zMD5AA0HROJbe^NF:AXx_$Mhu_b,  /r d $v8K2 mBꣅm7yHg$Ȅ-LԗG!o?IbN>]x@EmkE*ѫt|cЫ# \y;,CH7I OynGKf=| YQ94#F6tF+K3rn,[i\q*{^0Q߰mRu;'*$։ -!w͍K,r(;9d褓dHHGK' x*\~>W^[3HEU$-$Du*vM JSZ1fߦQVX̗5j3{/(Rͅ!Z5ޔ2ee\Ӎ4B? IBsY‹l63?,{^M}+sYyɑۈ|U}~rkVz$l]UEO6oU42%7 E^a .(۟ kpK5'O=iEkeXj nKn-w`U q̺[c8`4¥7ؚ<_y K tdW1Zzɢ~~Gorc. 2O@N$$bt @R|0mb 6[$QHsrn@N2Ilr3\ -"堟|3W1g w]>glI/ϣ|*`/[fҶg.6.kqVin9kONj̉+NjHwㅊS37]V[6-/N;..-O y3jעrL=;Ǐ ǫ<1ƨ\}2,DFJǵ}Rڧ}K΍iүvLn6svSu6yuڶk&oi֒tK~qqLQkkvue{ʮ} ""I(B!$8Dqcڹ7T-z}sZNzYk1^$̝YuY{^ȘMm7YJz)?W^O563A%eJʬʖqF58aȑ̮#Oҽ!ԃ:G>Y<)msopb+tI;6~ions~ÏJsIQB:@%7 V9Fɚ|yI.оf3\ ?4@>.E —O@r$fl}x WqI1`I6gTE@﨤O+Wڢ<?p# HL9+u 1Gם\ݾ@W=!cLԴ|vKTsi%Y՚"!W][sN\܉-w%L`UhTɲy/grFL+\61D4vd͔U[)HϭVFY3i?Ï+b(IJ Pj5a$/-:B L/Y/?^“nɧ9% M_G%;a:xqѯ6]EGBS# ƲyJ*aGߞm6J)me۶1~P9xM:**&6vt/aLZ~D{2^v%y-M_03Y71j*+7a,Pc5/\`6~zhk儗3M?8Y01IOosv^~ Lk@KI@;>-)c)H%UDQdzF?:Suz_(8TL*ұ+~%6%1 "z|IsR\3q"|AR|ǢuOс^ zA}4"jDL7(%TVy iU7Dq3Dy(b{D$.G2d^I˼Ҥ|ׄU_M^ִ| 22!G/TQ%^K~x/Y%?Kg,%^K~x/Y%?KUi$A КIdI;$>B&gV A䅣z/lx hmG~t⵴mY#Qb{ >Qs~:/[ fD{66>hH˽x=F:v8:?zC^CYtzFjP2Gj \ z X#.]\}~t^K `\.a-PC^xESćty>4RĖ~E=M Y؄lnjXS~ҕEKc.,ٵDBp>Jvb䤨1AR+ʼ avl k8q.!9s$<_0!yESd'ɵI$*ZQ|Hyc=nyA c<5,o*F`Ű}4CCWm蟰< {+]mhH }x}9Ո5YQkV;8S %]~OW WMVs?hHP=PO}(_kx%3YOKsvX?/sg*O55@J3Sޭx(T/c55Љ;Dƪt}],,(*V@sH, AOsZ[EoqKC{;eަҀ#}mA+b{08ik^2_0orI ZAllyq9Gl FTQF_D;[6?{)ѵACmtC莼lO$&q~0gC˗/k +σC޲"1#w|gQзs:a59 Ƕ0Sj|~nl Qӗ[]d (Ath^?goh5 Ww~ER(-WY>%m`TXրg`GfN8P{',k2Z!O }X`$͞P~GC?VB" @5HC=!K%/70,fblK92s/e #yg_ƔobL3|9S|S_؀b3v૙jL Nx/3)k% [V_0)pGYFIi"ҬbbUSՄQGGN.^.@ ڦq77`J_~G',)؟Q{SӀg3g8;ϝ]/r/spwrwqspqA\gyT h>0!|"')|:ȋ|&D~"$~`. N'Njy-NgggF2Cn&|WU|5` qkZ@7\/\/8U R`*PȪbT10^JLTUI**EVRTi S1jР֨A:^  ̓rrfF$W[Iw))l0"IU!WCTY'D$™l2"++D[DR$kTxN:ENAbĉ؊i+mKۖQ߳JO:SQԒ)I4bI$OOR>u[ctLuJ1eqRtIcK0Sr1S~{”KDzŒrbu焘5CkTncPm 6AJغpm=rC;$<r{ڙa.Юɺߓm[ؘmvImh{e0gЎA;,.b[T=lwAђ MYrhׁ/ Xl1݈4b1C=r7} - ~qg!h+#G!/,OfhԦnho˟ʟ@; ٺ\O;%]x++Шoq=l J9hбByv[ٹڝ ܁m715_q[߁ q~CG#ޯ0#aT,TTT*]m)"T{ҔRvZDʧWl96eVl9Ue-nmk/`N cTP _W{:=ugQw#@ŕ4_G7Pmýp=PnL+/|i.`Vur,v#< Ϧ!&aDkJ/NdZKjty ɴ X߅hB90 .Alea G_Gh3-(y{> )Ǻ3^-1T~߫ڃrKwo?@#*)IW*D b""W!$ NESe o }=ވzRKoY4H Z}͈A%K֫xm?27Wmi}eM_'{{7:cZٌ}ZiSb PgۻM*|M[wUЪ=PL{*^*cClYu\ TGP{kY]uuuz Њ" E^_XڐrP~-ڰm\5,TWE[wN#zYbLl{9Ҝh;L l޲u%.6>PiMlױ v@{mЕnUA]5Ujڧ*1ɕiVUA4k2Ϊlr*B~:EZ( ̉U%?j[Uyx/VU.,V5t欪%UªeU]eu.kd{7Rf UkOJ\VMm{Mj'UPΪ}KgJz\i.kT ~;C$nRTsCo\BmPyo5]MM9Uw>UPs-vj0 W$L{+hʱKw).L܉\k#nBJGqzB-2tUv>SkQB7vDklky}k?Qr4]n΋vkPt,8[ #7=1C3og3t˵ w~䩵{\%~Gـ]zZ/YQ6Ѹط2zhPg1fX#weΘg\u JHJv \ۼ~ Tu }g>lJh>fl>Mn(&*|5Ke5t695ͧΦҚY-̂gs]#X}v߰}+;phY_]z|VZGu-1@wUz -wjV]e^.xV٥u|:j~sŠӦ0kϸA\o3t@zf)vUov@ð`ubځKm<2ȵWu[;@doW1y/_B=O캪O!vXOY zǢ*d/$ S;(6鮬-!߉ PCˠ~4Oe1z68Z2iݎ lļ}fvKc;p1ђpvKv'\wȖKc9V9![96EKc @6g?"]ezߋWatlYwX\\8ۃ}zuRm^ײ[8NmKP-_r,"n;qrZ9Wye]BiZ_CIkROGoR|AxQt:*t/HcZsZ̬=iY5e{kxƨjec:e_Mۏ~m9X  ikm5Aw^^ ƽrf{t&fෂt;:bDbyj\XřzEyuL An{jyO KU{*V~CEM VJ&J;E3NIbR,wFD__YC!f^'ȿD>#p 1 .adn4ˍ2x.f<iL 5kL73c{?o'%wL;ϘU[o{̗a 4栐.gzL!9& ET,aB09+'T e) B=sUhZ K MdMX)d uo/{-恰]/t W`^V UCZ 6Z8"aco lpV8& }B"+- e_>T$ZE"**T)S/-a,!rs2Id\#%*:e\_6%&(6۸{ !iiUφ@\gCM@a;!W?`>$JV*cH4&B~fGX6K4lAىD2gI;BF$-eKI2 Iz3M2w\Y&Sd]ۆ{A#oTIҌl c8Xmh7 M%v2j:F6-;{ E$,B i&L}pMxxx#}<̅Qi @Ra%`}L' $3Qbr&P)1:%1J1@VdF 6fC NR$NZMjXVT$udE2YHWz$EyU1KQL^S(J0c$ta#-жA m7}ʭLm[ ;w"cvRKt }K 7 w Fe2*$>A'c:}ߋe/R׻?P|n%$SB2MWt<<ED%003:h КAЂ.blП9?=#?$6؞!OIfwNϳ/}Z;g5?/7?ͼSyz?j=+O>:8}y|T3}T s9۟ŽOY铎?:?vh/_IO|_O/C^r`R{WwEw]wJFm,:{hE.]zH4}><}t} HAI]2mr šMK#?3lPױ3@V$?Lr"4@d.7 ș|2a'Cz"( 8W_h#BVDϷsQMD(VӸYѕ7DRX$|hy(|h$"P"l%_&d;2|?0 ^vPO{Pۣ՞Ԟ֞_{S{G{_;#:.FKѥkuqҭe$&Ջ#V?uv\+#إ@A:{GwZSt>D0:.GWXftVUZA׬kG Y _p+i0Q]htV:2[G`Dن'nvhWSҫtz Dj3liL[YԳ\]G:2}.p ohzA7k{6 E=ɓګ̡>_үԯ]oLoֿ]ֿ߫?г)W6sck͘ 4 o֮SBI !$B!<:m0D B%h% " DDF!""" "ADD^""20 2Ewk޵Y]c׮}>p#շpgSnWwd.L/NGyGC@aezԣ`6T.Y&<v'~n  &$44Ut, - m Lm%N#/¬О\^ߟܟ}?yO& W*Rh׸22ӑjgy<v:++ٟ?wLym1-c'A2s4AL",e.\bxZDj><$m[<u,dnwP_]Ꝼzzz7?Ǜ?x??}^ҺӽxZmGx xz>Bm/ ᎣDkRɳ(R P*ԎRJ)u32(/A& 4$4J3MU&_`ERZIi u[))tܔt|@FGXx(\'PJ; <gPʾ*ϧԆR{J)瞔R?s JMOq?IMNi6y&=4',<<*Jo^?sC(tѰ=8'˩gRϻ1Ұԋ^QXo}o Rco7yR*v2;sH# RO ޵ T~a1IYK>s|޳8N$y/˗ }8Pey3}}|}||)|ooowʵշK鸚^i55vk;ٝ[c#[];;tw*"w ߹4IIKKK&wӍ?i'r"<Hkhh]"Ԓ[H# K%Rōn"nҭt'qŽ%j!{U""OXOZ~3\:dut¤3WќScUb](`l}sNəטR&J~/*5J L4O6e7ܟr8Xɔq)U:$s85:T'5.5)՛#r28Qw^ ]'u:,\Pu^׎d]c:I7>&6}hw ݛoz%& ;A^.(M3zYF;>5j;=z%͸fy,a CZ/J~?k9$99ǣa#e > N|+HS{A:e⬮,C)x/j.ĉ%z0RY0=5o:؏fFنB'm0.\j}>/'<ơܮx3~µ=I8Cs18{5\П1WO_ÜOi\` vk6C:. }̹W(9!0#E_p=Ɇ?O(]+2yJ=Hz Jg"j덞6K7|8J1p *[,iV% t/Nh)ORo|ּ{Ў %^UMC^ӊ*Пɽ6pm#Ic=]]Ӑ},9X;m]5IX*,<_[(m\Kj,2U/i>Hr#gO l~Oh9Kve@q}]C31lK'u΃>w=>?|_L 0KH.|-:; w @f,_+u_+u5|Fy<:lsz %X_~H8 z$G1 LpoOX}bM6t:JFa1ǚ ?hv< )1?t : 8#r O3~ 0V!~`>sEKѓmcfOz'ݎӺ`~fkŻ=uNl;D{<X7%<ݝqei=ѝ]3F?NCpꂳ :ν#@_~`"a9ކ>43*u+.0wU{7FC `$:ctA| tk@Wq++eK-_B4fk`?6!Y5Umj0Asr=U,]e%)8BZayC p=|0lr*Lk!'Btk%<´Z`8y RԦ=H3QP3,iu bԦP[>''!`f{Py~=x"ywQAG0 U=js3G@i櫹iU)< yH{y^PJt+:ڄ%!*un$LsŹ,>;}^ks!~y|~55 Hc{E& \˥5C1MkҎf+?&li=,9¶v`F*5c-fF9ЏKI~ f+ 3l~Q:WH?: uti˷ ׀NX<\ҩ8+à0j>PQCΝgyh>M}(➛>s\|F| ɂ%5X7{4%*'򪓡m%hiHmmmX`.qn5͘#@WPg5ƛ}DOJ 38,5=yyRY31ga?GR W~,|۽ Op8d6 X.ty|XXAKh:O2#et'DX㯠F|z-öb6q[nOC)~[VIBfGC}@W26ޏf;Bo@0*pVg:, {|}Ne&Xqb\zg Fai $J<,Y݈tuJƎZ?AϘv]Yn͸]y:}T' _UO{"~0I45ju=iwOч(j~5=7GAvݩV N$J!Y)}t[Or>ܝ x'eZ~>F2zӼOȳ߂aOn y›ߎB7Џ7~4<=fv~!q/:!=׸8;j_t_`8'.?=pp5*p'mo>\߀нǽC{5q*UquTO(DdVqUtĽbxPc4iOHi%U":2ZyE?1P ##?ϊWD"KEkqM.wHģ?j[=ckIi!D :n\t[4v6Cd&d#/&3 E!B zx̴)lѐl,bE(!^E)W/*p1F{0+ l 8 Xs=TXÁ3Wx߯=} ~:<<<aԺߐ`,0 C3P;=88 8X 42= 8X\\\ \9xHAz ppPҡ << <9AYK:CsZq$`` 3;7aX N ̷ K+k u=~8Х` 0 L# 2|`~C}:K݁=}}b888885{D3&Μs5±.`5B>h 猑׌u \^ܟy1׀STt5I$מK| 00{ x-`1q]KgbVub!C8#.I-dLe̗E(d+ar r~9,&n&_`+GJ.*NF8 G 9cN3byU<97 ;w!._n'! +K&4=&7-/6yp/|~6ɕ&j4VS|Z:Foo|7wOs0PBCZ/Z#<|x1*"Qv)aӬQ( QjoZ1r#lUnQԭyשz*FR*]l @)C A5Rn k%6ɉ&tB%(CI%y-\][%( DӨbi9irF1>7A\%n$ #HI/ifh$9rɢ]oןo R<+Wz|]lo7;-VlA'ʭb.-+¯\R*C\V~5j+MJT,ڡvHKT;V.ijt=jtjt~_FCꐌ޵ޕQ{{"m6Ynm1>>ueu: 㭯egϲoLIel`]dMIP[ڒ)ֶLn^OGhctlulzNԉ2]TTOf&l3tt溅n!tKRй:Wf|/[j~QlC:$su.yX|Fn+n' u{^t.AAw!Qw7N,ҥTeLn6!ul{^Fr,α[lD8f'҉%N-ũԖ:N SWvtxySϩ';9Ni4NC9>YtZʮZZSS[#yzr yxB~_]>F{Cx&%^Wr&G''Ir*_Fǿ,{7ny+|@!–#ᖣ(ȱrJ%O"FuWE}h_=j&Iq5YMQSj?iQ 5Oc鐔xiıG&WQm!y {nyPbDUҿiW[KRkzZab^VYY׭5֛[Zmk;k{kkk[^vk׫tk]k\kM]oֹ~nrOI5]='5=3Nr&`6bxZ4ψRP#D+5ZUJܠ֨5595SRo5WU"S/iqL^Xf,+XdgY&{޲?y:sߦəJ.RJr+HɿQ4I&F?} d=hIv/kDDXG6 ɄueC8Bx)S#ٌ$l",¦RBsd PJH 4J~J;( z|@ $g:L4aM%DuK l%ۿ{ش {ڽ|#v%I=m#\hʱ_._&|^I~u{f6}{;;mٻIP.Ґ5us<=4~:,El@VK1+G/C2$h5'DJ$˷[!tz|oiFv/77&vgH7Gvw7GfH?EX{wCxΑ-e2P" %M&o{D}>'xFB)S^[}7z)u_kT`Hp|v/A@zPF~DYuL%[Ζ D$zi(Sh2E%$kE6TBr=~li{1Y+doƕJƜz9a"siIƌ4Č`FR1#^̈3iiiInj4Ōd`FaF21#1#YlHKC'XzhjUM;Vu,8)fLZ]%ʠR6*i&{ooJ‚.4tQ Z ˎ.Bqx"ZZH.02L8S1N/F0B~mD;QBW΢Lt墷+B #M$=O, ﻘ+h̿P%2ILWւ% IRJG<{Qv%y "ɷH,$"]OD{Qhs:MkGzEAh6l*6Uv ; ۉv`;i"t6$oPxua8*VSRWW!]=kn}`}h}d}ll}cκl]/:[u1:^Ӊ:Ut3u R|EXmu;^Ku\;["A"EtT^BI"D %T `TR"],WETPTTxuz}[esflg4 ͈fB1hv4'͏D1̜ܰͰ-0-3w,a09Lnճ0÷ ~_w*6 ˅U v\-Y%寂Y-U~-?I= h`ͳ {4~w 1110Fxj`X%džБYp24W @ sN@R+2\M+C}Pqdx_Z,  Y8 g6qh; b[ CB6Qr,b'[LL %{PEdeE^ĘK#QEɾ(kV}D2 + ܼ?-dٗH axA<}v@,N U `b+o  h0vjg`0^Dy1k/y:p8S/ia1yGnbzfyιDW6"vi1Qn:?4;9ܰ-5Cl|kT3fMBKmkSw:B6x~E#L,xvB3<(LAEI{ ;u+7J2)wЇjRە$# w k7Y/tލ}7uƾ%ɋem{++Ds# `Dt7aȈT0t8Ǟnkoy(OqRgh&O4ϝUyu&9g`DKlW*:|U6ן44vZ%|w]E`7grP’7(T,{~Eg<|zJſ=Hd:W8*Ͻz!rjqFL^Z^n5 zǷ/NL-Ώ=TP|lZ!e'<<3SsbZBñQ|J4dXsVd_,nG`6Y>>)Cm<+ן b'qd4^^!!V ooQA8Jp@JtKLڏdMsMn_RW.5}]T&m ѺTȕ$bFxrI2;n*zY/3T|Fnj3ۣ0jR'ǎ١ݥ\:agk1QQ1R"DseP$Edžp1]{6)d"`}6){cAH`M؅~TGJڨ*UQZu@ F\& J(HDaF18 zd]cV/@k;Oƅ>ֲ\x)cX5HH)JE >چba-:(uX|loV$@g%/I껗0Ƈ߀齛i9"-tH> i#heɗSDS9P݅ŎXuu!Eɞ|mӎ7,+'+i|L|50.#3mϭ:8e5l. Ks_ @2=|ly %I,|t{ȓ&[N_U.4IK*n_Gqv?aϷ"(/Bmwti>^&zD5zlJU3 J! f9>Ѩ)mH tn}JO5ukh_R=xt*;v'rU2%MqT I@oѓ [VEޟ (yumxkMq,k33NIWWh¢}Q`ޡ9m.L|re˨Ru@ZAVif$HM "NFޅ7}'^pߪ]P,gMB!]aۃ9?c__*+t"@o(0m~޶; $ҊN" wӴ='ä &_GDut ^S+K8~* X'@Z]97Bj9al(06.]1xE8Qk2zZSQ^{esQ~2{]"vE^\20,# N&˺r[ƂeWB>66L?R+Xv0飧ˊSX֠Uֆp ΀/@^ޙw`Hs_@PTߦWjH oH ?:pcW՟0 e0ˠr2Fڳ<)2PADsMuIf\rBN0[5;m+;bkZ3``~eJu %x Zs&{3jhhu }oWaWPce9@dtALk{؉%YdvVWdx{8*BwUF>ZSuGrr.7slg@Fi鮪f8W¨mar0:h|yI_Xg/PΎSZ~7u}X|f8mٯ׻^ED~{#ZQDR'A/u]𣟆ou"Y endstream endobj 2266 0 obj [ 550 0 0 0 0 0 0 0 0 0 0 0 550 0 0 0 0 0 550 0 0 0 0 0 0 0 550 0 0 0 0 0 0 550 0 0 550 0 550 0 0 550 0 0 550 550 0 550 550 0 550 550 550 550 0 0 0 0 0 0 0 0 0 0 0 550 0 550 550 550 550 550 550 550 550 550 550 550 550 550 550 0 550 550 550 550 550 0 550 550 0 550 0 550] endobj 2267 0 obj <> stream x |T}oI2KI&L$$dle%c6 YF*uPkժɀ4"j@R(ֶ.kn;R꯿?s{}{yf(<驒N+eRQqɯrqŤcwKTUSʼ1 eUIS>`aKZ/j~/P厱_iv(.X;3 @k\ 6pZ|ūvZJL|aἦ:'`yBІ_c^%WO5k;=.w-iZn [㲦%=^֥mSx"^zָeiQ:c̬\p9A}4`QۛKmCXWP}f+x+- {p0-و,_/%h*Ӱ<)F+ZAP$cZ*_ z 4+x3Pӵ>v 1$}%їFKoDRrsvi(}6ףlGYr/=_;wP|@G <+U:rYsuנzQ21V0zaǕHW@]o[]X@oAyu?>#a$'\~wXXяwH ?4}c08'ϥǙCJ3e/FsPƠDi?FH #a$0FHЀ{oIpOv^潏 rޟo4 8g` aO #a$0#00%6 0Q P%0C9@ X k`K2[ / >=<2.|fW-ڛeP5jX{Rl ۫X{O 1}3;fb`[SjʿnYP*|_jɿ͢u i¢ae3;a{.c169`=6õuVnm?қf? v`7rAzgGп(l^*3Y3j*+fL6uI%ER^Ĝ Y&&劊NQ Q`P*itc݊Wii"?v5aFӐFJίv4הa5%) dFG$&8]"5Ta"W#iE|N'(-,rY]baGqcש SǤSѮN6: atqv~Y].+.;rmUnܖcwt&e~-Yun O;:6M8W;ʷmyWQ;ޅMs+.Gʻz> 59\$ ut쀹vHIn( %JOot9T7V,7u$&8y!gӼWQ[u[*„kqgrojN,PQNr\T3|UɧNsw;(h,"y[}f8}wzRSQ2hoA勉;R=_n^=%&^)_Q> 6@esuQ'z>[(UF.hAa^WkR^$S Kz'QI iˈ:uS5s+y*} Zv=> >Eb4\9ϢrGkޅ6$wjkjEC<>+>3|)PXoSx|7ԻE˶ltC+T %w]u̡EݠrxAR.,jnth+ N9*bɢ wKڱ ~,_hu}=)/mUkz(fPN\یOf*ҵ WZnInM|=2NpMjs?w1^j琐wn`߇ 334s@$fBЎ;H؁"4l@مrM hMX 㫱j\0fS؈q# Xs=֔0nE'QQDa%Kʓ_+ke%bXi-n[1ޅ|^ĸ_NW_X\$c܊"ȱc0~QCXn9r <V` +e=Vb^2ƇP؈KX)/gKŤ˄E k$ίRӜ8)&1Q:f[+o`50cCrCcXXSsmyFNyض*fj5e5e,%$H]edXԓǗC6UN(e0gI0pEv S $B (" G%L$& YLB!00FH% ID"!OC#&bфQ!$8B8!6a'B6`!3D0 ?'Z&J # O g _$|ApS' N!|H'Gxm)}-I›7^#Ÿ DxpGq1/^"Hxp<9³!½{&M./ ; w~Ap;6­[?' L3O=!E턟n$@JAp-p a'$ q5m86"#%!\IXMXEXNC \AXNh#\NXFh%,%\FXBXLp aa!aa>aLKhX9ل 3 zB"B-P nFT* rOXaa'01cGL%L!L&&Jń"BDŽ^ ǘ#&rل,B&!NOGH#RɄ$XB"!OC#&bфQ!$8B8!`'B6`!3D0 ?'<! *  #xQPzQF9/Q@4g(|1G(GAP((PB9&(WU?r(Qe"_Dy((ϡ<{gPF9r)'Q@N ȏ| =re?ʣ(PP~=(Q<("(<[Q@7(܋rʯQF](DمN_wI(܊r Qv܌rP~'(I7WGހU ™!<2|[;&tK"ÒCXdضa)dGHv#21ٝJBF6Mlx{m%VƯhvܖCFsyYcl -qQOB/5Ksq%CA(31,5NÆ1!ҳK B>x1e^@Yq[mz):v+53l;RE[~fu2vc}' &F>n(LJ]S0!D?& m˯?c \m9؏piVڸ,ǀ3-B2sˠJ|q<8)q_[[:=h_fx6%ee<&l̶zs߄{ƻ0k{qhGm`:x`1}ߏ}Nj8b|PQ<7^?#sPFܘ=|ǡG\ yύS\4|_Y/&0t4x.ar k|uk*aZ]`fd&y\LPfgNbY9RX:d6%g`:3\ Y%3Xdp[rvkuY\pϫb&NWfFo#wtt/A,.;+UVEp?W Qq08aѨ UdAlN)N* 99xBuB^ y=,c9+=,鵞{}GLYI={Ri%(@p]bZjqck|Zj ܨq?VjɋU~k&5fe\EgL)b;Jח(L_$<10 c#3l?O)_w%&h a&SX,]{?{ʷ!5uRDj jDCh:$k j5P`KK2%%aYi{RMfj;nsw71%.ɶR띢St1de7siձM}O?j+vajG)#?B!T 8K:U)u~)Iů,sc(kS49q>Tp)Sww۴䎩3Q[[[<e]W^%Q}ڎ֊T;Eڻ͖< W^,N}pAц] [2_LGnxqV} g3(f=ʯss^'d]}b|}s 8]E[ _A<4pݞ֫~aͪ͟X;$iՃͽ̟4*xtq _KN^U(H,%4TM,:KJz{h<1A1z:|lp88Isf_l"nn ? Rb TRǣ7+$ QrT7O2O~4 TWza\3ƌ'䩖_ubw|ܕ LԩE3I-zhY}Kcr[k'.#VJ )m?x֣uv5ti}@rznqZ`Ϻv) ,>HceWh*_VkX,iHiJg ;m[l=atpś*jqmG?U>] 9 mht0ED-ŦJeRʠůd\iCw>&gGEM'DEeۼzO !,w'+P8CBⳝ섐l`7Y%n:?-@8FM#|6LrKs>QYϟoC7㹇 pËnI 4>aL7+E8-2K\ :uzG 80GqΥҬ|9[(Ɲa*{DaIHUS%MaOLVL`%R♛8s}o/v/.3`A4 o$d,kerYwA>vU;3Y9c Cxol>w:c n$C XV1?{s[wE]̳xW\Y]\jȶoX:!3LPzoZ}dkΝ-/˔Vp)屍ءy5>:,>bo%%\_q// <jYWe7sZh?|$d)%l}=mvy6JP"ڂ2؃+ƄRk &>!tyUv1VF{mͅ{>liԉ!V|5mHٙWVĊ’qܮnM_|6xO}sQ`BGbd(c`?mPFke٠?$iLZ/?kz Tr?ocNJ=-V*B_խ{gjR1u̥ٔ,m)[Ni?gFݪњ࠿ƺ&Xc\s˪'[GEE[BJgqI9}65Giu kg ebv3}f W}3!2ž i>'3e{(sy`S>}|)z.s|̐]/?50|D' eĞThsn==WK~)B5gbr&Q0}fƌ+fĊg.W+lOxi7UV\G.ݑQp0P*:eR0(N4jQ(EZ^g2|-Nݮ=f,kd;h5QÜaUkf=PV"ɂǨO5*Z7Ot,oq bZ,ӲeiQ\tEtz7+KPH 1!xa rrx{^*O44*eryb,yަKY]ZƧzaY-4A^QEj$:jeWc6oCUEo=9kw>6u:\eECvo="7i~IztsVCާ$3urt Ydi&sI8I%e(;тAN [b ,9^[:9f/ȳKUP#I"+OaI~7٧69 Z fAs6RӰFq^全bm?s'4f+9"sXބVⶦHr\%XD(oЭ`Bk6.R*.&?7>Q 2NEJD!ATJѦ}Z Μ&z^fa B-ΡDYTŁ|LA1Jsq*;k G(X{РR-v' yA¯SKq huN1W뛥\ƹ@ᦾ6[ãU25/?{*kZLOݺ##L"q@@^u if֟N_$gKn"wcnd敲s uQLH/ǖLZZܴn ?XƳc Vូs ꗒ.ꗟ_‡藘g+%JޢV[D\KauN5ÂhYlhE I[!X_ {C}UMZ9ABwbR K7DcEmf"격bgB Q dFS롻)_a ӪjuްIv^ƵT STQ[^eL 7~!=909DW#3ڃHG'R;9 PZb17\/+^]>^ONM֛rJ;*m+o~39RE|Zm}s]݌|ݹg~1tv$ojFU#{7X}f}XE{-Òό+f+in(J|[icV41Զ $\/A/w9")V,o gt3Xx;6vR,SW'%WpZ O&=]HWEwFBn~TJZrn=ۡ\n)yt&:9q\w!0ks0Ιc~M[+JL'zKڗٓUn/k/edt{'F8j)n9rWn4 }I[d+8-śmwP8xQOx s{s=x-nwe3x]wuK?ڷGG)ȟFz̵niΖ'|n'ϝ Z) KhFw/PPQ$cRlVB.ARbtOȩ7Ec)~({>t>Go}' ՚fc:X,p[X?U Cѵ,t d5pĩ) NWDk]+ 寛j=C=EYMM=;nڹ࿂D[aĪ SSd h Hߨ  JK\Y'2$sѪpu]Nm;֙tewfpTܵ׹&7'+4;-1_if-#A{BuZW:&C&i[B/U$̾PcUrJK 6 U^gZn-m(6[KjmK6lM0"^珀:$)x~4w5 tߑ12eC|4o?rqXp,<[X3sds,kwF-|>p&6(}nu Ĉ<,u'rn^ѩ` N. n e=oD!m"+''Qaj($(m?1sfw DK-,z~p&Pka'範Q7,8FTJ'#]n\!`U*5=;+X@Io5خ lW Ev.nMUk,= `HmVdK_f@*f?{Z+XHNΪHצU[%%CAӔQb]z{<9AKUԆO6ZS rWWq9wT)町$)b-'ҥi_&CDJeHX{bS&쇦w=Ja_u zjP֓( Za=Tc:dG6eENOG"l 60nIJEhÓȆ nϘP`Pt3[NJ&uU(f67kbvҿ1TOVw)]Tb9CCR&sunL.jUW^pu٘U S˻*#X[aD,HZ kL|jB35⑃f#A{M .w uz*h%Ih_%tU* }ZK,{e+*382sdvE;>أLK.3`<$ ejv{ݺ4'˭дde2L4ݑ(^Ҝ ΅t{҅*SAQrܐW˻[S u֊]u};vM{i\Uݨr%Mh뷵5NNd46<4>r #p֮5+@9&23+K=^ߩg}Rٹ )+k/˽"+߅7/"=r )I݃A=9G};%Z<%CrŒ3q4'd|ޡ`Vפmyk[KF[gh**oIWVȽSUNUQH*^אlqfW ʺjx L&)Eae 2o2/ъjF:J[Vc1Z$aΌi $[P0(2g*+\?bGУ$F/pa=cpaG{pd1ISčY'"4[ |*''FKH8Q=5^@Jhs3)lXZ35r)ΏUj:!Ai:PHe(-ڧm8pNVw- Wu&oldѧko\rZ+|"LR0+ܧV#bX)htǘm4{&AŎe 86?dhǖW,_`Y;l݇FVſ`+vhT%92?c3΀>v̪3*)KK›?}'L* gﶖ+Zյ2-|Sm}}mﭸ1dM=[qyMA~mm~A+MR I9溃Fh@/ '\1 :n c#HҪ*xb%[mj  kEJO}:uI Uu`#FFgJ::`DWʄŢYǦXV6~̶υZTD ^W]ǔEDŽ/_'wIe47 kf$פb}tŤ1ejIjRW~/QMg BX[/w5+ŅB0ԉKx1;9ޔDGKKXWf|̰3æK &B5vۖY-Ir&$}R.KR GCrG^!l0r6嬭^ ^K5?vſ-ؕ6_ ¥p)\ !TdiSJxt$<\rH9,yA%*9-R,U fKye+%ݱTOy5ʗ͈|sנq@WY˔E#2k D!JH+NK!"/C;N4"@:M+GbuPfXՐ+"4Uj?$)D= g,^г zxA/Y= g,^г zxAϏ ˀkG>K8\MR4q<ꆴQ4B^Ƚ0lOǡG4uy4E%9@')QZ: ^nOAZyA"sʞK]qz ry( HDC!Zy&H?O'c:$rk *ꭟ3 )ӴE=SMNRNk'#'=4"0MyQpS VS[im=#ٞ:NçmHQD<*Y(N;!D#䮀K-iK}#*S-K$~@$-yJڈhѸX'/8RKZVHmHZb8fUηմXF4'x_wf><}zbE ioxfKE2()>c~va{ 4 V+li0\ ߣMA|a?]#zl؃z '"RAXtQO뿽b,@i p\ REFݑj4QR?zzj1>"ljkXlDm2rybģfJxx$h ab:RXlN/jPvH%#br~;i-o,pYs :AՐQhغww$4kw>f\8>I%O(KI]*7/TNM **%:Z,}zS{.}_IY´דYO-ϧJ*sN}6@J!_phj"!~I-&&CTIq y7<[<Ƈ<^~7+}[|`|oN}$g!?BPh 0 |C^yrq np*{C!~( zC0AX@=  }tH8 M{4ސocDHG(s<N@a0HgGrA%SA7HBDT7>PH| 5|h(I;'?@R0԰O^?Sޠg泍 5+P:_Q\V]DnG]AA T#oF]~Q'8P&S09T65 ' 'kh`s'x9ijc۝Ca-bVx-$߆}P@>jK'| cg}1Ɖ5d b>Zw`EDS7 )V;իX>% Vh'RZ 0&Jz3\"_b j w35.&G\݉YC% ;4/Ão_a\Wz |n7߄W ~5^ |3n&ߴ-k_ߊ[omv;px] n z |iAY@9L+s2Oe?a?,{!gvD,Tsjn 2/k~YOY'2xVvVd,"Nva9VxF |AX*UU)k_ٕ-V۔dgϠ"!gg1 З¼UU?g~Ne| Q(c1ϰY {=G쏀>>eec]]}}@ϰg~~ccOAC6c9%$@eS Ti8P3gj@m h4Ke沁qy@ E\P'Zʕuq.\* h5W Z6p @&8@n Z94:N]\z}\hw₭+e圜*K?JZR5rZDy"P*!X)T %PRI4~R%z#z݌!vh{pG-l#7ydD 8AmȌ5ֵ G=ݭW T"'!rR4d4A}SzwR8)}}b!bR VJ3(-{DFRgT% Dh%z&bg5O׼do ײfǮB)6HצMµe?¦ۀHހ~+ @w> mw@K@Ae?=mO>.CK>o^Sb|≸ *x}⿉eG+s[bXOCX#qo7rumB*!ď EeHCɅX TwUfk2D^,< j͆X(Z&ޯEԺ "'!inK]A샸 `ulg?Ecrj;cWfj!xć CƮ6{D~$%u1%:?RKa6v}!~ 1PxmS m:fmlby` nmbcmo =޶ݖv)hhH?6CSAJMq,OQȟ2OPJJ/)}=J?#BW)b)*m>5> ]n?4^~]? @{T̟Q봮h]>}jԕ~Jo|AΒ%)CG9ƟR;2HbAPrIG9S# nSٱZ5-Ftt8C@&л)yc)WR 4e+ia )/G)&s; ~P{g:b)hlj;b 2 er!=y>F>ᶳ@_ngl^nאv#7ړloҔ2_AJJRd|M4ecq9)ҝ4aGǻ~8XHtpRF:u㝉@G( vZA:q N;y3P>Ғ%|Og%mc);:/{gus__BРA,QC;/%: K!Zc,5UZPZCXC&khj]RXZC1c!PkP<{Ubپz>{yyιseL}hfe{bMvWfSR\UVICg/טmK6٫Ȯ%; MVkY-[ɟoފ6o1쬧Zc_^˚Wn tPik,da%2yғlv;l=`(^ԥZ=j4k+W;Ks\}:+ˁ.@CzGKkp>yEҏ-˷S;wOGD3p4Sx'z̵w:|,?%pwFs_Z դ}g[ov^};c gebȟ8{y+Ξ qp |xIϟ v/v˯$+5+,h %_˫X~]p8 5NFLsQoFhV)YlV-Bp,X]L}42F B !sQ֢>*>9ኝ-۱R? 4S 'Nj'0K4jO_SJ5sEn1jތ~nHWI3?\a)=\r̝|.?܉A]?6*nʰj##u?L]~<8syO;<e05ֿ(_4/1#g 4s2f7uUΘ͘_B-_y~2y\CS6*cIʠn`2sq9ٚ@Z$I.u3wX}iZ526Њ@rX0w lp_fxyBWaHp?H\H730"xwvn‰ bSS}`XB¹Eݙхt'[H*3g!%y52 ^ɫ`œ 2B a- 3RF@4YA0c {3|_Vx Lc)dq} <2w֓.~ƥ閎Z6< !xWC* ϩ);C®%nWzϦj:Nܥު9Rk^hw[?#$=\Q#rO?+քiG M(.(WqtG+S[οoǍqcϩ׶FZqv?i}8sGӵ]K~U>.'kçosm~|y^y5/݆r^wj:w׿CQ4_v%(d$uLKGAt qHK2f:2SOE:ےx*w8v:ZP>qOSᎃÆ1< iFT*#ѩ:C)ƺ3u9Bs  ]hs,j,kΑP\)fG9(bTt3rl3vGGe]O}[CehuQȤQSeH׀@:JQsltHM9yJ"csQGs ^Gd|*95fǥVB9 3 9dLc.#LJZۅGMp0WQD]q+b]qt&ZqˠrR{t^!WOhrvJ)uڰBtfj\+)dWkR5Nk)rWAZVvKHVn׵Oy7:TF\ .)W#DZu_0:'d7BRQ*wwrG55i+)nKmwOtOqȭNp;)Tbb*iKeTg==ߕ^v/spru׹7yA"l.I g8]D$tSM6mj愾>=Qbİ0)DRrlb,okujBtoj #GYE ]?CiwUO;-(%4 )a;q|nx=^x=^x=}?~Y̿|buZ/91n;p?[3B"(hDS(&PtRLJG1b!+,|{g>ηBՃ(ҭk)Yv/7:6Rlbe:*w+}S<8aǬ|NPjﲟRjb䘐11cc1IbIqƤ_LNL!bIHNn,$z6>7D7EGosfN픶GOEt+!L땤+/ YP +4TQ*T:ֱj:JĨc՛-,ubVX_ͮ$6gkO `*1W.bj!A}N8<=Hs !YA~ B43 P/Z84Ñf <^Rgj-E _~ vmYNˉ4 ?z[qd8 mxGa܏CD5H8טҳf߂K752i$ϛ֐~i:,3G=c+&%d-;߃q5-azP#j?NGܡ˵F9IZ,?7PXE{"e!jabUor}FRJ_,)ՐP/3)*0ʿj`4{Ͷ<KJfYIF ?ɥZQDmҠ 9#w1(P|q~}#,>V>F|*<>̔9V /LߨEz6.: 1'qМMW Oeh΁?_~&8D`XNF_?Q5(~ eK,iih&qz<<߇(O_qlʖ 5@8?r&/X itm*^PASFNW/!h!ˋhج~ f[dLrMlӶyF},u :ijJģz"4V_b]臱FM՜0#XIq~ZsiY,kWl\؅WB sYmoc4aKukGxR͝!Uԯ._̻ޫ8jY}rrO8<مHs;x/l6R e~ vJ b?g؂6f_G?v E HQR9rlx; )'^gw`ȝF"7> 2OE^:_ga ޡ)?& H/c$C x+xw}bPkrgpohea hpv.PF`Z2?w#Џ68hnf4OpԯC3,pI G51VT;rR:xS LT <{ϭ1締9k PŨf22ڡm2 ͯ.V³ 9vFJ8k߁PxvЧz#8dJ)ͰF*#p:z0vF9J^|Jý`"ϋe'"N ,HKH> ͲRf*-'B> ցg89pky)0U=A@Sr(0{*ƭME]+*k^IioX83&];qU8*7/G |Sئ " qgD;D)`rوvn㡷[m^mleAH9zecy@1E߾؍\x(JQ(wx$|Epzo;ܛr .rp Z; o_(B˳>5K_m>GQڲ9,V%r_nk?J+j)Kξklk%'P[dypf5s5?(( "kn5p'R&SLj(dF]]㯁Ҷ?i.lb9k sbhmC]d)T J8)ArK3%oIUR\Z)5Ǣ䵎scu`Pdېu:!Ѿ|X]1mމ*r$3sKoJ^tQD,HS\;R (4{Æv (X{Y{[{Y&=9˜03L~y&ɝGq">JY||Cʴ@SYUf-H㪧"Uj|ljWO<E8j>n&>n s8ynd*&_Df"S{{GCwQ%:~^W&*A_8|/g1p2Y\e-@"S_ΰ8ga;+xH3l3" %ͪcn"krƆ34."nO\roSx_Y!6RO˧S 1~)#pg1J8F\rs5Q$5Q&5Ao9-dAkE&\[F v0.@(V0Ei` `hVhK`i,CeV '>@|@h+`eB;D+Xh`uA5V &Z:D+Xh`}l@ V 6&Z&D+ؔh`slA-V &Z6D+XBmV 'ZD+ v$ZND+ؙh`WF݉VpWAD+ؓد IVp/ܛh!Z}V %Z~D+ 'ZVpy6h`Bbo?\O(o@.2@>21'g`+ 9$8 f;x_|~B~"~xy?|1y?| y?|)y?|y?|9y?^í`%^ րFg l l͠ Gax)f92E#rD@='䍼1A} D>"Ԅ Q3Q+j jCmPcPNE)(Bi(FgY(ERP eFQP:D a0TZD@e$uPwu;SPzL=jS)T^Qz5w;ũCmNgPOPP] - i9Z 4;ӝ FASZւf. i}ZZFMhhEК- mM[C 7hKvЎv=H;Bڙv]hW:;t=hLwC=ЍE~i؍`w:t{Сt(TaONzsJ{K>,2/+dЇ"JRЏae`?VJ `UXȪj05aM`30D, H,Rb)\5#ꑵ_uh)ur@9_f@f,fy^ ¾BW@b?aIWBb O8>8O$+Lb O8Ǿ8$0ľQ$F$q_a}I+Cb?a G8 p Dƒ㑉ᑉ呉㑉I###2Gd"H $<"SxDxDdddL#L"DMDryDxDyDf#2<2xd,Y#GGd Re<"yD yDxDVDfOYLY7))Y#Gd-z <"yD6Tl#m<2ydxdydv#GdH-H*:H%񔚿^}<" <"<"yDi9###rGG(1<"'yDNi3<2gydȜ瑩' Ds­̬Y%80&$ '0f,s 8^F䗌ù@`~ #sS` T X8N"8 f14̃8KGA((~142QQfNP$<:F\_ϭFHo) ;ù 85@+R rE_Y:a~/c8 ]p@W Ta9njp3ԱݶMZdKa@]2?ǭ5F 0%0d1݀Ӈՙ Snu&`$9"`&0%"K)gʁ[ r/;n%`1u[y ta2#pb03#qV^\q.pn)Ҹ!["n cOao {aߪ{Q+8/{5?0a㻉3OAR31;AM3ļ1+AB \ǂ 1 A@i 0&aBÔs?,X&aCCBÖ{(k՘G0; jBͨc:NT-UO!0BNRwC1zEQQO4M hh3FkѺ>mD%mMKhnۑv]iwڃN{ҽhڏ :&(BbVȊX)VcX%VUcMČX(`W z^Ya׿|}0XQSlTkp2Jq\xwz-gU^Uy ?fu~{{tLgA|еk-6SwF yqrە'}쬦L??+;/}C,[KO9μX8IޛnlOSfTlgB:9`m%E׼EJ֝*Ŭ0RE}f&ViTfȻ\7{f>Y#g{wCK3sn}ڀ&yW$AחMf}uQ &E-K `g[@걨ԍy=Jm]Eu]fn[pO.^Fđ-- X@c!Eߠ 9J~ #w@wY۴M C}6bU]s=gE oZo+Z3͖,1t|BacgxZ_[S;ס9%6թ=Miq32U gӹ,tKRPIX:_-+͒.1ʲf՚#.'QU1 zy}BƄ/m:#q,昱cx ԏ</c/`ƱDŽ#qqܮ$hyO%ה]9]* ~w)f~MASUwqoU,6ϓ\g7S7ϊ9ݷʗYPTp"ġ}9-HVS5ޟx(:\Ĕ5J2F5͙0.^{_u9jckOڒt)#WܭLitcltiTf <"}^74_${c u.{i޹=&{_=S${)4g8!d@S쀉<׼d"kq-7BACBܴ!nw>7vcm|*fޓKCwI\JJڏINNp ObCXqQ I6^Ѭ!I/w˾Z(9%]jO޽?IaɕI֬o{^YTyPCz>?(㼢D& wb˪חT"82qbtx_Ԋ˹ܜ\m?$l)U+'V;`a~-LCw\lOp[l'ݫ89ܲmޠtzxѰ";YuOta[ˍ=>K/kb5J@^ܓ^-^>;]{}pnwZ,KU6n8.X}]n7KEԶ^ةXWVaxҤf_Qľ1֮q^'{ @+rϚ*|dGR?~a 1qGlDOȥ+Ϯ+~84?T𪡘= LiDW2V3SF3Q?dC:YNh}"Jؾ2&nGa_uHS-u&[>`sbPz{D\ˬIM'vYPS>Pn'XR-PO#NGzS/tl|~?awSmǮmhڣvgv ?xRUoīnUIz竫Cf,Shj\4raI}jWNwuԠ]nx~%숌py!+'t!ՋT*&NmeӰ>:)9#ͼ %vnwo Za{QNs^/)jۚz6v׶YLR̼pTXwiEW{B[!Ő8/)l;N|ۓt<"1v!m}~BkNP8}0fGjIDKmJBJ3LA? A"'3Q  h|< 720krjBİ17: ɗ^(oW_R|ǡb[椑1cgdKaٱW޹J'+ٹQλ.`p>R>o'~.ˆ>_ >zlM[ny۷c'6*1d6WVyhfWYO~(Ru#6:j+5kJ≯rzvs~O[5Q֣V7RtLrt_t9{9.B:,F,$.'w !$=Q۷@V?jms։g#9)}yiإ۪h8~`pXѻʛ37.%:12}uyض!)sbj^q5 R,^^*18N9|1YTO#r\5D|pi{njMOJbiiY// RN%ɯ7:bE+o>;8⣿ .RNz?Cq endstream endobj 2268 0 obj <] /Filter/FlateDecode/Length 4753>> stream x5ut]~+ PJq)Z܋KVS];7=?x69>ggZ3=zt߱{E.z[tG6)EsbŊ'+S(zNs\1lm(fV:A1X8b~xbybx1RbU,4F1d:\],|C`V,:w*xzXbbbˊeeC]^-)?Vt+yZZyb#Uvu_\ 隭隭ݧX%X%XwX}Xbb=/6;G׎ގ-veZ\U:sOn^ow{{ <_8gB[;=Y wYT&*8pK|USqO?]]1»9;+Z8혚+.Ι s}; ³_ K|nGVoՃ[fy;xե{|x{xؤx{FGao_VVfޣub3{O_|kvRWCe*Qn}db]E(\3gq8%_ų/\|[XGW.t}b5/,xزnбJ5: ^(돚+߷8a!Uw~q~ݨ;㚚w.guqi+q=uC/_]'3Z?og(ߔQn Bͣ ׈w}:L- to\Jf ,.nVoUB:߾im\oMtMY1Un)6,iѵǭk-kw #[B}&b׶~ʶwmW7W@Jv+ѵ DNu=v]V.vU߮G]ͪKרtp:^d'gv!Qtb4tat0clYF6b<9Fk4yFbbL0 &3hr Scy4az̀1f,~Fb6̎90sK2hn㋗kt|FW͏|J2Zj!F-lt"F-jtbF7 5hq0hI[2hiی1hY;3hyV0hE{V2heVX c 6XclX}6cl1 [`Klbg숝  cO Ǿ`??A88Gq"DZ8'4p2ݗ8!NnV.6mn3txmYܦomVfm)fUxmƵC2mVfNЦL+mZ<q?Cx<,Ɠx %<^x/&Hxc|  K|o5w?_+~ǿ/SDӖYĂ jKXĺ QXĺ  Xĺ `1A#}G3 T;aGأΜ(z=R0悆g^ ,0ba,Ű4XKa,e,ee_D15E"ŨaT-QLE"`/Q(F#|QbD12ዪE#_4.Q F)#|H]d0JE"Q_/RFѿ_/Eѿ_{bh_/Vm VmVmVmۖm ִmٖmۖmVm֦mQ֟mVmVmqփmVm9Vmփm֊mYEѿ(^/QEǢxQèa/EѸ_/jmE"Ѹ_$25FxѪ`4.E ѿ(^-2E"3xnϢQOz=zЁ1ЉЅcbB菱1Ǹ`"LI0)b2L)0%i0-3b&̌Y0+f1',17c,"Xa(Xa],e X+aeUVXkam !Fcl-90l5{aOv.aw}/ñ8a88`CqFp#q8qN)8t3qŸ|\Kp)r\+q5z܀qn-v܍"^=~<#xq<'3xyW*^x oux#|w3|/%;|ZZ~/w/ Q(^,DF 둭ŋ(F"`d0ŋE#|Q[.6F qQ_D1E"|ňbD1E"ubD1EqbD1Eѿf/RuVEѿ_/|FLS*Eѿ_/Fv#‘Yt,QF#ƨad0uVE"ƨa6QET$+݌FS#ňb/E"Yg/Eѿ_d7REѿ_/Eѿ(l.RENfD1Eѿ_/E"uH].zG"uH].RE"uH].RE"uH].-2Gѿ_.R F#ѿH].RFѿ_/Eѿ_/kjѿzV@=tD=utb4tat0cl 8a|L 1&$1&Saj 4az̀1f,av́sañy1X a"Xa(XKai,e X+aeUVXkamݰ+vXcl16 c la [cl=v ;c쎽` ǁ CqFp#qNi8Gp.\p5V\p=n 7܁;qw܋Ɠx<3x /<<^+xob$kx]6C|O~ |5ߣ%gRD\iw??aE\ѱbD1Q(F#ňbD1EǢjѸbD1Q(Fѿ_t,(F#ňbD1EѪ(Wt,Q(F#ňbD1QEqa02uVE"ňbD1Q(F#ňbD1E"KbD1Eѿ_/E"uH].RGq_: D^`1j݌(F`1j݌(F#ňbD1QE"uH].R݌FSѪ`/E㢔(^.ŋDF"|_/E"uH]-E7#ѿ_.R%DB(et3Q(Fѿhc2Q(Fѿ_1J݌(F#ѿzd\8DKE"fD1 F_/Eѿ_/bis\/?9z/FGoA:10&l?nPnB0vs\7Ѷ7m n&Ęnж nT6~s\7b:L0#f̰㳞㺙 c mg=ucsgj mc vn-mfۤvgmm?fۈv`melY1laCeIٶPmd=u*VXkb-u.b#lM)6[bv;`G쎝+v. b=Ab880C1G8cq18$q2©m=l3'nƅ8\ p.ǥ2\+q5f܈qn-v܁;qݸ^܏g Ãx<8x/%<^+xoU1o- Gc|O>?k|o-O?EO+~EZ¿?RMEx_/vAq_ ⥝D;ΠxѸ_/C;N] >> startxref 1263043 %%EOF xref 0 0 trailer <] /Prev 1263043/XRefStm 1258083>> startxref 1308587 %%EOFanbox-0.0~git20191115/external/glm/doc/logo.png000066400000000000000000000204051356361734700210420ustar00rootroot00000000000000PNG  IHDR+tEXtCreation TimeThu 9 Oct 2008 20:48:19 -0000kNtIME 5KK pHYsiTSgAMA a ]IDATx ՝U]}Ŝ0p1 *"CX@ O61&캉1k=]gxq r_}8sQU]S0L3=]fϧ{Wz0R:m0fa3İFbX #1,`0H a$0fa3İFbX #1,`0H a$0fa3İFbX #1,`0H a$0fa3İlhN،P-12P4VV%Mj{@z aU/=C+ax|h  ,G[ G --W?[T車'8 NtL:򌉺&<TvLA}lFAA+0F 1uTbfWE%tj&$^fT}L`"{&rUz] _T,pWN,yM%t *+=gU&qPⲥ؀IlrmP?@Z> @p` ITj -fZBZ jFX+U6,đ&2 ~ ]DCTx);O qd#B!!]p(ΟfQ[g g$3W((V =LB:4pp9pbUTDHV3QZڧ0kA3T^m};mjwܚpu}āe JwjFE؂aUrt Ss` u",`keTX^,{`{gyo;nPQtFb걓\``!Z<RCK1kpQ70 *t'axYǶTXC yD-t "w(NCz>6j"`V)`Vkg30n3 1F~Wn-`!>z 8m׊bmZ9Y٧:'#iP<\6=P zPzPK./=&&1>n&06=!Ion۶y[Mu;?ߩ%&sHD. yMBՐh`ypT=`f/Gy@Z>=Z[mzYYⶬF7SI1jĚ$fAYQbvTtF%SgdžrzL$rebM\82+c^Z6 [ m{ElZYdre-HԴuzDP%!4PuWo1px/:;]2[v'Oً? 3@Hz?NV>ʏ cT&a67{0' '>T k޿D~hjHI`w҈G EQH&O 8miTG~b\Up`[[Z&wN1a|@Bw(!1I6?{+ 8 jN_EtzN=3i KU) x|lS%ͯ5Rt/CV'6Շsv!D !᳏V wi, {t~' ulVx\ 'N!i˅Gavq%KSoBlՓlĵ!-yc ?>xuڜ8h)ڼ1$K(KsںUy*vI{^Nnls'ĴF!^[C|==Đ3q0FԦI["εο^{u[7JTnj |PT z.;|z[J!'~١$s#? 8m$K- , \l{kqy;j/oo">C۞<=-E bRDnVD2Oe)pI_&dq*wR)y m!ƻ8ʞlGJ,mn3%WdjIwm[8M`—@VIB4g&H׈=ˀuIarpPë>րKyy^%m>dPk"~4G]kmV?LyxGP_*n5!0Lg,v-uxJ& S23z.PYjw+XHBKc it^pxRs~L݋I*]=X4jao!'vF㕛##Inid|EVLxhM섀 qwpolas\ wՈ9?u}V?Ħ? Xp,ޞP{7*=I19ul{Csi&:Ϧ p0N1`"p*JP29:[kw/pǻ@-bFןsU NԴNs]3359=bt}G!r2{aN+qYD&/vƭx4RJ.bï"/P{zaHniDNw{F9/#5;;uN:7$EN[ P_nnF"wtB@/yȼpsrد)^+O*Drz8TZ'e X~nI14r$['?jO'T Hum'UVy3~yQ[]@>?p=@BLNc Oh~vݏ8"'w~g_l?dR YYbb~oNptmCt,X]뚐F\1_:mI8 byۖ9)$<ѵmc.n>G\ "l-n@gWMF/ۃlC*%$N֥%᳸b 8mIj i 9Xn\S BJJ:'^γ*@,TEff(SKMOp"lt&\Hd-I-um./<$-:5M@cgѴ=hzliBu_6{HDbGO  |m /0ov|\ V_imF#^V6jUF3%h2BG57߯jO_1X'Cc'hUM^z+1 2LdtD\ }eZ9[^D|=D OD7A/ E]!})"uiq3,/S')W3FG6b q7ME43FԤ<ӏY? 궒G\M;m{ 7居͐r"pwRy>[7 E糳-/:m;6E)%ⴅz`[Ag>y2~+= V}xVO-cs'w=?#reN[X>|ߍx͙ ݚA<3SEu53Z"Ά`^  x-<:9;z:E&X7P|eyae& {n⮕*2 vR/`5A<7׃`32W~lFQm֗6TGiګhEH6egǛ_ .J+wxV O gt?r^oe-?\ ,Y@ɇN[9duuej7ĵE^wNmרH;P]+M+pK-^׵X >EN[taD2'& ɹ#+F+`6>Bzj~SS /?[79iY ՈoؠMlcSMa?s7J2#Š{6t1?yXO\i$i+p^ë"jʽ yD\-VF c՛h`ޣ&ً-`ρ#DOߑA,^BxtkҺCO? \7n-`$0$dDyN[u.e%c$`aF;cę@ˣZH^ўve#nzŃ̾2px: X969gU/<0vO=/I&]-<OKhH\"'%n m8[X+ɷ)nn,0:޽/I;αE2a+=0**RVrsڵ[vTHStI,%M'` [ {5jokUHDCkiILB: }y* DR"d/ 3RuV­(mKR Sy% F+?u-Ԗ%Ԧ R:e01f>̿nn[=c!+>t+GSM#!S=l3 ćV{GV7Mm-Zq/=#9? cʽ̭҇qmi(8MNolR~*O<( *tBwPN%zoRTĖuG bޯ#`Աa4)n7yQl &i |% NHIxJ'#DaL/ylӱOal[g;zD˨a*kprUSnxUµ1tIC^ˈ=-3+t\fnDU+ {B`­&/ {CwJOp3a ,`۳Vk$$d&D0b gh=c3L7cP{%؇<,$RYy_c&]AZ#TRKOpKLTR{PptJ5,8wyB=*뀡s<,2NXmcN"6mWAT>`AǦ`߫`!W9h #I Yc NMEQ!w`wi^9CtM!CU䏠{ 8D'X'>2qC>Vq栊Zz[z"얣lZ_bb =*N$Nn椁&No5pc1`ae*¦z6LÄ )mw5Q0D>あbPg 1 hJrq 3bfJVV +Mc{-)ۂ>^oF;4@YE³"9CUdW`p,cBh<W;%:1宾TLS{5$zz#B2k$fl%OU5zjw0sjiAӭH^ftfRz[,D-PAZm Y ؝Xԅ؛fyD$h=7* ZiPpk6yoŀf@+A=zl$&ʯ3fa$0fa3İFbX #1,`0H a$0fa3İFbX #1,`0H a$0fa3İFbX #1,`0H a$0fa3İFbX #1,`0H a$0fa3?I[ IENDB`anbox-0.0~git20191115/external/glm/doc/man.doxy000066400000000000000000003145771356361734700210740ustar00rootroot00000000000000# Doxyfile 1.8.10 # This file describes the settings to be used by the documentation system # doxygen (www.doxygen.org) for a project. # # All text after a double hash (##) is considered a comment and is placed in # front of the TAG it is preceding. # # All text after a single 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. # The default value is: UTF-8. DOXYFILE_ENCODING = UTF-8 # The PROJECT_NAME tag is a single word (or a sequence of words surrounded by # double-quotes, unless you are using Doxywizard) that should identify the # project for which the documentation is generated. This name is used in the # title of most generated pages and in a few other places. # The default value is: My Project. PROJECT_NAME = 0.9.7 # 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 = # Using the PROJECT_BRIEF tag one can provide an optional one line description # for a project that appears at the top of each page and should give viewer a # quick idea about the purpose of the project. Keep the description short. PROJECT_BRIEF = # With the PROJECT_LOGO tag one can specify a logo or an icon that is included # in the documentation. The maximum height of the logo should not exceed 55 # pixels and the maximum width should not exceed 200 pixels. Doxygen will copy # the logo to the output directory. PROJECT_LOGO = D:/Source/G-Truc/glm/doc/logo.png # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path # into which the generated documentation will be written. 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 = . # 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 causes # performance problems for the file system. # The default value is: NO. CREATE_SUBDIRS = NO # If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII # characters to appear in the names of generated files. If set to NO, non-ASCII # characters will be escaped, for example _xE3_x81_x84 will be used for Unicode # U+3044. # The default value is: NO. ALLOW_UNICODE_NAMES = 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. # Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese, # Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States), # Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian, # Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages), # Korean, Korean-en (Korean with English messages), Latvian, Lithuanian, # Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian, # Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish, # Ukrainian and Vietnamese. # The default value is: English. OUTPUT_LANGUAGE = English # If the BRIEF_MEMBER_DESC tag is set to YES, 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. # The default value is: YES. BRIEF_MEMBER_DESC = NO # If the REPEAT_BRIEF tag is set to YES, 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. # The default value is: YES. 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 and 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. # The default value is: NO. 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. # The default value is: NO. INLINE_INHERITED_MEMB = NO # If the FULL_PATH_NAMES tag is set to YES, 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 # The default value is: YES. FULL_PATH_NAMES = NO # 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. # # Note that you can specify absolute paths here, but also relative paths, which # will be relative from the directory where doxygen is started. # This tag requires that the tag FULL_PATH_NAMES is set to YES. STRIP_FROM_PATH = "C:/Documents and Settings/Groove/ " # 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 list of 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. # The default value is: NO. SHORT_NAMES = YES # 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-style will behave just like regular Qt- # style comments (thus requiring an explicit @brief command for a brief # description.) # The default value is: NO. JAVADOC_AUTOBRIEF = YES # 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 Qt-style will behave just like regular Qt-style comments (thus # requiring an explicit \brief command for a brief description.) # The default value is: NO. 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 behavior. 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 behavior instead. # # Note that setting this tag to YES also means that rational rose comments are # not recognized any more. # The default value is: NO. MULTILINE_CPP_IS_BRIEF = NO # If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the # documentation from any documented member that it re-implements. # The default value is: YES. 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. # The default value is: NO. 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. # Minimum value: 1, maximum value: 16, default value: 4. TAB_SIZE = 8 # This tag can be used to specify a number of aliases that act 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 = # This tag can be used to specify a number of word-keyword mappings (TCL only). # A mapping has the form "name=value". For example adding "class=itcl::class" # will allow you to use the command class in the itcl::class meaning. TCL_SUBST = # 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. # The default value is: NO. OPTIMIZE_OUTPUT_FOR_C = NO # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or # Python sources only. Doxygen will then generate output that is more tailored # for that language. For instance, namespaces will be presented as packages, # qualified scopes will look different, etc. # The default value is: NO. OPTIMIZE_OUTPUT_JAVA = NO # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran # sources. Doxygen will then generate output that is tailored for Fortran. # The default value is: NO. 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. # The default value is: NO. 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 (fixed format Fortran: # FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran: # Fortran. In the later case the parser tries to guess whether the code is fixed # or free formatted code, this is the default for Fortran type files), VHDL. 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. # # Note: For files without extension you can use no_extension as a placeholder. # # Note that for custom extensions you also need to set FILE_PATTERNS otherwise # the files are not read by doxygen. EXTENSION_MAPPING = # If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments # according to the Markdown format, which allows for more readable # documentation. See http://daringfireball.net/projects/markdown/ for details. # The output of markdown processing is further processed by doxygen, so you can # mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in # case of backward compatibilities issues. # The default value is: YES. MARKDOWN_SUPPORT = YES # When enabled doxygen tries to link words that correspond to documented # classes, or namespaces to their corresponding documentation. Such a link can # be prevented in individual cases by putting a % sign in front of the word or # globally by setting AUTOLINK_SUPPORT to NO. # The default value is: YES. AUTOLINK_SUPPORT = YES # 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); # versus func(std::string) {}). This also make the inheritance and collaboration # diagrams that involve STL classes more complete and accurate. # The default value is: NO. BUILTIN_STL_SUPPORT = NO # If you use Microsoft's C++/CLI language, you should set this option to YES to # enable parsing support. # The default value is: NO. CPP_CLI_SUPPORT = NO # Set the SIP_SUPPORT tag to YES if your project consists of sip (see: # http://www.riverbankcomputing.co.uk/software/sip/intro) 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. # The default value is: NO. 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 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. # The default value is: YES. 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. # The default value is: NO. DISTRIBUTE_GROUP_DOC = NO # If one adds a struct or class to a group and this option is enabled, then also # any nested class or struct is added to the same group. By default this option # is disabled and one has to add nested compounds explicitly via \ingroup. # The default value is: NO. GROUP_NESTED_COMPOUNDS = NO # Set the SUBGROUPING tag to YES 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. # The default value is: YES. SUBGROUPING = NO # When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions # are shown inside the group in which they are included (e.g. using \ingroup) # instead of on a separate page (for HTML and Man pages) or section (for LaTeX # and RTF). # # Note that this feature does not work in combination with # SEPARATE_MEMBER_PAGES. # The default value is: NO. INLINE_GROUPED_CLASSES = NO # When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions # with only public data fields or simple typedef fields will be shown inline in # the documentation of the scope in which they are defined (i.e. file, # namespace, or group documentation), provided this scope is documented. If set # to NO, structs, classes, and unions are shown on a separate page (for HTML and # Man pages) or section (for LaTeX and RTF). # The default value is: NO. INLINE_SIMPLE_STRUCTS = NO # When TYPEDEF_HIDES_STRUCT tag 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. # The default value is: NO. TYPEDEF_HIDES_STRUCT = NO # The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This # cache is used to resolve symbols given their name and scope. Since this can be # an expensive process and often the same symbol appears multiple times in the # code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small # doxygen will become slower. If the cache is too large, memory is wasted. The # cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range # is 0..9, the default is 0, corresponding to a cache size of 2^16=65536 # symbols. At the end of a run doxygen will report the cache usage and suggest # the optimal cache size from a speed point of view. # Minimum value: 0, maximum value: 9, default value: 0. LOOKUP_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 respectively EXTRACT_STATIC tags are set to YES. # Note: This will also disable the warnings about undocumented members that are # normally produced when WARNINGS is set to YES. # The default value is: NO. EXTRACT_ALL = NO # If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will # be included in the documentation. # The default value is: NO. EXTRACT_PRIVATE = NO # If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal # scope will be included in the documentation. # The default value is: NO. EXTRACT_PACKAGE = NO # If the EXTRACT_STATIC tag is set to YES, all static members of a file will be # included in the documentation. # The default value is: NO. 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. Does not have any effect # for Java sources. # The default value is: YES. EXTRACT_LOCAL_CLASSES = NO # This flag is only useful for Objective-C code. If 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, only methods in the interface are # included. # The default value is: NO. EXTRACT_LOCAL_METHODS = NO # 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. # The default value is: NO. EXTRACT_ANON_NSPACES = NO # If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all # undocumented members inside documented classes or files. If set to NO 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. # The default value is: NO. HIDE_UNDOC_MEMBERS = YES # 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, these classes will be included in the various overviews. This option # has no effect if EXTRACT_ALL is enabled. # The default value is: NO. HIDE_UNDOC_CLASSES = YES # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend # (class|struct|union) declarations. If set to NO, these declarations will be # included in the documentation. # The default value is: NO. HIDE_FRIEND_COMPOUNDS = YES # 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, these # blocks will be appended to the function's detailed documentation block. # The default value is: NO. HIDE_IN_BODY_DOCS = YES # The INTERNAL_DOCS tag determines if documentation that is typed after a # \internal command is included. If the tag is set to NO then the documentation # will be excluded. Set it to YES to include the internal documentation. # The default value is: NO. 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. # The default value is: system dependent. CASE_SENSE_NAMES = YES # If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with # their full class and namespace scopes in the documentation. If set to YES, the # scope will be hidden. # The default value is: NO. HIDE_SCOPE_NAMES = YES # If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will # append additional text to a page's title, such as Class Reference. If set to # YES the compound reference will be hidden. # The default value is: NO. HIDE_COMPOUND_REFERENCE= NO # If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of # the files that are included by a file in the documentation of that file. # The default value is: YES. SHOW_INCLUDE_FILES = NO # If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each # grouped member an include statement to the documentation, telling the reader # which file to include in order to use the member. # The default value is: NO. SHOW_GROUPED_MEMB_INC = NO # If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include # files with double quotes in the documentation rather than with sharp brackets. # The default value is: NO. FORCE_LOCAL_INCLUDES = NO # If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the # documentation for inline members. # The default value is: YES. INLINE_INFO = NO # If the SORT_MEMBER_DOCS tag is set to YES 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. # The default value is: YES. SORT_MEMBER_DOCS = YES # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief # descriptions of file, namespace and class members alphabetically by member # name. If set to NO, the members will appear in declaration order. Note that # this will also influence the order of the classes in the class list. # The default value is: NO. SORT_BRIEF_DOCS = YES # If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the # (brief and detailed) documentation of class members so that constructors and # destructors are listed first. If set to NO the constructors will appear in the # respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS. # Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief # member documentation. # Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting # detailed member documentation. # The default value is: NO. SORT_MEMBERS_CTORS_1ST = 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 group names will # appear in their defined order. # The default value is: NO. 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 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. # The default value is: NO. SORT_BY_SCOPE_NAME = YES # If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper # type resolution of all parameters of a function it will reject a match between # the prototype and the implementation of a member function even if there is # only one candidate or it is obvious which candidate to choose by doing a # simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still # accept a match between prototype and implementation in such cases. # The default value is: NO. STRICT_PROTO_MATCHING = 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. # The default value is: YES. 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. # The default value is: YES. 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. # The default value is: YES. 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. # The default value is: YES. GENERATE_DEPRECATEDLIST= YES # The ENABLED_SECTIONS tag can be used to enable conditional documentation # sections, marked by \if ... \endif and \cond # ... \endcond blocks. ENABLED_SECTIONS = # The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the # initial value of a variable or macro / define can have 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 value of individual variables and macros / defines can be # controlled using \showinitializer or \hideinitializer command in the # documentation regardless of this setting. # Minimum value: 0, maximum value: 10000, default value: 30. MAX_INITIALIZER_LINES = 30 # 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. # The default value is: YES. SHOW_USED_FILES = 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 value 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 value 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 command input-file, where command is the value of the # FILE_VERSION_FILTER tag, and input-file is the name of an input file provided # by doxygen. Whatever the program writes to standard output is used as the file # version. For an example see the documentation. 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. To 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. # # Note that if you run doxygen from a directory containing a file called # DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE # tag is left empty. LAYOUT_FILE = # The CITE_BIB_FILES tag can be used to specify one or more bib files containing # the reference definitions. This must be a list of .bib files. The .bib # extension is automatically appended if omitted. This requires the bibtex tool # to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info. # For LaTeX the style of the bibliography can be controlled using # LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the # search path. See also \cite for info how to create references. CITE_BIB_FILES = #--------------------------------------------------------------------------- # Configuration options related to warning and progress messages #--------------------------------------------------------------------------- # The QUIET tag can be used to turn on/off the messages that are generated to # standard output by doxygen. If QUIET is set to YES this implies that the # messages are off. # The default value is: NO. QUIET = NO # The WARNINGS tag can be used to turn on/off the warning messages that are # generated to standard error (stderr) by doxygen. If WARNINGS is set to YES # this implies that the warnings are on. # # Tip: Turn warnings on while writing the documentation. # The default value is: YES. WARNINGS = YES # If the WARN_IF_UNDOCUMENTED tag 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. # The default value is: YES. WARN_IF_UNDOCUMENTED = YES # If the WARN_IF_DOC_ERROR tag 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. # The default value is: YES. WARN_IF_DOC_ERROR = YES # This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that # are documented, but have no documentation for their parameters or return # value. If set to NO, doxygen will only warn about wrong or incomplete # parameter documentation, but not about the absence of documentation. # The default value is: NO. 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) # The default value is: $file:$line: $text. 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 standard # error (stderr). WARN_LOGFILE = #--------------------------------------------------------------------------- # Configuration options related to the input files #--------------------------------------------------------------------------- # The INPUT tag is 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. See also FILE_PATTERNS and EXTENSION_MAPPING # Note: If this tag is empty the current directory is searched. INPUT = ../glm \ . # This tag can be used to specify the character encoding of the source files # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses # libiconv (or the iconv built into libc) for the transcoding. See the libiconv # documentation (see: http://www.gnu.org/software/libiconv) for the list of # possible encodings. # The default value is: UTF-8. 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 patterns (like *.cpp and # *.h) to filter out the source-files in the directories. # # Note that for custom extensions or not directly supported extensions you also # need to set EXTENSION_MAPPING for the extension otherwise the files are not # read by doxygen. # # If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp, # *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, # *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, # *.m, *.markdown, *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, # *.vhdl, *.ucf, *.qsf, *.as and *.js. FILE_PATTERNS = *.hpp \ *.doxy # The RECURSIVE tag can be used to specify whether or not subdirectories should # be searched for input files as well. # The default value is: NO. RECURSIVE = YES # The EXCLUDE tag can be used to specify files and/or directories that should be # 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. # # Note that relative paths are relative to the directory from which doxygen is # run. EXCLUDE = # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or # directories that are symbolic links (a Unix file system feature) are excluded # from the input. # The default value is: NO. 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 # # Note that the wildcards are matched against the file with absolute path, so to # exclude all test directories use the pattern */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. # The default value is: NO. EXAMPLE_RECURSIVE = NO # The IMAGE_PATH tag can be used to specify one or more files or directories # that contain images that are to be 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. # # Note that the filter must not add or remove lines; it is applied before the # code is scanned, but not when the output code is generated. If lines are added # or removed, the anchors will not be placed correctly. 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 information on how # filters are used. If the FILTER_PATTERNS tag is empty or if none of the # patterns match the file name, INPUT_FILTER is applied. FILTER_PATTERNS = # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using # INPUT_FILTER) will also be used to filter the input files that are used for # producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES). # The default value is: NO. FILTER_SOURCE_FILES = NO # The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file # pattern. A pattern will override the setting for FILTER_PATTERN (if any) and # it is also possible to disable source filtering for a specific pattern using # *.ext= (so without naming a filter). # This tag requires that the tag FILTER_SOURCE_FILES is set to YES. FILTER_SOURCE_PATTERNS = # If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that # is part of the input, its contents will be placed on the main page # (index.html). This can be useful if you have a project on for instance GitHub # and want to reuse the introduction page also for the doxygen output. USE_MDFILE_AS_MAINPAGE = #--------------------------------------------------------------------------- # 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 that # also VERBATIM_HEADERS is set to NO. # The default value is: NO. SOURCE_BROWSER = YES # Setting the INLINE_SOURCES tag to YES will include the body of functions, # classes and enums directly into the documentation. # The default value is: NO. INLINE_SOURCES = NO # Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any # special comment blocks from generated source code fragments. Normal C, C++ and # Fortran comments will always remain visible. # The default value is: YES. 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. # The default value is: NO. 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. # The default value is: NO. REFERENCES_RELATION = YES # If the REFERENCES_LINK_SOURCE tag is set to YES 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. # The default value is: YES. REFERENCES_LINK_SOURCE = YES # If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the # source code will show a tooltip with additional information such as prototype, # brief description and links to the definition and documentation. Since this # will make the HTML file larger and loading of large files a bit slower, you # can opt to disable this feature. # The default value is: YES. # This tag requires that the tag SOURCE_BROWSER is set to YES. SOURCE_TOOLTIPS = 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. # # To use it do the following: # - Install the latest version of global # - Enable SOURCE_BROWSER and USE_HTAGS in the config file # - Make sure the INPUT points to the root of the source tree # - Run doxygen as normal # # Doxygen will invoke htags (and that will in turn invoke gtags), so these # tools must be available from the command line (i.e. in the search path). # # The result: instead of the source browser generated by doxygen, the links to # source code will now point to the output of htags. # The default value is: NO. # This tag requires that the tag SOURCE_BROWSER is set to YES. USE_HTAGS = NO # If the VERBATIM_HEADERS tag is set the YES 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. # See also: Section \class. # The default value is: YES. 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. # The default value is: YES. ALPHABETICAL_INDEX = NO # The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in # which the alphabetical index list will be split. # Minimum value: 1, maximum value: 20, default value: 5. # This tag requires that the tag ALPHABETICAL_INDEX is set to YES. 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 a prefix (or a list of prefixes) that should be ignored # while generating the index headers. # This tag requires that the tag ALPHABETICAL_INDEX is set to YES. IGNORE_PREFIX = #--------------------------------------------------------------------------- # Configuration options related to the HTML output #--------------------------------------------------------------------------- # If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output # The default value is: YES. 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. # The default directory is: html. # This tag requires that the tag GENERATE_HTML is set to YES. 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). # The default value is: .html. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_FILE_EXTENSION = .html # The HTML_HEADER tag can be used to specify a user-defined HTML header file for # each generated HTML page. If the tag is left blank doxygen will generate a # standard header. # # To get valid HTML the header file that includes any scripts and style sheets # that doxygen needs, which is dependent on the configuration options used (e.g. # the setting GENERATE_TREEVIEW). It is highly recommended to start with a # default header using # doxygen -w html new_header.html new_footer.html new_stylesheet.css # YourConfigFile # and then modify the file new_header.html. See also section "Doxygen usage" # for information on how to generate the default header that doxygen normally # uses. # Note: The header is subject to change so you typically have to regenerate the # default header when upgrading to a newer version of doxygen. For a description # of the possible markers and block names see the documentation. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_HEADER = # The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each # generated HTML page. If the tag is left blank doxygen will generate a standard # footer. See HTML_HEADER for more information on how to generate a default # footer and what special commands can be used inside the footer. See also # section "Doxygen usage" for information on how to generate the default footer # that doxygen normally uses. # This tag requires that the tag GENERATE_HTML is set to YES. 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 left blank doxygen will generate a default style sheet. # See also section "Doxygen usage" for information on how to generate the style # sheet that doxygen normally uses. # Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as # it is more robust and this tag (HTML_STYLESHEET) will in the future become # obsolete. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_STYLESHEET = # The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined # cascading style sheets that are included after the standard style sheets # created by doxygen. Using this option one can overrule certain style aspects. # This is preferred over using HTML_STYLESHEET since it does not replace the # standard style sheet and is therefore more robust against future updates. # Doxygen will copy the style sheet files to the output directory. # Note: The order of the extra style sheet files is of importance (e.g. the last # style sheet in the list overrules the setting of the previous ones in the # list). For an example see the documentation. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_EXTRA_STYLESHEET = # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or # other source files which should be copied to the HTML output directory. Note # that these files will be copied to the base HTML output directory. Use the # $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these # files. In the HTML_STYLESHEET file, use the file name only. Also note that the # files will be copied as-is; there are no commands or markers available. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_EXTRA_FILES = # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen # will adjust the colors in the style sheet and background images according to # this color. Hue is specified as an angle on a colorwheel, see # http://en.wikipedia.org/wiki/Hue for more information. For instance the value # 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300 # purple, and 360 is red again. # Minimum value: 0, maximum value: 359, default value: 220. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_HUE = 220 # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors # in the HTML output. For a value of 0 the output will use grayscales only. A # value of 255 will produce the most vivid colors. # Minimum value: 0, maximum value: 255, default value: 100. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_SAT = 100 # The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the # luminance component of the colors in the HTML output. Values below 100 # gradually make the output lighter, whereas values above 100 make the output # darker. The value divided by 100 is the actual gamma applied, so 80 represents # a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not # change the gamma. # Minimum value: 40, maximum value: 240, default value: 80. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_GAMMA = 80 # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML # page will contain the date and time when the page was generated. Setting this # to YES can help to show when doxygen was last run and thus if the # documentation is up to date. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_TIMESTAMP = NO # 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. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_DYNAMIC_SECTIONS = NO # With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries # shown in the various tree structured indices initially; the user can expand # and collapse entries dynamically later on. Doxygen will expand the tree to # such a level that at most the specified number of entries are visible (unless # a fully collapsed tree already exceeds this amount). So setting the number of # entries 1 will produce a full collapsed tree by default. 0 is a special value # representing an infinite number of entries and will result in a full expanded # tree by default. # Minimum value: 0, maximum value: 9999, default value: 100. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_INDEX_NUM_ENTRIES = 100 # 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 (see: http://developer.apple.com/tools/xcode/), 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. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_DOCSET = NO # This tag determines the name of the docset 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. # The default value is: Doxygen generated docs. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_FEEDNAME = "Doxygen generated docs" # 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. # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_BUNDLE_ID = org.doxygen.Project # The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify # the documentation publisher. This should be a reverse domain-name style # string, e.g. com.mycompany.MyDocSet.documentation. # The default value is: org.doxygen.Publisher. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_PUBLISHER_ID = org.doxygen.Publisher # The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher. # The default value is: Publisher. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_PUBLISHER_NAME = Publisher # If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three # additional HTML index files: index.hhp, index.hhc, and index.hhk. The # index.hhp is a project file that can be read by Microsoft's HTML Help Workshop # (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on # Windows. # # The HTML Help Workshop contains a compiler that can convert all HTML output # generated by doxygen into a single compiled HTML file (.chm). Compiled HTML # files are now used as the Windows 98 help format, and will replace the old # Windows help format (.hlp) on all Windows platforms in the future. Compressed # HTML files also contain an index, a table of contents, and you can search for # words in the documentation. The HTML workshop also contains a viewer for # compressed HTML files. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_HTMLHELP = NO # 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. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. CHM_FILE = # 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. # The file has to be specified with full path. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. HHC_LOCATION = # 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). # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. GENERATE_CHI = NO # The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc) # and project file content. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. CHM_INDEX_ENCODING = # 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. Furthermore it # enables the Previous and Next buttons. # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. BINARY_TOC = NO # The TOC_EXPAND flag can be set to YES to add extra items for group members to # the table of contents of the HTML help documentation and to the tree view. # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. 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. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. 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. # This tag requires that the tag GENERATE_QHP is set to YES. QCH_FILE = # The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help # Project output. For more information please see Qt Help Project / Namespace # (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace). # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_QHP is set to YES. QHP_NAMESPACE = org.doxygen.Project # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt # Help Project output. For more information please see Qt Help Project / Virtual # Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual- # folders). # The default value is: doc. # This tag requires that the tag GENERATE_QHP is set to YES. QHP_VIRTUAL_FOLDER = doc # If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom # filter to add. For more information please see Qt Help Project / Custom # Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- # filters). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_CUST_FILTER_NAME = # The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the # custom filter to add. For more information please see Qt Help Project / Custom # Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- # filters). # This tag requires that the tag GENERATE_QHP is set to YES. 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 (see: # http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_SECT_FILTER_ATTRS = # 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. # This tag requires that the tag GENERATE_QHP is set to YES. QHG_LOCATION = # If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be # generated, together with the HTML files, they form an Eclipse help plugin. To # install this plugin and make it available under the help contents menu in # Eclipse, the contents of the directory containing the HTML and XML files needs # to be copied into the plugins directory of eclipse. The name of the directory # within the plugins directory should be the same as the ECLIPSE_DOC_ID value. # After copying Eclipse needs to be restarted before the help appears. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_ECLIPSEHELP = NO # A unique identifier for the Eclipse help plugin. When installing the plugin # the directory name containing the HTML and XML files should also have this # name. Each documentation set should have its own identifier. # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES. ECLIPSE_DOC_ID = org.doxygen.Project # If you want full control over the layout of the generated HTML pages it might # be necessary to disable the index and replace it with your own. The # DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top # of each HTML page. A value of NO enables the index and the value YES disables # it. Since the tabs in the index contain the same information as the navigation # tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. DISABLE_INDEX = NO # 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 YES, 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 # (i.e. any modern browser). Windows users are probably better off using the # HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can # further fine-tune the look of the index. As an example, the default style # sheet generated by doxygen has an example that shows how to put an image at # the root of the tree instead of the PROJECT_NAME. Since the tree basically has # the same information as the tab index, you could consider setting # DISABLE_INDEX to YES when enabling this option. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_TREEVIEW = NO # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that # doxygen will group on one line in the generated HTML documentation. # # Note that a value of 0 will completely suppress the enum values from appearing # in the overview section. # Minimum value: 0, maximum value: 20, default value: 4. # This tag requires that the tag GENERATE_HTML is set to YES. ENUM_VALUES_PER_LINE = 4 # 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. # Minimum value: 0, maximum value: 1500, default value: 250. # This tag requires that the tag GENERATE_HTML is set to YES. TREEVIEW_WIDTH = 250 # If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to # external symbols imported via tag files in a separate window. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. EXT_LINKS_IN_WINDOW = NO # Use this tag to change the font size of LaTeX formulas included as images in # the HTML documentation. 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. # Minimum value: 8, maximum value: 50, default value: 10. # This tag requires that the tag GENERATE_HTML is set to YES. FORMULA_FONTSIZE = 10 # Use the FORMULA_TRANPARENT tag to determine whether or not the images # generated for formulas are transparent PNGs. Transparent PNGs are not # supported properly for IE 6.0, but are supported on all modern browsers. # # Note that when changing this option you need to delete any form_*.png files in # the HTML output directory before the changes have effect. # The default value is: YES. # This tag requires that the tag GENERATE_HTML is set to YES. FORMULA_TRANSPARENT = YES # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see # http://www.mathjax.org) which uses client side Javascript for the rendering # instead of using pre-rendered bitmaps. Use this if you do not have LaTeX # installed or if you want to formulas look prettier in the HTML output. When # enabled you may also need to install MathJax separately and configure the path # to it using the MATHJAX_RELPATH option. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. USE_MATHJAX = NO # When MathJax is enabled you can set the default output format to be used for # the MathJax output. See the MathJax site (see: # http://docs.mathjax.org/en/latest/output.html) for more details. # Possible values are: HTML-CSS (which is slower, but has the best # compatibility), NativeMML (i.e. MathML) and SVG. # The default value is: HTML-CSS. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_FORMAT = HTML-CSS # When MathJax is enabled you need to specify the location relative to the HTML # output directory using the MATHJAX_RELPATH option. The destination directory # should contain the MathJax.js script. For instance, if the mathjax directory # is located at the same level as the HTML output directory, then # MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax # Content Delivery Network so you can quickly see the result without installing # MathJax. However, it is strongly recommended to install a local copy of # MathJax from http://www.mathjax.org before deployment. # The default value is: http://cdn.mathjax.org/mathjax/latest. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_RELPATH = http://www.mathjax.org/mathjax # The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax # extension names that should be enabled during MathJax rendering. For example # MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_EXTENSIONS = # The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces # of code that will be used on startup of the MathJax code. See the MathJax site # (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an # example see the documentation. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_CODEFILE = # When the SEARCHENGINE tag is enabled doxygen will generate a search box for # the HTML output. The underlying search engine uses javascript and DHTML and # should work on any modern browser. Note that when using HTML help # (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET) # there is already a search function so this one should typically be disabled. # For large projects the javascript based search engine can be slow, then # enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to # search using the keyboard; to jump to the search box use + S # (what the is depends on the OS and browser, but it is typically # , /OpenGL Mathematics (GLM) is a header only C++ mathematics library for graphics software based on the OpenGL Shading Language (GLSL) specification. GLM provides classes and functions designed and implemented with the same naming conventions and functionalities than GLSL so that when a programmer knows GLSL, he knows GLM as well which makes it really easy to use. This project isn't limited to GLSL features. An extension system, based on the GLSL extension conventions, provides extended capabilities: matrix transformations, quaternions, half-based types, random numbers, noise, etc... This library works perfectly with OpenGL but it also ensures interoperability with other third party libraries and SDK. It is a good candidate for software rendering (raytracing / rasterisation), image processing, physic simulations and any development context that requires a simple and convenient mathematics library. GLM is written in C++98 but can take advantage of C++11 when supported by the compiler. It is a platform independent library with no dependence and it officially supports the following compilers: - Apple Clang 4.0 and higher - GCC 4.2 and higher - LLVM 3.0 and higher - Intel C++ Composer XE 2013 and higher - Visual Studio 2010 and higher - CUDA 4.0 and higher (experimental) - Any conform C++98 compiler @note The Doxygen-generated documentation will often state that a type or function is defined in a namespace that is a child of the @link glm glm @endlink namespace. Please ignore this; All publicly available types and functions can be accessed as a direct children of the glm namespace. The source code is licenced under the Happy Bunny License (Modified MIT) and MIT license. These pages are the API reference only. For more information about how to use GLM, please have a look at the manual. Thanks for contributing to the project by submitting tickets for bug reports and feature requests. Any feedback is welcome at glm@g-truc.net. **/ anbox-0.0~git20191115/external/glm/doc/theme/000077500000000000000000000000001356361734700204755ustar00rootroot00000000000000anbox-0.0~git20191115/external/glm/doc/theme/doxygen.css000066400000000000000000000343001356361734700226640ustar00rootroot00000000000000/* The standard CSS for doxygen */ body, table, div, p, dl { font-family: Lucida Grande, Calibri, Verdana; font-size: 14px; } body { margin:0px; padding:0px; background-color:#bf6000; background-repeat:no-repeat; background-position:center center; background-attachment:fixed; /* background-image: -moz-linear-gradient(center top, #FFFFFF 0%, #FFF8F0 5%, #FFEEDD 95%, #FFDDBB); background-image: -webkit-gradient(linear,center top,center bottom,from(#FFFFFF), color-stop(0.05,#FFF8F0), color-stop(0.05,#FFF8F0), color-stop(0.95,#FFEEDD), to(#FFDDBB)); */ min-height:1200px; overflow:auto; } p { background-color:#FFFFFF; } /* @group Heading Levels */ h1 { color:#FF8000; font-family: Lucida Grande, Cambria, Georgia; font-size: 24px; font-weight: bold; } h2 { color:#FF8000; font-family: Lucida Grande, Cambria, Georgia; font-size: 18px; font-weight: bold; } h3 { font-family: Lucida Grande, Cambria, Georgia; font-size: 14px; font-weight: bold; } dt { font-weight: bold; } div.multicol { -moz-column-gap: 1em; -webkit-column-gap: 1em; -moz-column-count: 3; -webkit-column-count: 3; } p.startli, p.startdd, p.starttd { margin-top: 2px; } p.endli { margin-bottom: 0px; } p.enddd { margin-bottom: 4px; } p.endtd { margin-bottom: 2px; } /* @end */ caption { font-weight: bold; } span.legend { font-size: 70%; text-align: center; } h3.version { font-size: 90%; text-align: center; } div.qindex, div.navtab{ background-color: #FFF8F0; border: 0px solid #FF8000; text-align: center; margin: 2px; padding: 2px; } div.qindex, div.navpath { width: 100%; line-height: 140%; } div.navtab { margin-right: 15px; } /* @group Link Styling */ a { color: #000000; font-weight: normal; /*text-decoration: none;*/ } .contents a:visited { color: #606060; } .contents{ background-color: #FFFFFF; margin:0px; margin-left:auto; margin-right:auto; padding-top:8px; padding-bottom:8px; padding-left:32px; padding-right:32px; width:936px; } div.textblock{ background-color: #FFFFFF; padding-top: 4px; padding-bottom: 4px; padding-left: 32px; padding-right: 32px; } a:hover { text-decoration: underline; } a.qindex { font-weight: bold; } a.qindexHL { font-weight: bold; background-color: #9CAFD4; color: #ffffff; border: 0px double #869DCA; } .contents a.qindexHL:visited { color: #ffffff; } a.el { font-weight: bold; } a.elRef { } a.code { color: #4665A2; } a.codeRef { color: #4665A2; } /* @end */ dl.el { margin-left: -1cm; } .fragment { font-family: monospace, consolas, "courier new"; font-size: 12px; } pre.fragment { border: 0px solid #FF8000; background-color: #FFF8F0; padding: 4px 6px; margin: 4px 8px 4px 2px; overflow: auto; word-wrap: break-word; line-height: 125%; } div.ah { background-color: black; font-weight: bold; color: #ffffff; margin-bottom: 3px; margin-top: 3px; padding: 0.2em; border: solid thin #333; border-radius: 0.5em; -webkit-border-radius: .5em; -moz-border-radius: .5em; box-shadow: 2px 2px 3px #999; -webkit-box-shadow: 2px 2px 3px #999; -moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px; background-image: -webkit-gradient(linear, left top, left bottom, from(#eee), to(#000),color-stop(0.3, #444)); background-image: -moz-linear-gradient(center top, #eee 0%, #444 40%, #000); } div.groupHeader { margin-left: 16px; margin-top: 12px; font-weight: bold; } div.groupText { margin-left: 16px; font-style: italic; } td.indexkey { font-weight: bold; border: 0px solid #C4CFE5; margin: 2px 0px 2px 0; padding: 4px 10px; } td.indexvalue { border: 0px solid #C4CFE5; padding: 2px 10px; margin: 2px 0px; } tr.memlist { background-color: #FFF8F0; } p.formulaDsp { text-align: center; } img.formulaDsp { } img.formulaInl { vertical-align: middle; } div.center { text-align: center; margin-top: 0px; margin-bottom: 0px; padding: 0px; } div.center img { border: 0px; } address.footer { margin-left:auto; margin-right:auto; width:1000px; text-align: right; padding-right: 12px; color: #FFEEDD; } img.footer { border: 0px; vertical-align: middle; } /* @group Code Colorization */ span.keyword { color: #008000 } span.keywordtype { color: #604020 } span.keywordflow { color: #e08000 } span.comment { color: #800000 } span.preprocessor { color: #806020 } span.stringliteral { color: #002080 } span.charliteral { color: #008080 } span.vhdldigit { color: #ff00ff } span.vhdlchar { color: #000000 } span.vhdlkeyword { color: #700070 } span.vhdllogic { color: #ff0000 } /* @end */ /* .search { color: #003399; font-weight: bold; } form.search { margin-bottom: 0px; margin-top: 0px; } input.search { font-size: 75%; color: #000080; font-weight: normal; background-color: #e8eef2; } */ td.tiny { font-size: 10px; } .dirtab { padding: 4px; border-collapse: collapse; border: 0px solid #A3B4D7; } th.dirtab { background: #EBEFF6; font-weight: bold; } hr { height: 0px; border: none; border-top: 0px solid #FF8000; } hr.footer { height: 1px; margin-left:auto; margin-right:auto; width:1000px; } /* @group Member Descriptions */ table.memberdecls { border-spacing: 0px; padding: 0px; } .mdescLeft, .mdescRight, .memItemLeft, .memItemRight, .memTemplItemLeft, .memTemplItemRight, .memTemplParams { font-family: monospace, consolas, "courier new"; font-size: 12px; background-color: #FFFCF8; border: none; margin: 4px; padding: 1px 0 0 8px; } .mdescLeft, .mdescRight { padding: 0px 8px 4px 8px; color: #000000; } .memItemLeft, .memItemRight, .memTemplParams { border-top: 4px solid #FFFFFF; } .memItemLeft, .memTemplItemLeft { white-space: nowrap; } .memTemplParams { color: #404040; white-space: nowrap; } /* @end */ /* @group Member Details */ /* Styles for detailed member documentation */ .memtemplate { color: #000000; font-weight: normal; margin-left: 9px; } .memnav { background-color: #000000; border: 0px solid #A3B4D7; text-align: center; margin: 2px; margin-right: 15px; padding: 2px; } .memitem { padding: 8px; margin-bottom: 10px; } .memname { font-family: monospace, consolas, "courier new"; font-weight: bold; font-size: 12px; white-space: nowrap; margin-left: 6px; } .memproto { border-top: 0px solid #FF8000; border-left: 0px solid #FF8000; border-right: 0px solid #FF8000; padding: 6px 0px 6px 0px; color: #000000; font-weight: bold; text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9); /* opera specific markup */ box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); border-top-right-radius: 8px; border-top-left-radius: 8px; /* firefox specific markup */ -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px; -moz-border-radius-topright: 8px; -moz-border-radius-topleft: 8px; /* webkit specific markup */ -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); -webkit-border-top-right-radius: 8px; -webkit-border-top-left-radius: 8px; background-repeat:repeat-x; background-color: #FFFFFF; background-image: -moz-linear-gradient(center top, #FFF8F0 0%, #FFFFFF 60%, #FFFFFF 95%, #FFFFFF); background-image: -webkit-gradient(linear,center top,center bottom,from(#FFF8F0), color-stop(0.2,#FFFFFF), color-stop(0.60,#FFFFFF), color-stop(0.95,#FFFFFF), to(#FFFFFF)); } .memdoc { /*font-family: Lucida Grande, Calibri, Verdana;*/ border-bottom: 0px solid #FF8000; border-left: 0px solid #FF8000; border-right: 0px solid #FF8000; padding: 2px 5px; background-color: #FFFFFF; border-top-width: 0; /* opera specific markup */ border-bottom-left-radius: 8px; border-bottom-right-radius: 8px; box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); /* firefox specific markup */ -moz-border-radius-bottomleft: 8px; -moz-border-radius-bottomright: 8px; -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px; background-image: -moz-linear-gradient(center top, #FFFFFF 0%, #FFFFFF 60%, #FFF8F0 90%, #FFEEDD); /* webkit specific markup */ -webkit-border-bottom-left-radius: 8px; -webkit-border-bottom-right-radius: 8px; -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); background-image: -webkit-gradient(linear,center top,center bottom,from(#FFFFFF), color-stop(0.6,#FFFFFF), color-stop(0.60,#FFFFFF), color-stop(0.90,#FFF8F0), to(#FFEEDD)); } .paramkey { text-align: right; } .paramtype { white-space: nowrap; } .paramname { color: #FF8000; white-space: nowrap; } .paramname em { font-style: normal; } .params, .retval, .exception, .tparams { border-spacing: 6px 2px; } .params .paramname, .retval .paramname { color: #FF8000; font-family: monospace, consolas, "courier new"; font-weight: bold; font-size: 12px; vertical-align: top; } .params .paramtype { font-style: italic; vertical-align: top; } .params .paramdir { vertical-align: top; } /* @end */ /* @group Directory (tree) */ /* for the tree view */ .ftvtree { /*font-family: Lucida Grande, Calibri, Verdana;*/ margin: 0px; } /* these are for tree view when used as main index */ .directory { font-weight: bold; margin: 5px; } .directory h3 { margin: 0px; margin-top: 1em; } /* The following two styles can be used to replace the root node title with an image of your choice. Simply uncomment the next two styles, specify the name of your image and be sure to set 'height' to the proper pixel height of your image. */ /* .directory h3.swap { height: 61px; background-repeat: no-repeat; background-image: url("yourimage.gif"); } .directory h3.swap span { display: none; } */ .directory > h3 { margin-top: 0; } .directory p { margin: 0px; white-space: nowrap; } .directory div { display: none; margin: 0px; } .directory img { vertical-align: -30%; } /* these are for tree view when not used as main index */ .directory-alt { font-size: 100%; font-weight: bold; } .directory-alt h3 { margin: 0px; margin-top: 1em; } .directory-alt > h3 { margin-top: 0; } .directory-alt p { margin: 0px; white-space: nowrap; } .directory-alt div { display: none; margin: 0px; } .directory-alt img { vertical-align: -30%; } /* @end */ div.dynheader { margin-top: 8px; } address { font-style: normal; color: #804000; } table.doxtable { border-collapse:collapse; } table.doxtable td, table.doxtable th { border: 0px solid #000000; padding: 3px 7px 2px; } table.doxtable th { background-color: #000000; color: #FFFFFF; font-size: 110%; padding-bottom: 4px; padding-top: 5px; text-align:left; } .tabsearch { top: 0px; left: 10px; height: 36px; /*background-image: url('tab_b.png');*/ z-index: 101; overflow: hidden; } .navpath ul { background-color: #FFEEDD; height:30px; line-height:30px; overflow:hidden; margin:0px; padding:0px; } .navpath li { list-style-type:none; float:left; padding-left:10px; padding-right:15px; /*background-image:url('bc_s.png');*/ background-repeat:no-repeat; background-position:right; } .navpath li.navelem a { height:32px; display:block; text-decoration: none; outline: none; } .navpath li.navelem a:hover { color:#FF8000; } .navpath li.footer { list-style-type:none; float:right; padding-left:10px; padding-right:15px; background-image:none; background-repeat:no-repeat; background-position:right; color:#FFEEDD; } div.summary { float: right; font-size: 12px; padding-right: 5px; width: 160px; text-align: right; } div.summary a { white-space: nowrap; } div.ingroups { padding-left: 5px; width: 50%; text-align: left; } div.ingroups a { white-space: nowrap; } div.header { background-color:#FFEEDD; background-image: -moz-linear-gradient(center top, #FFEEDD 0%, #FFEEDD 5%, #FFEEDD 80%, #FFFFFF); background-image: -webkit-gradient(linear,center top,center bottom,from(#FFEEDD), color-stop(0.05,#FFEEDD), color-stop(0.05,#FFEEDD), color-stop(0.80,#FFEEDD), to(#FFFFFF)); padding:0px; margin:0px; margin-left:auto; margin-right:auto; width:1000px; border-bottom: 0px solid #FFC080; } div.headertitle { margin: 0px; padding: 5px; padding-bottom:10px; padding-top:10px; } div.title { font-family: Lucida Grande, Cambria, Georgia; font-size: 24px; color: #FF7F00; } dl { padding: 0 0 0 10px; } dl.note, dl.warning, dl.attention, dl.pre, dl.post, dl.invariant, dl.deprecated, dl.todo, dl.test, dl.bug { border-color: #FF7F00; border-left:4px solid; padding: 0 0 0 6px; } dl.note { border-color: #FFDDBB; } dl.warning, dl.attention { border-color: #FF0000; } dl.pre, dl.post, dl.invariant { border-color: #00D000; } dl.deprecated { border-color: #505050; } dl.todo { border-color: #00C0E0; } dl.test { border-color: #3030E0; } dl.bug { border-color: #C08050; } #projectlogo { text-align: center; vertical-align: bottom; border-collapse: separate; } #projectlogo img { border: 0px none; } #projectname { /*font-family: Lucida Grande, Cambria, Georgia;*/ font-size: 24px; margin: 0px; padding: 0px; } #projectbrief { /*font-family: Lucida Grande, Cambria, Georgia;*/ font-size: 18px; margin: 0px; padding: 0px; } #projectnumber { /*font-family: Lucida Grande, Cambria, Georgia;*/ font-size: 14px; margin: 0px; padding: 0px; } #titlearea { padding: 0px; margin: 0px; width: 100%; border-bottom: 0px solid #FF8000; background-color:#FFFFFF; } #top { margin-left:auto; margin-right:auto; width:1000px; } anbox-0.0~git20191115/external/glm/doc/theme/tabs.css000066400000000000000000000051731356361734700221460ustar00rootroot00000000000000.tabs, .tabs2, .tabs3 { background-image: -moz-linear-gradient(center top, #FFFFFF 0%, #FFFFFF 5%, #FFEEDD 95%, #FFEEDD); background-image: -webkit-gradient(linear,center top,center bottom,from(#FFFFFF), color-stop(0.05,#FFFFFF), color-stop(0.05,#FFFFFF), color-stop(0.95,#FFEEDD), to(#FFEEDD)); /*background-image: url('tab_b.png');*/ background-color:#FFF8F0; width: 100%; z-index: 101; font-size: 13px; } .tabs2 { font-size: 10px; } .tabs3 { font-size: 9px; } .tablist { margin: 0; padding: 0; display: table; } .tablist li { float: left; display: table-cell; background-image: -moz-linear-gradient(center top, #FFFFFF 0%, #FFFFFF 5%, #FFEEDD 95%, #FFEEDD); background-image: -webkit-gradient(linear,center top,center bottom,from(#FFFFFF), color-stop(0.05,#FFFFFF), color-stop(0.05,#FFFFFF), color-stop(0.95,#FFEEDD), to(#FFEEDD)); /*background-image: url('tab_b.png');*/ line-height: 36px; list-style: none; } .tablist a { display: block; padding: 0 20px; font-weight: bold; background-image: -moz-linear-gradient(center top, #FFFFFF 0%, #FFFFFF 5%, #FFEEDD 95%, #FFEEDD); background-image: -webkit-gradient(linear,center top,center bottom,from(#FFFFFF), color-stop(0.05,#FFFFFF), color-stop(0.05,#FFFFFF), color-stop(0.95,#FFEEDD), to(#FFEEDD)); /*background-image:url('tab_s.png');*/ background-repeat:no-repeat; background-position:right; color: #FF8000; /*text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9);*/ text-decoration: none; outline: none; } .tabs3 .tablist a { padding: 0 10px; } .tablist a:hover { background-image: -moz-linear-gradient(center top, #FFFFFF 0%, #FFFFFF 5%, #FFEEDD 95%, #FFEEDD); background-image: -webkit-gradient(linear,center top,center bottom,from(#FFFFFF), color-stop(0.05,#FFFFFF), color-stop(0.05,#FFFFFF), color-stop(0.95,#FFEEDD), to(#FFEEDD)); /*background-image: url('tab_h.png');*/ background-color:#FFFEFD; background-repeat:repeat-x; color: #FF8000; /*text-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0);*/ text-decoration:underline; } .tablist li.current a { background-image: -moz-linear-gradient(center top, #FFFFFF 0%, #FFFFFF 5%, #FFEEDD 95%, #FFEEDD); background-image: -webkit-gradient(linear,center top,center bottom,from(#FFFFFF), color-stop(0.05,#FFFFFF), color-stop(0.05,#FFFFFF), color-stop(0.95,#FFEEDD), to(#FFEEDD)); /*background-image: url('tab_a.png');*/ background-color:#FFFEFD; background-repeat:repeat-x; color: #FF8000; /*text-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0);*/ } anbox-0.0~git20191115/external/glm/glm/000077500000000000000000000000001356361734700174055ustar00rootroot00000000000000anbox-0.0~git20191115/external/glm/glm/CMakeLists.txt000066400000000000000000000030311356361734700221420ustar00rootroot00000000000000set(NAME glm_dummy) file(GLOB ROOT_SOURCE *.cpp) file(GLOB ROOT_INLINE *.inl) file(GLOB ROOT_HEADER *.hpp) file(GLOB ROOT_TEXT ../*.txt) file(GLOB ROOT_MD ../*.md) file(GLOB ROOT_NAT ../util/glm.natvis) file(GLOB_RECURSE CORE_SOURCE ./detail/*.cpp) file(GLOB_RECURSE CORE_INLINE ./detail/*.inl) file(GLOB_RECURSE CORE_HEADER ./detail/*.hpp) file(GLOB_RECURSE GTC_SOURCE ./gtc/*.cpp) file(GLOB_RECURSE GTC_INLINE ./gtc/*.inl) file(GLOB_RECURSE GTC_HEADER ./gtc/*.hpp) file(GLOB_RECURSE GTX_SOURCE ./gtx/*.cpp) file(GLOB_RECURSE GTX_INLINE ./gtx/*.inl) file(GLOB_RECURSE GTX_HEADER ./gtx/*.hpp) source_group("Text Files" FILES ${ROOT_TEXT} ${ROOT_MD}) source_group("Core Files" FILES ${CORE_SOURCE}) source_group("Core Files" FILES ${CORE_INLINE}) source_group("Core Files" FILES ${CORE_HEADER}) source_group("GTC Files" FILES ${GTC_SOURCE}) source_group("GTC Files" FILES ${GTC_INLINE}) source_group("GTC Files" FILES ${GTC_HEADER}) source_group("GTX Files" FILES ${GTX_SOURCE}) source_group("GTX Files" FILES ${GTX_INLINE}) source_group("GTX Files" FILES ${GTX_HEADER}) include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..) if(GLM_TEST_ENABLE) add_executable(${NAME} ${ROOT_TEXT} ${ROOT_MD} ${ROOT_NAT} ${ROOT_SOURCE} ${ROOT_INLINE} ${ROOT_HEADER} ${CORE_SOURCE} ${CORE_INLINE} ${CORE_HEADER} ${GTC_SOURCE} ${GTC_INLINE} ${GTC_HEADER} ${GTX_SOURCE} ${GTX_INLINE} ${GTX_HEADER}) endif(GLM_TEST_ENABLE) #add_library(glm STATIC glm.cpp) #add_library(glm_shared SHARED glm.cpp) anbox-0.0~git20191115/external/glm/glm/common.hpp000066400000000000000000000032171356361734700214110ustar00rootroot00000000000000/////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// /// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights /// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell /// copies of the Software, and to permit persons to whom the Software is /// furnished to do so, subject to the following conditions: /// /// The above copyright notice and this permission notice shall be included in /// all copies or substantial portions of the Software. /// /// Restrictions: /// By making use of the Software for military purposes, you choose to make /// a Bunny unhappy. /// /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE /// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER /// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, /// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN /// THE SOFTWARE. /// /// @ref core /// @file glm/common.hpp /// @date 2013-12-24 / 2013-12-24 /// @author Christophe Riccio /////////////////////////////////////////////////////////////////////////////////// #pragma once #include "detail/func_common.hpp" anbox-0.0~git20191115/external/glm/glm/detail/000077500000000000000000000000001356361734700206475ustar00rootroot00000000000000anbox-0.0~git20191115/external/glm/glm/detail/_features.hpp000066400000000000000000000323571356361734700233470ustar00rootroot00000000000000/////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// /// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights /// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell /// copies of the Software, and to permit persons to whom the Software is /// furnished to do so, subject to the following conditions: /// /// The above copyright notice and this permission notice shall be included in /// all copies or substantial portions of the Software. /// /// Restrictions: /// By making use of the Software for military purposes, you choose to make /// a Bunny unhappy. /// /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE /// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER /// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, /// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN /// THE SOFTWARE. /// /// @ref core /// @file glm/detail/_features.hpp /// @date 2013-02-20 / 2013-02-20 /// @author Christophe Riccio /////////////////////////////////////////////////////////////////////////////////// #pragma once // #define GLM_CXX98_EXCEPTIONS // #define GLM_CXX98_RTTI // #define GLM_CXX11_RVALUE_REFERENCES // Rvalue references - GCC 4.3 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2118.html // GLM_CXX11_TRAILING_RETURN // Rvalue references for *this - GCC not supported // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2439.htm // GLM_CXX11_NONSTATIC_MEMBER_INIT // Initialization of class objects by rvalues - GCC any // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1610.html // GLM_CXX11_NONSTATIC_MEMBER_INIT // Non-static data member initializers - GCC 4.7 // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2756.htm // #define GLM_CXX11_VARIADIC_TEMPLATE // Variadic templates - GCC 4.3 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2242.pdf // // Extending variadic template template parameters - GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2555.pdf // #define GLM_CXX11_GENERALIZED_INITIALIZERS // Initializer lists - GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2672.htm // #define GLM_CXX11_STATIC_ASSERT // Static assertions - GCC 4.3 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1720.html // #define GLM_CXX11_AUTO_TYPE // auto-typed variables - GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1984.pdf // #define GLM_CXX11_AUTO_TYPE // Multi-declarator auto - GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1737.pdf // #define GLM_CXX11_AUTO_TYPE // Removal of auto as a storage-class specifier - GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2546.htm // #define GLM_CXX11_AUTO_TYPE // New function declarator syntax - GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2541.htm // #define GLM_CXX11_LAMBDAS // New wording for C++0x lambdas - GCC 4.5 // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2927.pdf // #define GLM_CXX11_DECLTYPE // Declared type of an expression - GCC 4.3 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2343.pdf // // Right angle brackets - GCC 4.3 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1757.html // // Default template arguments for function templates DR226 GCC 4.3 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#226 // // Solving the SFINAE problem for expressions DR339 GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2634.html // #define GLM_CXX11_ALIAS_TEMPLATE // Template aliases N2258 GCC 4.7 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf // // Extern templates N1987 Yes // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1987.htm // #define GLM_CXX11_NULLPTR // Null pointer constant N2431 GCC 4.6 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2431.pdf // #define GLM_CXX11_STRONG_ENUMS // Strongly-typed enums N2347 GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf // // Forward declarations for enums N2764 GCC 4.6 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2764.pdf // // Generalized attributes N2761 GCC 4.8 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf // // Generalized constant expressions N2235 GCC 4.6 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf // // Alignment support N2341 GCC 4.8 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf // #define GLM_CXX11_DELEGATING_CONSTRUCTORS // Delegating constructors N1986 GCC 4.7 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1986.pdf // // Inheriting constructors N2540 GCC 4.8 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2540.htm // #define GLM_CXX11_EXPLICIT_CONVERSIONS // Explicit conversion operators N2437 GCC 4.5 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf // // New character types N2249 GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2249.html // // Unicode string literals N2442 GCC 4.5 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm // // Raw string literals N2442 GCC 4.5 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm // // Universal character name literals N2170 GCC 4.5 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2170.html // #define GLM_CXX11_USER_LITERALS // User-defined literals N2765 GCC 4.7 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2765.pdf // // Standard Layout Types N2342 GCC 4.5 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2342.htm // #define GLM_CXX11_DEFAULTED_FUNCTIONS // #define GLM_CXX11_DELETED_FUNCTIONS // Defaulted and deleted functions N2346 GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2346.htm // // Extended friend declarations N1791 GCC 4.7 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1791.pdf // // Extending sizeof N2253 GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2253.html // #define GLM_CXX11_INLINE_NAMESPACES // Inline namespaces N2535 GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2535.htm // #define GLM_CXX11_UNRESTRICTED_UNIONS // Unrestricted unions N2544 GCC 4.6 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf // #define GLM_CXX11_LOCAL_TYPE_TEMPLATE_ARGS // Local and unnamed types as template arguments N2657 GCC 4.5 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm // #define GLM_CXX11_RANGE_FOR // Range-based for N2930 GCC 4.6 // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2930.html // #define GLM_CXX11_OVERRIDE_CONTROL // Explicit virtual overrides N2928 N3206 N3272 GCC 4.7 // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2928.htm // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3206.htm // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3272.htm // // Minimal support for garbage collection and reachability-based leak detection N2670 No // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2670.htm // #define GLM_CXX11_NOEXCEPT // Allowing move constructors to throw [noexcept] N3050 GCC 4.6 (core language only) // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3050.html // // Defining move special member functions N3053 GCC 4.6 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3053.html // // Sequence points N2239 Yes // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2239.html // // Atomic operations N2427 GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2239.html // // Strong Compare and Exchange N2748 GCC 4.5 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html // // Bidirectional Fences N2752 GCC 4.8 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2752.htm // // Memory model N2429 GCC 4.8 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2429.htm // // Data-dependency ordering: atomics and memory model N2664 GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2664.htm // // Propagating exceptions N2179 GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2179.html // // Abandoning a process and at_quick_exit N2440 GCC 4.8 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2440.htm // // Allow atomics use in signal handlers N2547 Yes // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2547.htm // // Thread-local storage N2659 GCC 4.8 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2659.htm // // Dynamic initialization and destruction with concurrency N2660 GCC 4.3 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2660.htm // // __func__ predefined identifier N2340 GCC 4.3 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2340.htm // // C99 preprocessor N1653 GCC 4.3 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1653.htm // // long long N1811 GCC 4.3 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1811.pdf // // Extended integral types N1988 Yes // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1988.pdf #if(GLM_COMPILER & GLM_COMPILER_GCC) # if(GLM_COMPILER >= GLM_COMPILER_GCC43) # define GLM_CXX11_STATIC_ASSERT # endif #elif(GLM_COMPILER & (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM)) # if(__has_feature(cxx_exceptions)) # define GLM_CXX98_EXCEPTIONS # endif # if(__has_feature(cxx_rtti)) # define GLM_CXX98_RTTI # endif # if(__has_feature(cxx_access_control_sfinae)) # define GLM_CXX11_ACCESS_CONTROL_SFINAE # endif # if(__has_feature(cxx_alias_templates)) # define GLM_CXX11_ALIAS_TEMPLATE # endif # if(__has_feature(cxx_alignas)) # define GLM_CXX11_ALIGNAS # endif # if(__has_feature(cxx_attributes)) # define GLM_CXX11_ATTRIBUTES # endif # if(__has_feature(cxx_constexpr)) # define GLM_CXX11_CONSTEXPR # endif # if(__has_feature(cxx_decltype)) # define GLM_CXX11_DECLTYPE # endif # if(__has_feature(cxx_default_function_template_args)) # define GLM_CXX11_DEFAULT_FUNCTION_TEMPLATE_ARGS # endif # if(__has_feature(cxx_defaulted_functions)) # define GLM_CXX11_DEFAULTED_FUNCTIONS # endif # if(__has_feature(cxx_delegating_constructors)) # define GLM_CXX11_DELEGATING_CONSTRUCTORS # endif # if(__has_feature(cxx_deleted_functions)) # define GLM_CXX11_DELETED_FUNCTIONS # endif # if(__has_feature(cxx_explicit_conversions)) # define GLM_CXX11_EXPLICIT_CONVERSIONS # endif # if(__has_feature(cxx_generalized_initializers)) # define GLM_CXX11_GENERALIZED_INITIALIZERS # endif # if(__has_feature(cxx_implicit_moves)) # define GLM_CXX11_IMPLICIT_MOVES # endif # if(__has_feature(cxx_inheriting_constructors)) # define GLM_CXX11_INHERITING_CONSTRUCTORS # endif # if(__has_feature(cxx_inline_namespaces)) # define GLM_CXX11_INLINE_NAMESPACES # endif # if(__has_feature(cxx_lambdas)) # define GLM_CXX11_LAMBDAS # endif # if(__has_feature(cxx_local_type_template_args)) # define GLM_CXX11_LOCAL_TYPE_TEMPLATE_ARGS # endif # if(__has_feature(cxx_noexcept)) # define GLM_CXX11_NOEXCEPT # endif # if(__has_feature(cxx_nonstatic_member_init)) # define GLM_CXX11_NONSTATIC_MEMBER_INIT # endif # if(__has_feature(cxx_nullptr)) # define GLM_CXX11_NULLPTR # endif # if(__has_feature(cxx_override_control)) # define GLM_CXX11_OVERRIDE_CONTROL # endif # if(__has_feature(cxx_reference_qualified_functions)) # define GLM_CXX11_REFERENCE_QUALIFIED_FUNCTIONS # endif # if(__has_feature(cxx_range_for)) # define GLM_CXX11_RANGE_FOR # endif # if(__has_feature(cxx_raw_string_literals)) # define GLM_CXX11_RAW_STRING_LITERALS # endif # if(__has_feature(cxx_rvalue_references)) # define GLM_CXX11_RVALUE_REFERENCES # endif # if(__has_feature(cxx_static_assert)) # define GLM_CXX11_STATIC_ASSERT # endif # if(__has_feature(cxx_auto_type)) # define GLM_CXX11_AUTO_TYPE # endif # if(__has_feature(cxx_strong_enums)) # define GLM_CXX11_STRONG_ENUMS # endif # if(__has_feature(cxx_trailing_return)) # define GLM_CXX11_TRAILING_RETURN # endif # if(__has_feature(cxx_unicode_literals)) # define GLM_CXX11_UNICODE_LITERALS # endif # if(__has_feature(cxx_unrestricted_unions)) # define GLM_CXX11_UNRESTRICTED_UNIONS # endif # if(__has_feature(cxx_user_literals)) # define GLM_CXX11_USER_LITERALS # endif # if(__has_feature(cxx_variadic_templates)) # define GLM_CXX11_VARIADIC_TEMPLATES # endif #endif//(GLM_COMPILER & (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM)) anbox-0.0~git20191115/external/glm/glm/detail/_fixes.hpp000066400000000000000000000037721356361734700226460ustar00rootroot00000000000000/////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// /// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights /// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell /// copies of the Software, and to permit persons to whom the Software is /// furnished to do so, subject to the following conditions: /// /// The above copyright notice and this permission notice shall be included in /// all copies or substantial portions of the Software. /// /// Restrictions: /// By making use of the Software for military purposes, you choose to make /// a Bunny unhappy. /// /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE /// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER /// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, /// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN /// THE SOFTWARE. /// /// @ref core /// @file glm/detail/_fixes.hpp /// @date 2011-02-21 / 2011-11-22 /// @author Christophe Riccio /////////////////////////////////////////////////////////////////////////////////// #include //! Workaround for compatibility with other libraries #ifdef max #undef max #endif //! Workaround for compatibility with other libraries #ifdef min #undef min #endif //! Workaround for Android #ifdef isnan #undef isnan #endif //! Workaround for Android #ifdef isinf #undef isinf #endif //! Workaround for Chrone Native Client #ifdef log2 #undef log2 #endif anbox-0.0~git20191115/external/glm/glm/detail/_noise.hpp000066400000000000000000000106041356361734700226350ustar00rootroot00000000000000/////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// /// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights /// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell /// copies of the Software, and to permit persons to whom the Software is /// furnished to do so, subject to the following conditions: /// /// The above copyright notice and this permission notice shall be included in /// all copies or substantial portions of the Software. /// /// Restrictions: /// By making use of the Software for military purposes, you choose to make /// a Bunny unhappy. /// /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE /// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER /// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, /// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN /// THE SOFTWARE. /// /// @ref core /// @file glm/detail/_noise.hpp /// @date 2013-12-24 / 2013-12-24 /// @author Christophe Riccio /////////////////////////////////////////////////////////////////////////////////// #pragma once #include "../vec2.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #include "../common.hpp" namespace glm{ namespace detail { template GLM_FUNC_QUALIFIER T mod289(T const & x) { return x - floor(x * static_cast(1.0) / static_cast(289.0)) * static_cast(289.0); } template GLM_FUNC_QUALIFIER T permute(T const & x) { return mod289(((x * static_cast(34)) + static_cast(1)) * x); } template GLM_FUNC_QUALIFIER tvec2 permute(tvec2 const & x) { return mod289(((x * static_cast(34)) + static_cast(1)) * x); } template GLM_FUNC_QUALIFIER tvec3 permute(tvec3 const & x) { return mod289(((x * static_cast(34)) + static_cast(1)) * x); } template GLM_FUNC_QUALIFIER tvec4 permute(tvec4 const & x) { return mod289(((x * static_cast(34)) + static_cast(1)) * x); } /* template class vecType> GLM_FUNC_QUALIFIER vecType permute(vecType const & x) { return mod289(((x * T(34)) + T(1)) * x); } */ template GLM_FUNC_QUALIFIER T taylorInvSqrt(T const & r) { return T(1.79284291400159) - T(0.85373472095314) * r; } template GLM_FUNC_QUALIFIER tvec2 taylorInvSqrt(tvec2 const & r) { return T(1.79284291400159) - T(0.85373472095314) * r; } template GLM_FUNC_QUALIFIER tvec3 taylorInvSqrt(tvec3 const & r) { return T(1.79284291400159) - T(0.85373472095314) * r; } template GLM_FUNC_QUALIFIER tvec4 taylorInvSqrt(tvec4 const & r) { return T(1.79284291400159) - T(0.85373472095314) * r; } /* template class vecType> GLM_FUNC_QUALIFIER vecType taylorInvSqrt(vecType const & r) { return T(1.79284291400159) - T(0.85373472095314) * r; } */ template GLM_FUNC_QUALIFIER tvec2 fade(tvec2 const & t) { return (t * t * t) * (t * (t * T(6) - T(15)) + T(10)); } template GLM_FUNC_QUALIFIER tvec3 fade(tvec3 const & t) { return (t * t * t) * (t * (t * T(6) - T(15)) + T(10)); } template GLM_FUNC_QUALIFIER tvec4 fade(tvec4 const & t) { return (t * t * t) * (t * (t * T(6) - T(15)) + T(10)); } /* template class vecType> GLM_FUNC_QUALIFIER vecType fade(vecType const & t) { return (t * t * t) * (t * (t * T(6) - T(15)) + T(10)); } */ }//namespace detail }//namespace glm anbox-0.0~git20191115/external/glm/glm/detail/_swizzle.hpp000066400000000000000000001551071356361734700232370ustar00rootroot00000000000000/////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// /// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights /// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell /// copies of the Software, and to permit persons to whom the Software is /// furnished to do so, subject to the following conditions: /// /// The above copyright notice and this permission notice shall be included in /// all copies or substantial portions of the Software. /// /// Restrictions: /// By making use of the Software for military purposes, you choose to make /// a Bunny unhappy. /// /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE /// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER /// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, /// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN /// THE SOFTWARE. /// /// @ref core /// @file glm/detail/_swizzle.hpp /// @date 2006-04-20 / 2011-02-16 /// @author Christophe Riccio /////////////////////////////////////////////////////////////////////////////////// #pragma once namespace glm{ namespace detail { // Internal class for implementing swizzle operators template struct _swizzle_base0 { typedef T value_type; protected: GLM_FUNC_QUALIFIER value_type& elem (size_t i) { return (reinterpret_cast(_buffer))[i]; } GLM_FUNC_QUALIFIER const value_type& elem (size_t i) const { return (reinterpret_cast(_buffer))[i]; } // Use an opaque buffer to *ensure* the compiler doesn't call a constructor. // The size 1 buffer is assumed to aligned to the actual members so that the // elem() char _buffer[1]; }; template struct _swizzle_base1 : public _swizzle_base0 { }; template struct _swizzle_base1 : public _swizzle_base0 { GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0), this->elem(E1)); } }; template struct _swizzle_base1 : public _swizzle_base0 { GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0), this->elem(E1), this->elem(E2)); } }; template struct _swizzle_base1 : public _swizzle_base0 { GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0), this->elem(E1), this->elem(E2), this->elem(E3)); } }; // Internal class for implementing swizzle operators /* Template parameters: ValueType = type of scalar values (e.g. float, double) VecType = class the swizzle is applies to (e.g. tvec3) N = number of components in the vector (e.g. 3) E0...3 = what index the n-th element of this swizzle refers to in the unswizzled vec DUPLICATE_ELEMENTS = 1 if there is a repeated element, 0 otherwise (used to specialize swizzles containing duplicate elements so that they cannot be used as r-values). */ template struct _swizzle_base2 : public _swizzle_base1 { typedef VecType vec_type; typedef ValueType value_type; GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const ValueType& t) { for (int i = 0; i < N; ++i) (*this)[i] = t; return *this; } GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const VecType& that) { struct op { GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e = t; } }; _apply_op(that, op()); return *this; } GLM_FUNC_QUALIFIER void operator -= (const VecType& that) { struct op { GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e -= t; } }; _apply_op(that, op()); } GLM_FUNC_QUALIFIER void operator += (const VecType& that) { struct op { GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e += t; } }; _apply_op(that, op()); } GLM_FUNC_QUALIFIER void operator *= (const VecType& that) { struct op { GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e *= t; } }; _apply_op(that, op()); } GLM_FUNC_QUALIFIER void operator /= (const VecType& that) { struct op { GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e /= t; } }; _apply_op(that, op()); } GLM_FUNC_QUALIFIER value_type& operator[] (size_t i) { const int offset_dst[4] = { E0, E1, E2, E3 }; return this->elem(offset_dst[i]); } GLM_FUNC_QUALIFIER value_type operator[] (size_t i) const { const int offset_dst[4] = { E0, E1, E2, E3 }; return this->elem(offset_dst[i]); } protected: template GLM_FUNC_QUALIFIER void _apply_op(const VecType& that, T op) { // Make a copy of the data in this == &that. // The copier should optimize out the copy in cases where the function is // properly inlined and the copy is not necessary. ValueType t[N]; for (int i = 0; i < N; ++i) t[i] = that[i]; for (int i = 0; i < N; ++i) op( (*this)[i], t[i] ); } }; // Specialization for swizzles containing duplicate elements. These cannot be modified. template struct _swizzle_base2 : public _swizzle_base1 { typedef VecType vec_type; typedef ValueType value_type; struct Stub {}; GLM_FUNC_QUALIFIER _swizzle_base2& operator= (Stub const &) { return *this; } GLM_FUNC_QUALIFIER value_type operator[] (size_t i) const { const int offset_dst[4] = { E0, E1, E2, E3 }; return this->elem(offset_dst[i]); } }; template struct _swizzle : public _swizzle_base2 { typedef _swizzle_base2 base_type; using base_type::operator=; GLM_FUNC_QUALIFIER operator VecType () const { return (*this)(); } }; // // To prevent the C++ syntax from getting entirely overwhelming, define some alias macros // #define _GLM_SWIZZLE_TEMPLATE1 template #define _GLM_SWIZZLE_TEMPLATE2 template #define _GLM_SWIZZLE_TYPE1 _swizzle #define _GLM_SWIZZLE_TYPE2 _swizzle // // Wrapper for a binary operator (e.g. u.yy + v.zy) // #define _GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \ _GLM_SWIZZLE_TEMPLATE2 \ GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b) \ { \ return a() OPERAND b(); \ } \ _GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const V& b) \ { \ return a() OPERAND b; \ } \ _GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER V operator OPERAND ( const V& a, const _GLM_SWIZZLE_TYPE1& b) \ { \ return a OPERAND b(); \ } // // Wrapper for a operand between a swizzle and a binary (e.g. 1.0f - u.xyz) // #define _GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \ _GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const T& b) \ { \ return a() OPERAND b; \ } \ _GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER V operator OPERAND ( const T& a, const _GLM_SWIZZLE_TYPE1& b) \ { \ return a OPERAND b(); \ } // // Macro for wrapping a function taking one argument (e.g. abs()) // #define _GLM_SWIZZLE_FUNCTION_1_ARGS(RETURN_TYPE,FUNCTION) \ _GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a) \ { \ return FUNCTION(a()); \ } // // Macro for wrapping a function taking two vector arguments (e.g. dot()). // #define _GLM_SWIZZLE_FUNCTION_2_ARGS(RETURN_TYPE,FUNCTION) \ _GLM_SWIZZLE_TEMPLATE2 \ GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b) \ { \ return FUNCTION(a(), b()); \ } \ _GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b) \ { \ return FUNCTION(a(), b()); \ } \ _GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename V& b) \ { \ return FUNCTION(a(), b); \ } \ _GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const V& a, const _GLM_SWIZZLE_TYPE1& b) \ { \ return FUNCTION(a, b()); \ } // // Macro for wrapping a function take 2 vec arguments followed by a scalar (e.g. mix()). // #define _GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(RETURN_TYPE,FUNCTION) \ _GLM_SWIZZLE_TEMPLATE2 \ GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b, const T& c) \ { \ return FUNCTION(a(), b(), c); \ } \ _GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b, const T& c) \ { \ return FUNCTION(a(), b(), c); \ } \ _GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename S0::vec_type& b, const T& c)\ { \ return FUNCTION(a(), b, c); \ } \ _GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const typename V& a, const _GLM_SWIZZLE_TYPE1& b, const T& c) \ { \ return FUNCTION(a, b(), c); \ } }//namespace detail }//namespace glm namespace glm { namespace detail { _GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(-) _GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(*) _GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(+) _GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(-) _GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(*) _GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(/) } // // Swizzles are distinct types from the unswizzled type. The below macros will // provide template specializations for the swizzle types for the given functions // so that the compiler does not have any ambiguity to choosing how to handle // the function. // // The alternative is to use the operator()() when calling the function in order // to explicitly convert the swizzled type to the unswizzled type. // //_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, abs); //_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, acos); //_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, acosh); //_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, all); //_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, any); //_GLM_SWIZZLE_FUNCTION_2_ARGS(value_type, dot); //_GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type, cross); //_GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type, step); //_GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(vec_type, mix); } #define _GLM_SWIZZLE2_2_MEMBERS(T, P, V, E0,E1) \ struct { detail::_swizzle<2, T, P, V, 0,0,-1,-2> E0 ## E0; }; \ struct { detail::_swizzle<2, T, P, V, 0,1,-1,-2> E0 ## E1; }; \ struct { detail::_swizzle<2, T, P, V, 1,0,-1,-2> E1 ## E0; }; \ struct { detail::_swizzle<2, T, P, V, 1,1,-1,-2> E1 ## E1; }; #define _GLM_SWIZZLE2_3_MEMBERS(T, P, V, E0,E1) \ struct { detail::_swizzle<3,T, P, V, 0,0,0,-1> E0 ## E0 ## E0; }; \ struct { detail::_swizzle<3,T, P, V, 0,0,1,-1> E0 ## E0 ## E1; }; \ struct { detail::_swizzle<3,T, P, V, 0,1,0,-1> E0 ## E1 ## E0; }; \ struct { detail::_swizzle<3,T, P, V, 0,1,1,-1> E0 ## E1 ## E1; }; \ struct { detail::_swizzle<3,T, P, V, 1,0,0,-1> E1 ## E0 ## E0; }; \ struct { detail::_swizzle<3,T, P, V, 1,0,1,-1> E1 ## E0 ## E1; }; \ struct { detail::_swizzle<3,T, P, V, 1,1,0,-1> E1 ## E1 ## E0; }; \ struct { detail::_swizzle<3,T, P, V, 1,1,1,-1> E1 ## E1 ## E1; }; #define _GLM_SWIZZLE2_4_MEMBERS(T, P, V, E0,E1) \ struct { detail::_swizzle<4,T, P, V, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; #define _GLM_SWIZZLE3_2_MEMBERS(T, P, V, E0,E1,E2) \ struct { detail::_swizzle<2,T, P, V, 0,0,-1,-2> E0 ## E0; }; \ struct { detail::_swizzle<2,T, P, V, 0,1,-1,-2> E0 ## E1; }; \ struct { detail::_swizzle<2,T, P, V, 0,2,-1,-2> E0 ## E2; }; \ struct { detail::_swizzle<2,T, P, V, 1,0,-1,-2> E1 ## E0; }; \ struct { detail::_swizzle<2,T, P, V, 1,1,-1,-2> E1 ## E1; }; \ struct { detail::_swizzle<2,T, P, V, 1,2,-1,-2> E1 ## E2; }; \ struct { detail::_swizzle<2,T, P, V, 2,0,-1,-2> E2 ## E0; }; \ struct { detail::_swizzle<2,T, P, V, 2,1,-1,-2> E2 ## E1; }; \ struct { detail::_swizzle<2,T, P, V, 2,2,-1,-2> E2 ## E2; }; #define _GLM_SWIZZLE3_3_MEMBERS(T, P, V ,E0,E1,E2) \ struct { detail::_swizzle<3,T,P, V, 0,0,0,-1> E0 ## E0 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 0,0,1,-1> E0 ## E0 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 0,0,2,-1> E0 ## E0 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 0,1,0,-1> E0 ## E1 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 0,1,1,-1> E0 ## E1 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 0,1,2,-1> E0 ## E1 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 0,2,0,-1> E0 ## E2 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 0,2,1,-1> E0 ## E2 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 0,2,2,-1> E0 ## E2 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 1,0,0,-1> E1 ## E0 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 1,0,1,-1> E1 ## E0 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 1,0,2,-1> E1 ## E0 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 1,1,0,-1> E1 ## E1 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 1,1,1,-1> E1 ## E1 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 1,1,2,-1> E1 ## E1 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 1,2,0,-1> E1 ## E2 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 1,2,1,-1> E1 ## E2 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 1,2,2,-1> E1 ## E2 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 2,0,0,-1> E2 ## E0 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 2,0,1,-1> E2 ## E0 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 2,0,2,-1> E2 ## E0 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 2,1,0,-1> E2 ## E1 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 2,1,1,-1> E2 ## E1 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 2,1,2,-1> E2 ## E1 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 2,2,0,-1> E2 ## E2 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 2,2,1,-1> E2 ## E2 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 2,2,2,-1> E2 ## E2 ## E2; }; #define _GLM_SWIZZLE3_4_MEMBERS(T, P, V, E0,E1,E2) \ struct { detail::_swizzle<4,T, P, V, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, P, V, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, P, V, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, P, V, 2,2,2,2> E2 ## E2 ## E2 ## E2; }; #define _GLM_SWIZZLE4_2_MEMBERS(T, P, V, E0,E1,E2,E3) \ struct { detail::_swizzle<2,T, P, V, 0,0,-1,-2> E0 ## E0; }; \ struct { detail::_swizzle<2,T, P, V, 0,1,-1,-2> E0 ## E1; }; \ struct { detail::_swizzle<2,T, P, V, 0,2,-1,-2> E0 ## E2; }; \ struct { detail::_swizzle<2,T, P, V, 0,3,-1,-2> E0 ## E3; }; \ struct { detail::_swizzle<2,T, P, V, 1,0,-1,-2> E1 ## E0; }; \ struct { detail::_swizzle<2,T, P, V, 1,1,-1,-2> E1 ## E1; }; \ struct { detail::_swizzle<2,T, P, V, 1,2,-1,-2> E1 ## E2; }; \ struct { detail::_swizzle<2,T, P, V, 1,3,-1,-2> E1 ## E3; }; \ struct { detail::_swizzle<2,T, P, V, 2,0,-1,-2> E2 ## E0; }; \ struct { detail::_swizzle<2,T, P, V, 2,1,-1,-2> E2 ## E1; }; \ struct { detail::_swizzle<2,T, P, V, 2,2,-1,-2> E2 ## E2; }; \ struct { detail::_swizzle<2,T, P, V, 2,3,-1,-2> E2 ## E3; }; \ struct { detail::_swizzle<2,T, P, V, 3,0,-1,-2> E3 ## E0; }; \ struct { detail::_swizzle<2,T, P, V, 3,1,-1,-2> E3 ## E1; }; \ struct { detail::_swizzle<2,T, P, V, 3,2,-1,-2> E3 ## E2; }; \ struct { detail::_swizzle<2,T, P, V, 3,3,-1,-2> E3 ## E3; }; #define _GLM_SWIZZLE4_3_MEMBERS(T,P, V, E0,E1,E2,E3) \ struct { detail::_swizzle<3,T,P, V, 0,0,0,-1> E0 ## E0 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 0,0,1,-1> E0 ## E0 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 0,0,2,-1> E0 ## E0 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 0,0,3,-1> E0 ## E0 ## E3; }; \ struct { detail::_swizzle<3,T,P, V, 0,1,0,-1> E0 ## E1 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 0,1,1,-1> E0 ## E1 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 0,1,2,-1> E0 ## E1 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 0,1,3,-1> E0 ## E1 ## E3; }; \ struct { detail::_swizzle<3,T,P, V, 0,2,0,-1> E0 ## E2 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 0,2,1,-1> E0 ## E2 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 0,2,2,-1> E0 ## E2 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 0,2,3,-1> E0 ## E2 ## E3; }; \ struct { detail::_swizzle<3,T,P, V, 0,3,0,-1> E0 ## E3 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 0,3,1,-1> E0 ## E3 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 0,3,2,-1> E0 ## E3 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 0,3,3,-1> E0 ## E3 ## E3; }; \ struct { detail::_swizzle<3,T,P, V, 1,0,0,-1> E1 ## E0 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 1,0,1,-1> E1 ## E0 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 1,0,2,-1> E1 ## E0 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 1,0,3,-1> E1 ## E0 ## E3; }; \ struct { detail::_swizzle<3,T,P, V, 1,1,0,-1> E1 ## E1 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 1,1,1,-1> E1 ## E1 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 1,1,2,-1> E1 ## E1 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 1,1,3,-1> E1 ## E1 ## E3; }; \ struct { detail::_swizzle<3,T,P, V, 1,2,0,-1> E1 ## E2 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 1,2,1,-1> E1 ## E2 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 1,2,2,-1> E1 ## E2 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 1,2,3,-1> E1 ## E2 ## E3; }; \ struct { detail::_swizzle<3,T,P, V, 1,3,0,-1> E1 ## E3 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 1,3,1,-1> E1 ## E3 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 1,3,2,-1> E1 ## E3 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 1,3,3,-1> E1 ## E3 ## E3; }; \ struct { detail::_swizzle<3,T,P, V, 2,0,0,-1> E2 ## E0 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 2,0,1,-1> E2 ## E0 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 2,0,2,-1> E2 ## E0 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 2,0,3,-1> E2 ## E0 ## E3; }; \ struct { detail::_swizzle<3,T,P, V, 2,1,0,-1> E2 ## E1 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 2,1,1,-1> E2 ## E1 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 2,1,2,-1> E2 ## E1 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 2,1,3,-1> E2 ## E1 ## E3; }; \ struct { detail::_swizzle<3,T,P, V, 2,2,0,-1> E2 ## E2 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 2,2,1,-1> E2 ## E2 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 2,2,2,-1> E2 ## E2 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 2,2,3,-1> E2 ## E2 ## E3; }; \ struct { detail::_swizzle<3,T,P, V, 2,3,0,-1> E2 ## E3 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 2,3,1,-1> E2 ## E3 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 2,3,2,-1> E2 ## E3 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 2,3,3,-1> E2 ## E3 ## E3; }; \ struct { detail::_swizzle<3,T,P, V, 3,0,0,-1> E3 ## E0 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 3,0,1,-1> E3 ## E0 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 3,0,2,-1> E3 ## E0 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 3,0,3,-1> E3 ## E0 ## E3; }; \ struct { detail::_swizzle<3,T,P, V, 3,1,0,-1> E3 ## E1 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 3,1,1,-1> E3 ## E1 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 3,1,2,-1> E3 ## E1 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 3,1,3,-1> E3 ## E1 ## E3; }; \ struct { detail::_swizzle<3,T,P, V, 3,2,0,-1> E3 ## E2 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 3,2,1,-1> E3 ## E2 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 3,2,2,-1> E3 ## E2 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 3,2,3,-1> E3 ## E2 ## E3; }; \ struct { detail::_swizzle<3,T,P, V, 3,3,0,-1> E3 ## E3 ## E0; }; \ struct { detail::_swizzle<3,T,P, V, 3,3,1,-1> E3 ## E3 ## E1; }; \ struct { detail::_swizzle<3,T,P, V, 3,3,2,-1> E3 ## E3 ## E2; }; \ struct { detail::_swizzle<3,T,P, V, 3,3,3,-1> E3 ## E3 ## E3; }; #define _GLM_SWIZZLE4_4_MEMBERS(T, P, V, E0,E1,E2,E3) \ struct { detail::_swizzle<4, T, P, V, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 0,0,0,3> E0 ## E0 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 0,0,1,3> E0 ## E0 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 0,0,2,3> E0 ## E0 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 0,0,3,0> E0 ## E0 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 0,0,3,1> E0 ## E0 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 0,0,3,2> E0 ## E0 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 0,0,3,3> E0 ## E0 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 0,1,0,3> E0 ## E1 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 0,1,1,3> E0 ## E1 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 0,1,2,3> E0 ## E1 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 0,1,3,0> E0 ## E1 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 0,1,3,1> E0 ## E1 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 0,1,3,2> E0 ## E1 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 0,1,3,3> E0 ## E1 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 0,2,0,3> E0 ## E2 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 0,2,1,3> E0 ## E2 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 0,2,2,3> E0 ## E2 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 0,2,3,0> E0 ## E2 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 0,2,3,1> E0 ## E2 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 0,2,3,2> E0 ## E2 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 0,2,3,3> E0 ## E2 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 0,3,0,0> E0 ## E3 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 0,3,0,1> E0 ## E3 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 0,3,0,2> E0 ## E3 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 0,3,0,3> E0 ## E3 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 0,3,1,0> E0 ## E3 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 0,3,1,1> E0 ## E3 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 0,3,1,2> E0 ## E3 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 0,3,1,3> E0 ## E3 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 0,3,2,0> E0 ## E3 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 0,3,2,1> E0 ## E3 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 0,3,2,2> E0 ## E3 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 0,3,2,3> E0 ## E3 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 0,3,3,0> E0 ## E3 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 0,3,3,1> E0 ## E3 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 0,3,3,2> E0 ## E3 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 0,3,3,3> E0 ## E3 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 1,0,0,3> E1 ## E0 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 1,0,1,3> E1 ## E0 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 1,0,2,3> E1 ## E0 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 1,0,3,0> E1 ## E0 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 1,0,3,1> E1 ## E0 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 1,0,3,2> E1 ## E0 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 1,0,3,3> E1 ## E0 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 1,1,0,3> E1 ## E1 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 1,1,1,3> E1 ## E1 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 1,1,2,3> E1 ## E1 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 1,1,3,0> E1 ## E1 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 1,1,3,1> E1 ## E1 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 1,1,3,2> E1 ## E1 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 1,1,3,3> E1 ## E1 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 1,2,0,3> E1 ## E2 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 1,2,1,3> E1 ## E2 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 1,2,2,3> E1 ## E2 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 1,2,3,0> E1 ## E2 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 1,2,3,1> E1 ## E2 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 1,2,3,2> E1 ## E2 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 1,2,3,3> E1 ## E2 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 1,3,0,0> E1 ## E3 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 1,3,0,1> E1 ## E3 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 1,3,0,2> E1 ## E3 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 1,3,0,3> E1 ## E3 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 1,3,1,0> E1 ## E3 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 1,3,1,1> E1 ## E3 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 1,3,1,2> E1 ## E3 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 1,3,1,3> E1 ## E3 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 1,3,2,0> E1 ## E3 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 1,3,2,1> E1 ## E3 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 1,3,2,2> E1 ## E3 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 1,3,2,3> E1 ## E3 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 1,3,3,0> E1 ## E3 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 1,3,3,1> E1 ## E3 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 1,3,3,2> E1 ## E3 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 1,3,3,3> E1 ## E3 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 2,0,0,3> E2 ## E0 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 2,0,1,3> E2 ## E0 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 2,0,2,3> E2 ## E0 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 2,0,3,0> E2 ## E0 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 2,0,3,1> E2 ## E0 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 2,0,3,2> E2 ## E0 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 2,0,3,3> E2 ## E0 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 2,1,0,3> E2 ## E1 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 2,1,1,3> E2 ## E1 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 2,1,2,3> E2 ## E1 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 2,1,3,0> E2 ## E1 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 2,1,3,1> E2 ## E1 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 2,1,3,2> E2 ## E1 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 2,1,3,3> E2 ## E1 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 2,2,0,3> E2 ## E2 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 2,2,1,3> E2 ## E2 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 2,2,2,2> E2 ## E2 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 2,2,2,3> E2 ## E2 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 2,2,3,0> E2 ## E2 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 2,2,3,1> E2 ## E2 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 2,2,3,2> E2 ## E2 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 2,2,3,3> E2 ## E2 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 2,3,0,0> E2 ## E3 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 2,3,0,1> E2 ## E3 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 2,3,0,2> E2 ## E3 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 2,3,0,3> E2 ## E3 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 2,3,1,0> E2 ## E3 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 2,3,1,1> E2 ## E3 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 2,3,1,2> E2 ## E3 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 2,3,1,3> E2 ## E3 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 2,3,2,0> E2 ## E3 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 2,3,2,1> E2 ## E3 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 2,3,2,2> E2 ## E3 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 2,3,2,3> E2 ## E3 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 2,3,3,0> E2 ## E3 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 2,3,3,1> E2 ## E3 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 2,3,3,2> E2 ## E3 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 2,3,3,3> E2 ## E3 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 3,0,0,0> E3 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 3,0,0,1> E3 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 3,0,0,2> E3 ## E0 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 3,0,0,3> E3 ## E0 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 3,0,1,0> E3 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 3,0,1,1> E3 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 3,0,1,2> E3 ## E0 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 3,0,1,3> E3 ## E0 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 3,0,2,0> E3 ## E0 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 3,0,2,1> E3 ## E0 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 3,0,2,2> E3 ## E0 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 3,0,2,3> E3 ## E0 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 3,0,3,0> E3 ## E0 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 3,0,3,1> E3 ## E0 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 3,0,3,2> E3 ## E0 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 3,0,3,3> E3 ## E0 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 3,1,0,0> E3 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 3,1,0,1> E3 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 3,1,0,2> E3 ## E1 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 3,1,0,3> E3 ## E1 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 3,1,1,0> E3 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 3,1,1,1> E3 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 3,1,1,2> E3 ## E1 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 3,1,1,3> E3 ## E1 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 3,1,2,0> E3 ## E1 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 3,1,2,1> E3 ## E1 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 3,1,2,2> E3 ## E1 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 3,1,2,3> E3 ## E1 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 3,1,3,0> E3 ## E1 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 3,1,3,1> E3 ## E1 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 3,1,3,2> E3 ## E1 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 3,1,3,3> E3 ## E1 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 3,2,0,0> E3 ## E2 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 3,2,0,1> E3 ## E2 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 3,2,0,2> E3 ## E2 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 3,2,0,3> E3 ## E2 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 3,2,1,0> E3 ## E2 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 3,2,1,1> E3 ## E2 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 3,2,1,2> E3 ## E2 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 3,2,1,3> E3 ## E2 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 3,2,2,0> E3 ## E2 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 3,2,2,1> E3 ## E2 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 3,2,2,2> E3 ## E2 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 3,2,2,3> E3 ## E2 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 3,2,3,0> E3 ## E2 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 3,2,3,1> E3 ## E2 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 3,2,3,2> E3 ## E2 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 3,2,3,3> E3 ## E2 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 3,3,0,0> E3 ## E3 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 3,3,0,1> E3 ## E3 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 3,3,0,2> E3 ## E3 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 3,3,0,3> E3 ## E3 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 3,3,1,0> E3 ## E3 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 3,3,1,1> E3 ## E3 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 3,3,1,2> E3 ## E3 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 3,3,1,3> E3 ## E3 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 3,3,2,0> E3 ## E3 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 3,3,2,1> E3 ## E3 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 3,3,2,2> E3 ## E3 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 3,3,2,3> E3 ## E3 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, P, V, 3,3,3,0> E3 ## E3 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, P, V, 3,3,3,1> E3 ## E3 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, P, V, 3,3,3,2> E3 ## E3 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, P, V, 3,3,3,3> E3 ## E3 ## E3 ## E3; }; anbox-0.0~git20191115/external/glm/glm/detail/_swizzle_func.hpp000066400000000000000000001775421356361734700242610ustar00rootroot00000000000000/////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// /// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights /// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell /// copies of the Software, and to permit persons to whom the Software is /// furnished to do so, subject to the following conditions: /// /// The above copyright notice and this permission notice shall be included in /// all copies or substantial portions of the Software. /// /// Restrictions: /// By making use of the Software for military purposes, you choose to make /// a Bunny unhappy. /// /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE /// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER /// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, /// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN /// THE SOFTWARE. /// /// @ref core /// @file glm/detail/_swizzle_func.hpp /// @date 2011-10-16 / 2011-10-16 /// @author Christophe Riccio /////////////////////////////////////////////////////////////////////////////////// #pragma once #define GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B) \ SWIZZLED_TYPE A ## B() CONST \ { \ return SWIZZLED_TYPE(this->A, this->B); \ } #define GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C) \ SWIZZLED_TYPE A ## B ## C() CONST \ { \ return SWIZZLED_TYPE(this->A, this->B, this->C); \ } #define GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C, D) \ SWIZZLED_TYPE A ## B ## C ## D() CONST \ { \ return SWIZZLED_TYPE(this->A, this->B, this->C, this->D); \ } #define GLM_SWIZZLE_GEN_VEC2_ENTRY_DEF(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B) \ template \ SWIZZLED_TYPE CLASS_TYPE::A ## B() CONST \ { \ return SWIZZLED_TYPE(this->A, this->B); \ } #define GLM_SWIZZLE_GEN_VEC3_ENTRY_DEF(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C) \ template \ SWIZZLED_TYPE CLASS_TYPE::A ## B ## C() CONST \ { \ return SWIZZLED_TYPE(this->A, this->B, this->C); \ } #define GLM_SWIZZLE_GEN_VEC4_ENTRY_DEF(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C, D) \ template \ SWIZZLED_TYPE CLASS_TYPE::A ## B ## C ## D() CONST \ { \ return SWIZZLED_TYPE(this->A, this->B, this->C, this->D); \ } #define GLM_MUTABLE #define GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A) #define GLM_SWIZZLE_GEN_REF_FROM_VEC2(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE) \ GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, x, y) \ GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, r, g) \ GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, s, t) //GLM_SWIZZLE_GEN_REF_FROM_VEC2(valType, detail::vec2, detail::ref2) #define GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B) #define GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B, A) #define GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \ GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \ GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C) #define GLM_SWIZZLE_GEN_REF_FROM_VEC3(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE) \ GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, x, y, z) \ GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, r, g, b) \ GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, s, t, p) //GLM_SWIZZLE_GEN_REF_FROM_VEC3(valType, detail::vec3, detail::ref2, detail::ref3) #define GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, C) #define GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, B) #define GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, C, A) #define GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D) \ GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C, D) \ GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C, D) \ GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D) #define GLM_SWIZZLE_GEN_REF_FROM_VEC4(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \ GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z, w) \ GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b, a) \ GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, p, q) //GLM_SWIZZLE_GEN_REF_FROM_VEC4(valType, detail::vec4, detail::ref2, detail::ref3, detail::ref4) #define GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B) #define GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B) #define GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B) #define GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B) \ GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B) \ GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B) \ GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B) #define GLM_SWIZZLE_GEN_VEC_FROM_VEC2(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t) //GLM_SWIZZLE_GEN_VEC_FROM_VEC2(valType, detail::vec2, detail::vec2, detail::vec3, detail::vec4) #define GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C) #define GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C) #define GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, C) #define GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C) \ GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C) \ GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C) #define GLM_SWIZZLE_GEN_VEC_FROM_VEC3(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, p) //GLM_SWIZZLE_GEN_VEC_FROM_VEC3(valType, detail::vec3, detail::vec2, detail::vec3, detail::vec4) #define GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D) #define GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D) #define GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, D) #define GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D) #define GLM_SWIZZLE_GEN_VEC_FROM_VEC4(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z, w) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b, a) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, p, q) //GLM_SWIZZLE_GEN_VEC_FROM_VEC4(valType, detail::vec4, detail::vec2, detail::vec3, detail::vec4) anbox-0.0~git20191115/external/glm/glm/detail/_vectorize.hpp000066400000000000000000000121371356361734700235350ustar00rootroot00000000000000/////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// /// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights /// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell /// copies of the Software, and to permit persons to whom the Software is /// furnished to do so, subject to the following conditions: /// /// The above copyright notice and this permission notice shall be included in /// all copies or substantial portions of the Software. /// /// Restrictions: /// By making use of the Software for military purposes, you choose to make /// a Bunny unhappy. /// /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE /// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER /// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, /// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN /// THE SOFTWARE. /// /// @ref core /// @file glm/detail/_vectorize.hpp /// @date 2011-10-14 / 2011-10-14 /// @author Christophe Riccio /////////////////////////////////////////////////////////////////////////////////// #pragma once #include "type_vec1.hpp" #include "type_vec2.hpp" #include "type_vec3.hpp" #include "type_vec4.hpp" namespace glm{ namespace detail { template class vecType> struct functor1{}; template struct functor1 { GLM_FUNC_QUALIFIER static tvec1 call(R (*Func) (T x), tvec1 const & v) { return tvec1(Func(v.x)); } }; template struct functor1 { GLM_FUNC_QUALIFIER static tvec2 call(R (*Func) (T x), tvec2 const & v) { return tvec2(Func(v.x), Func(v.y)); } }; template struct functor1 { GLM_FUNC_QUALIFIER static tvec3 call(R (*Func) (T x), tvec3 const & v) { return tvec3(Func(v.x), Func(v.y), Func(v.z)); } }; template struct functor1 { GLM_FUNC_QUALIFIER static tvec4 call(R (*Func) (T x), tvec4 const & v) { return tvec4(Func(v.x), Func(v.y), Func(v.z), Func(v.w)); } }; template class vecType> struct functor2{}; template struct functor2 { GLM_FUNC_QUALIFIER static tvec1 call(T (*Func) (T x, T y), tvec1 const & a, tvec1 const & b) { return tvec1(Func(a.x, b.x)); } }; template struct functor2 { GLM_FUNC_QUALIFIER static tvec2 call(T (*Func) (T x, T y), tvec2 const & a, tvec2 const & b) { return tvec2(Func(a.x, b.x), Func(a.y, b.y)); } }; template struct functor2 { GLM_FUNC_QUALIFIER static tvec3 call(T (*Func) (T x, T y), tvec3 const & a, tvec3 const & b) { return tvec3(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z)); } }; template struct functor2 { GLM_FUNC_QUALIFIER static tvec4 call(T (*Func) (T x, T y), tvec4 const & a, tvec4 const & b) { return tvec4(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z), Func(a.w, b.w)); } }; template class vecType> struct functor2_vec_sca{}; template struct functor2_vec_sca { GLM_FUNC_QUALIFIER static tvec1 call(T (*Func) (T x, T y), tvec1 const & a, T b) { return tvec1(Func(a.x, b)); } }; template struct functor2_vec_sca { GLM_FUNC_QUALIFIER static tvec2 call(T (*Func) (T x, T y), tvec2 const & a, T b) { return tvec2(Func(a.x, b), Func(a.y, b)); } }; template struct functor2_vec_sca { GLM_FUNC_QUALIFIER static tvec3 call(T (*Func) (T x, T y), tvec3 const & a, T b) { return tvec3(Func(a.x, b), Func(a.y, b), Func(a.z, b)); } }; template struct functor2_vec_sca { GLM_FUNC_QUALIFIER static tvec4 call(T (*Func) (T x, T y), tvec4 const & a, T b) { return tvec4(Func(a.x, b), Func(a.y, b), Func(a.z, b), Func(a.w, b)); } }; }//namespace detail }//namespace glm anbox-0.0~git20191115/external/glm/glm/detail/dummy.cpp000066400000000000000000000163341356361734700225150ustar00rootroot00000000000000/////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// /// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights /// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell /// copies of the Software, and to permit persons to whom the Software is /// furnished to do so, subject to the following conditions: /// /// The above copyright notice and this permission notice shall be included in /// all copies or substantial portions of the Software. /// /// Restrictions: /// By making use of the Software for military purposes, you choose to make /// a Bunny unhappy. /// /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE /// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER /// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, /// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN /// THE SOFTWARE. /// /// @ref core /// @file glm/core/dummy.cpp /// @date 2011-01-19 / 2011-06-15 /// @author Christophe Riccio /// /// GLM is a header only library. There is nothing to compile. /// dummy.cpp exist only a wordaround for CMake file. /////////////////////////////////////////////////////////////////////////////////// #define GLM_MESSAGES #include #include #include struct material { glm::vec4 emission; // Ecm glm::vec4 ambient; // Acm glm::vec4 diffuse; // Dcm glm::vec4 specular; // Scm float shininess; // Srm }; struct light { glm::vec4 ambient; // Acli glm::vec4 diffuse; // Dcli glm::vec4 specular; // Scli glm::vec4 position; // Ppli glm::vec4 halfVector; // Derived: Hi glm::vec3 spotDirection; // Sdli float spotExponent; // Srli float spotCutoff; // Crli // (range: [0.0,90.0], 180.0) float spotCosCutoff; // Derived: cos(Crli) // (range: [1.0,0.0],-1.0) float constantAttenuation; // K0 float linearAttenuation; // K1 float quadraticAttenuation;// K2 }; // Sample 1 #include // glm::vec3 #include // glm::cross, glm::normalize glm::vec3 computeNormal ( glm::vec3 const & a, glm::vec3 const & b, glm::vec3 const & c ) { return glm::normalize(glm::cross(c - a, b - a)); } typedef unsigned int GLuint; #define GL_FALSE 0 void glUniformMatrix4fv(GLuint, int, int, float*){} // Sample 2 #include // glm::vec3 #include // glm::vec4, glm::ivec4 #include // glm::mat4 #include // glm::translate, glm::rotate, glm::scale, glm::perspective #include // glm::value_ptr void func(GLuint LocationMVP, float Translate, glm::vec2 const & Rotate) { glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.f); glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Translate)); glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Rotate.y, glm::vec3(-1.0f, 0.0f, 0.0f)); glm::mat4 View = glm::rotate(ViewRotateX, Rotate.x, glm::vec3(0.0f, 1.0f, 0.0f)); glm::mat4 Model = glm::scale(glm::mat4(1.0f), glm::vec3(0.5f)); glm::mat4 MVP = Projection * View * Model; glUniformMatrix4fv(LocationMVP, 1, GL_FALSE, glm::value_ptr(MVP)); } // Sample 3 #include // glm::vec2 #include // glm::packUnorm2x16 #include // glm::uint #include // glm::i8vec2, glm::i32vec2 std::size_t const VertexCount = 4; // Float quad geometry std::size_t const PositionSizeF32 = VertexCount * sizeof(glm::vec2); glm::vec2 const PositionDataF32[VertexCount] = { glm::vec2(-1.0f,-1.0f), glm::vec2( 1.0f,-1.0f), glm::vec2( 1.0f, 1.0f), glm::vec2(-1.0f, 1.0f) }; // Half-float quad geometry std::size_t const PositionSizeF16 = VertexCount * sizeof(glm::uint); glm::uint const PositionDataF16[VertexCount] = { glm::uint(glm::packUnorm2x16(glm::vec2(-1.0f, -1.0f))), glm::uint(glm::packUnorm2x16(glm::vec2( 1.0f, -1.0f))), glm::uint(glm::packUnorm2x16(glm::vec2( 1.0f, 1.0f))), glm::uint(glm::packUnorm2x16(glm::vec2(-1.0f, 1.0f))) }; // 8 bits signed integer quad geometry std::size_t const PositionSizeI8 = VertexCount * sizeof(glm::i8vec2); glm::i8vec2 const PositionDataI8[VertexCount] = { glm::i8vec2(-1,-1), glm::i8vec2( 1,-1), glm::i8vec2( 1, 1), glm::i8vec2(-1, 1) }; // 32 bits signed integer quad geometry std::size_t const PositionSizeI32 = VertexCount * sizeof(glm::i32vec2); glm::i32vec2 const PositionDataI32[VertexCount] = { glm::i32vec2 (-1,-1), glm::i32vec2 ( 1,-1), glm::i32vec2 ( 1, 1), glm::i32vec2 (-1, 1) }; struct intersection { glm::vec4 position; glm::vec3 normal; }; /* // Sample 4 #include // glm::vec3 #include // glm::normalize, glm::dot, glm::reflect #include // glm::pow #include // glm::vecRand3 glm::vec3 lighting ( intersection const & Intersection, material const & Material, light const & Light, glm::vec3 const & View ) { glm::vec3 Color(0.0f); glm::vec3 LightVertor(glm::normalize( Light.position - Intersection.position + glm::vecRand3(0.0f, Light.inaccuracy)); if(!shadow(Intersection.position, Light.position, LightVertor)) { float Diffuse = glm::dot(Intersection.normal, LightVector); if(Diffuse <= 0.0f) return Color; if(Material.isDiffuse()) Color += Light.color() * Material.diffuse * Diffuse; if(Material.isSpecular()) { glm::vec3 Reflect(glm::reflect( glm::normalize(-LightVector), glm::normalize(Intersection.normal))); float Dot = glm::dot(Reflect, View); float Base = Dot > 0.0f ? Dot : 0.0f; float Specular = glm::pow(Base, Material.exponent); Color += Material.specular * Specular; } } return Color; } */ template class vecType> T normalizeDotA(vecType const & x, vecType const & y) { return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y)); } #define GLM_TEMPLATE_GENTYPE typename T, glm::precision P, template class template T normalizeDotB(vecType const & x, vecType const & y) { return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y)); } template typename vecType::value_type normalizeDotC(vecType const & a, vecType const & b) { return glm::dot(a, b) * glm::inversesqrt(glm::dot(a, a) * glm::dot(b, b)); } int main() { glm::vec1 o(1); glm::vec2 a(1); glm::vec3 b(1); glm::vec4 c(1); glm::quat q; glm::dualquat p; glm::mat4 m(1); float a0 = normalizeDotA(a, a); float b0 = normalizeDotB(b, b); float c0 = normalizeDotC(c, c); return 0; } anbox-0.0~git20191115/external/glm/glm/detail/func_common.hpp000066400000000000000000000576201356361734700236750ustar00rootroot00000000000000/////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// /// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights /// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell /// copies of the Software, and to permit persons to whom the Software is /// furnished to do so, subject to the following conditions: /// /// The above copyright notice and this permission notice shall be included in /// all copies or substantial portions of the Software. /// /// Restrictions: /// By making use of the Software for military purposes, you choose to make /// a Bunny unhappy. /// /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE /// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER /// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, /// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN /// THE SOFTWARE. /// /// @ref core /// @file glm/detail/func_common.hpp /// @date 2008-03-08 / 2010-01-26 /// @author Christophe Riccio /// /// @see GLSL 4.20.8 specification, section 8.3 Common Functions /// /// @defgroup core_func_common Common functions /// @ingroup core /// /// These all operate component-wise. The description is per component. /////////////////////////////////////////////////////////////////////////////////// #pragma once #include "setup.hpp" #include "precision.hpp" #include "type_int.hpp" #include "_fixes.hpp" namespace glm { /// @addtogroup core_func_common /// @{ /// Returns x if x >= 0; otherwise, it returns -x. /// /// @tparam genType floating-point or signed integer; scalar or vector types. /// /// @see GLSL abs man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType abs(genType x); template class vecType> GLM_FUNC_DECL vecType abs(vecType const & x); /// Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0. /// /// @tparam genType Floating-point or signed integer; scalar or vector types. /// /// @see GLSL sign man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template class vecType> GLM_FUNC_DECL vecType sign(vecType const & x); /// Returns a value equal to the nearest integer that is less then or equal to x. /// /// @tparam genType Floating-point scalar or vector types. /// /// @see GLSL floor man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template class vecType> GLM_FUNC_DECL vecType floor(vecType const & x); /// Returns a value equal to the nearest integer to x /// whose absolute value is not larger than the absolute value of x. /// /// @tparam genType Floating-point scalar or vector types. /// /// @see GLSL trunc man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template class vecType> GLM_FUNC_DECL vecType trunc(vecType const & x); /// Returns a value equal to the nearest integer to x. /// The fraction 0.5 will round in a direction chosen by the /// implementation, presumably the direction that is fastest. /// This includes the possibility that round(x) returns the /// same value as roundEven(x) for all values of x. /// /// @tparam genType Floating-point scalar or vector types. /// /// @see GLSL round man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template class vecType> GLM_FUNC_DECL vecType round(vecType const & x); /// Returns a value equal to the nearest integer to x. /// A fractional part of 0.5 will round toward the nearest even /// integer. (Both 3.5 and 4.5 for x will return 4.0.) /// /// @tparam genType Floating-point scalar or vector types. /// /// @see GLSL roundEven man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions /// @see New round to even technique template class vecType> GLM_FUNC_DECL vecType roundEven(vecType const & x); /// Returns a value equal to the nearest integer /// that is greater than or equal to x. /// /// @tparam genType Floating-point scalar or vector types. /// /// @see GLSL ceil man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template class vecType> GLM_FUNC_DECL vecType ceil(vecType const & x); /// Return x - floor(x). /// /// @tparam genType Floating-point scalar or vector types. /// /// @see GLSL fract man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType fract(genType x); template class vecType> GLM_FUNC_DECL vecType fract(vecType const & x); /// Modulus. Returns x - y * floor(x / y) /// for each component in x using the floating point value y. /// /// @tparam genType Floating-point scalar or vector types. /// /// @see GLSL mod man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType mod(genType x, genType y); template class vecType> GLM_FUNC_DECL vecType mod(vecType const & x, T y); template class vecType> GLM_FUNC_DECL vecType mod(vecType const & x, vecType const & y); /// Returns the fractional part of x and sets i to the integer /// part (as a whole number floating point value). Both the /// return value and the output parameter will have the same /// sign as x. /// /// @tparam genType Floating-point scalar or vector types. /// /// @see GLSL modf man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType modf(genType x, genType & i); /// Returns y if y < x; otherwise, it returns x. /// /// @tparam genType Floating-point or integer; scalar or vector types. /// /// @see GLSL min man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType min(genType x, genType y); template class vecType> GLM_FUNC_DECL vecType min(vecType const & x, T y); template class vecType> GLM_FUNC_DECL vecType min(vecType const & x, vecType const & y); /// Returns y if x < y; otherwise, it returns x. /// /// @tparam genType Floating-point or integer; scalar or vector types. /// /// @see GLSL max man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType max(genType x, genType y); template class vecType> GLM_FUNC_DECL vecType max(vecType const & x, T y); template class vecType> GLM_FUNC_DECL vecType max(vecType const & x, vecType const & y); /// Returns min(max(x, minVal), maxVal) for each component in x /// using the floating-point values minVal and maxVal. /// /// @tparam genType Floating-point or integer; scalar or vector types. /// /// @see GLSL clamp man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType clamp(genType x, genType minVal, genType maxVal); template class vecType> GLM_FUNC_DECL vecType clamp(vecType const & x, T minVal, T maxVal); template class vecType> GLM_FUNC_DECL vecType clamp(vecType const & x, vecType const & minVal, vecType const & maxVal); /// If genTypeU is a floating scalar or vector: /// Returns x * (1.0 - a) + y * a, i.e., the linear blend of /// x and y using the floating-point value a. /// The value for a is not restricted to the range [0, 1]. /// /// If genTypeU is a boolean scalar or vector: /// Selects which vector each returned component comes /// from. For a component of that is false, the /// corresponding component of x is returned. For a /// component of a that is true, the corresponding /// component of y is returned. Components of x and y that /// are not selected are allowed to be invalid floating point /// values and will have no effect on the results. Thus, this /// provides different functionality than /// genType mix(genType x, genType y, genType(a)) /// where a is a Boolean vector. /// /// @see GLSL mix man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions /// /// @param[in] x Value to interpolate. /// @param[in] y Value to interpolate. /// @param[in] a Interpolant. /// /// @tparam genTypeT Floating point scalar or vector. /// @tparam genTypeU Floating point or boolean scalar or vector. It can't be a vector if it is the length of genTypeT. /// /// @code /// #include /// ... /// float a; /// bool b; /// glm::dvec3 e; /// glm::dvec3 f; /// glm::vec4 g; /// glm::vec4 h; /// ... /// glm::vec4 r = glm::mix(g, h, a); // Interpolate with a floating-point scalar two vectors. /// glm::vec4 s = glm::mix(g, h, b); // Teturns g or h; /// glm::dvec3 t = glm::mix(e, f, a); // Types of the third parameter is not required to match with the first and the second. /// glm::vec4 u = glm::mix(g, h, r); // Interpolations can be perform per component with a vector for the last parameter. /// @endcode template class vecType> GLM_FUNC_DECL vecType mix(vecType const & x, vecType const & y, vecType const & a); template class vecType> GLM_FUNC_DECL vecType mix(vecType const & x, vecType const & y, U a); template GLM_FUNC_DECL genTypeT mix(genTypeT x, genTypeT y, genTypeU a); /// Returns 0.0 if x < edge, otherwise it returns 1.0 for each component of a genType. /// /// @see GLSL step man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType step(genType edge, genType x); /// Returns 0.0 if x < edge, otherwise it returns 1.0. /// /// @see GLSL step man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template