Repository: alex-petrenko/megaverse
Branch: master
Commit: c38436d69b7a
Files: 205
Total size: 859.1 KB
Directory structure:
gitextract_gmyfvy_d/
├── .dockerignore
├── .gitignore
├── .gitmodules
├── LICENSE
├── MANIFEST.in
├── Makefile
├── README.md
├── data/
│ ├── benchmarking.txt
│ └── old_readme.md
├── docker/
│ ├── Dockerfile.base
│ └── README.md
├── docker-compose.yml
├── environment.yml
├── megaverse/
│ ├── .gitignore
│ ├── __init__.py
│ ├── examples/
│ │ ├── __init__.py
│ │ └── random_policy.py
│ ├── megaverse_env.py
│ └── tests/
│ ├── __init__.py
│ └── test_env.py
├── megaverse_rl/
│ ├── __init__.py
│ ├── enjoy_megaverse.py
│ ├── megaverse_params.py
│ ├── megaverse_utils.py
│ ├── runs/
│ │ ├── __init__.py
│ │ ├── megaverse_base_experiments.py
│ │ ├── multi_agent.py
│ │ ├── multitask.py
│ │ ├── multitask_obstacles.py
│ │ ├── performance_benchmark.py
│ │ ├── performance_benchmark_all_envs.py
│ │ ├── single_agent.py
│ │ └── training_benchmark.py
│ ├── sampling_benchmark.py
│ ├── slurm/
│ │ ├── sbatch_template.sh
│ │ └── slurm_cli.txt
│ ├── tests/
│ │ ├── __init__.py
│ │ └── test_megaverse_env.py
│ └── train_megaverse.py
├── setup.cfg
├── setup.py
└── src/
├── 3rdparty/
│ ├── CMakeLists.txt
│ └── glad/
│ ├── CMakeLists.txt
│ ├── include/
│ │ ├── KHR/
│ │ │ └── khrplatform.h
│ │ └── glad/
│ │ └── glad_egl.h
│ └── src/
│ └── glad_egl.c
├── CMakeLists.txt
├── apps/
│ ├── CMakeLists.txt
│ ├── mazegen.cpp
│ ├── megaverse_test_app.cpp
│ ├── viewer_app.cpp
│ ├── viewer_args.cpp
│ └── viewer_args.hpp
├── cmake/
│ ├── modules/
│ │ ├── FindCorrade.cmake
│ │ ├── FindEGL.cmake
│ │ ├── FindMagnum.cmake
│ │ ├── FindMagnumIntegration.cmake
│ │ └── FindSDL2.cmake
│ └── util.cmake
├── examples/
│ ├── CMakeLists.txt
│ ├── arcball/
│ │ ├── ArcBall.cpp
│ │ ├── ArcBall.h
│ │ ├── ArcBallCamera.h
│ │ ├── ArcBallExample.cpp
│ │ └── CMakeLists.txt
│ ├── bullet_example/
│ │ ├── CMakeLists.txt
│ │ └── bullet_example.cpp
│ ├── picking_objects/
│ │ ├── CMakeLists.txt
│ │ └── picking_example.cpp
│ ├── textured_triangle/
│ │ ├── CMakeLists.txt
│ │ ├── resources.conf
│ │ ├── stone.tga
│ │ ├── textured_triangle.cpp
│ │ ├── textured_triangle_shader.cpp
│ │ ├── textured_triangle_shader.frag
│ │ ├── textured_triangle_shader.hpp
│ │ └── textured_triangle_shader.vert
│ └── triangle.cpp
├── libs/
│ ├── CMakeLists.txt
│ ├── bindings/
│ │ ├── CMakeLists.txt
│ │ └── megaverse.cpp
│ ├── env/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── env/
│ │ │ ├── agent.hpp
│ │ │ ├── const.hpp
│ │ │ ├── env.hpp
│ │ │ ├── env_renderer.hpp
│ │ │ ├── kinematic_character_controller.hpp
│ │ │ ├── physics.hpp
│ │ │ ├── scenario.hpp
│ │ │ ├── scenario_component.hpp
│ │ │ ├── vector_env.hpp
│ │ │ └── voxel_state.hpp
│ │ └── src/
│ │ ├── agent.cpp
│ │ ├── env.cpp
│ │ ├── kinematic_character_controller.cpp
│ │ └── vector_env.cpp
│ ├── magnum_rendering/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── magnum_rendering/
│ │ │ ├── magnum_env_renderer.hpp
│ │ │ └── rendering_context.hpp
│ │ └── src/
│ │ ├── magnum_env_renderer.cpp
│ │ └── rendering_context.cpp
│ ├── mazes/
│ │ ├── CMakeLists.txt
│ │ ├── LICENSE.txt
│ │ ├── Readme.md
│ │ ├── examples/
│ │ │ ├── gen.sh
│ │ │ └── manual_input.xy
│ │ ├── include/
│ │ │ └── mazes/
│ │ │ ├── breadthfirstsearch.h
│ │ │ ├── cellborder.h
│ │ │ ├── circularhexagonmaze.h
│ │ │ ├── circularmaze.h
│ │ │ ├── depthfirstsearch.h
│ │ │ ├── hexagonalmaze.h
│ │ │ ├── honeycombmaze.h
│ │ │ ├── kruskal.h
│ │ │ ├── looperasedrandomwalk.h
│ │ │ ├── maze.h
│ │ │ ├── prim.h
│ │ │ ├── rectangularmaze.h
│ │ │ ├── spanningtreealgorithm.h
│ │ │ └── usermaze.h
│ │ └── src/
│ │ ├── breadthfirstsearch.cpp
│ │ ├── cellborder.cpp
│ │ ├── circularhexagonmaze.cpp
│ │ ├── circularmaze.cpp
│ │ ├── depthfirstsearch.cpp
│ │ ├── hexagonalmaze.cpp
│ │ ├── honeycombmaze.cpp
│ │ ├── kruskal.cpp
│ │ ├── looperasedrandomwalk.cpp
│ │ ├── maze.cpp
│ │ ├── prim.cpp
│ │ ├── rectangularmaze.cpp
│ │ ├── spanningtreealgorithm.cpp
│ │ └── usermaze.cpp
│ ├── rendering/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── rendering/
│ │ │ └── render_utils.hpp
│ │ └── src/
│ │ └── render_utils.cpp
│ ├── scenarios/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── scenarios/
│ │ │ ├── component_fall_detection.hpp
│ │ │ ├── component_hexagonal_maze.hpp
│ │ │ ├── component_object_stacking.hpp
│ │ │ ├── component_platforms.hpp
│ │ │ ├── component_voxel_grid.hpp
│ │ │ ├── const.hpp
│ │ │ ├── init.hpp
│ │ │ ├── layout_utils.hpp
│ │ │ ├── platforms.hpp
│ │ │ ├── scenario_box_a_gone.hpp
│ │ │ ├── scenario_collect.hpp
│ │ │ ├── scenario_default.hpp
│ │ │ ├── scenario_empty.hpp
│ │ │ ├── scenario_football.hpp
│ │ │ ├── scenario_hex_explore.hpp
│ │ │ ├── scenario_hex_memory.hpp
│ │ │ ├── scenario_obstacles.hpp
│ │ │ ├── scenario_rearrange.hpp
│ │ │ ├── scenario_sokoban.hpp
│ │ │ └── scenario_tower_building.hpp
│ │ └── src/
│ │ ├── component_hexagonal_maze.cpp
│ │ ├── layout_utils.cpp
│ │ ├── scenario_box_a_gone.cpp
│ │ ├── scenario_collect.cpp
│ │ ├── scenario_empty.cpp
│ │ ├── scenario_football.cpp
│ │ ├── scenario_hex_explore.cpp
│ │ ├── scenario_hex_memory.cpp
│ │ ├── scenario_obstacles.cpp
│ │ ├── scenario_rearrange.cpp
│ │ ├── scenario_sokoban.cpp
│ │ └── scenario_tower_building.cpp
│ ├── util/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── util/
│ │ │ ├── argparse.hpp
│ │ │ ├── enum.hpp
│ │ │ ├── filesystem_utils.hpp
│ │ │ ├── macro.hpp
│ │ │ ├── magnum.hpp
│ │ │ ├── math_utils.hpp
│ │ │ ├── os_utils.hpp
│ │ │ ├── perlin_noise.hpp
│ │ │ ├── string_utils.hpp
│ │ │ ├── tiny_logger.hpp
│ │ │ ├── tiny_profiler.hpp
│ │ │ ├── util.hpp
│ │ │ └── voxel_grid.hpp
│ │ └── src/
│ │ ├── filesystem_utils.cpp
│ │ ├── string_utils.cpp
│ │ ├── tiny_logger.cpp
│ │ ├── tiny_profiler.cpp
│ │ └── util.cpp
│ ├── v4r_rendering/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── v4r_rendering/
│ │ │ └── v4r_env_renderer.hpp
│ │ └── src/
│ │ └── v4r_env_renderer.cpp
│ └── viewer/
│ ├── CMakeLists.txt
│ ├── include/
│ │ └── viewer/
│ │ └── viewer.hpp
│ └── src/
│ └── viewer.cpp
└── test/
├── CMakeLists.txt
└── src/
├── env_tests.cpp
├── filesystem_tests.cpp
├── gfx_tests.cpp
├── logger_tests.cpp
├── maze_tests.cpp
├── noise_test.cpp
├── string_tests.cpp
├── util_tests.cpp
└── voxel_grid_tests.cpp
================================================
FILE CONTENTS
================================================
================================================
FILE: .dockerignore
================================================
# Files for docker
docker-compose.yml
# Byte-compiled / optimized / DLL files
__pycache__/
*.pyc
*.pyo
*.pyd
*.local
# Distribution / packaging
.Python
env/
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
*.egg-info/
.installed.cfg
*.egg
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec
# Installer logs
pip-log.txt
pip-delete-this-directory.txt
# Unit test / coverage reports
htmlcov/
.tox/
.coverage
.coverage.*
.cache/
.hypothesis/
coverage.xml
# IPython Notebook
.ipynb_checkpoints
# pyenv
.python-version
# virtualenv
venv/
ENV/
.env/
# pytest
.pytest_cache/
# IDE
.idea/
# mypy
.mypy_cache/
# VCS
.git/
.gitignore
.gitattributes
================================================
FILE: .gitignore
================================================
# Prerequisites
*.d
# Compiled Object files
*.slo
*.lo
*.o
*.obj
# Precompiled Headers
*.gch
*.pch
# Compiled Dynamic libraries
*.so
*.dylib
*.dll
# Fortran module files
*.mod
*.smod
# Compiled Static libraries
*.lai
*.la
*.a
*.lib
# Executables
*.exe
*.out
*.app
# IDE
.idea/**
src/.idea/**
# CMake build
cmake-build*
build*
# Byte-compiled Python
__pycache__/
# Python build stuff
*.egg-info/**
# RL-training related
train_dir/
# Python intermediate folders
megaverse/extension/**
================================================
FILE: .gitmodules
================================================
[submodule "src/3rdparty/googletest-1.10.0"]
path = src/3rdparty/googletest-1.10.0
url = https://github.com/google/googletest.git
[submodule "src/3rdparty/pybind11"]
path = src/3rdparty/pybind11
url = https://github.com/pybind/pybind11.git
[submodule "src/3rdparty/magnum"]
path = src/3rdparty/magnum
url = https://github.com/mosra/magnum.git
[submodule "src/3rdparty/corrade"]
path = src/3rdparty/corrade
url = https://github.com/mosra/corrade.git
[submodule "src/3rdparty/v4r"]
path = src/3rdparty/v4r
url = https://github.com/alex-petrenko/v4r.git
[submodule "src/3rdparty/magnum-integration"]
path = src/3rdparty/magnum-integration
url = https://github.com/mosra/magnum-integration.git
================================================
FILE: LICENSE
================================================
MIT License
Copyright (c) 2020 Aleksei Petrenko
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.
================================================
FILE: MANIFEST.in
================================================
global-include *
global-exclude *git*
recursive-exclude **/benchmark* *
recursive-exclude **/json/test *
recursive-exclude **/.git *
prune dist
================================================
FILE: Makefile
================================================
PYTHON ?= python
export BASE_TAG=$(shell ${PYTHON} -c 'import hashlib; sha = hashlib.sha1((open("docker/Dockerfile.base").read() + open("requirements/requirements.txt").read()).encode()); print(sha.hexdigest())')
BRANCH = $(shell git rev-parse --abbrev-ref HEAD)
VERSION = $(shell git rev-parse --short HEAD)
DATE = $(shell date +%F)
export TAG=$(BRANCH)-$(VERSION)-$(DATE)
.PHONY: pull build up push shell docker-bash
pull-%:
docker-compose pull $(subst pull-,,$@)
build-%:
docker-compose build $(subst build-,,$@)
up-%:
docker-compose up -d $(subst up-,,$@)
push-%:
docker-compose push $(subst push-,,$@)
shell:
@echo TAG=$(TAG) BASE_TAG=$(BASE_TAG)
docker-bash:
docker-compose run --it --rm dev bash
.PHONY: upload upload-test clean
upload:
python3 -m twine upload --repository pypi dist/*
upload-test:
python3 -m twine upload --repository testpypi dist/*
clean:
rm -rf build dist
================================================
FILE: README.md
================================================
# Megaverse
[
](https://discord.gg/4ZNdhfaZtK)
Megaverse is a dedicated high-throughput rendering and simulation engine for Artificial Intelligence research.
It features an optimized batched renderer that enables generation of up to 1,000,000 observations per second on a single machine.
* **Website:** [www.megaverse.info](https://www.megaverse.info)
* **arXiv:** [arxiv.org/abs/2107.08170](https://arxiv.org/abs/2107.08170)
Left: RL agent completing a TowerBuilding task. Right: human player solving a randomly generated obstacle course.
## Installation
Currently, the easiest way to install Megaverse is to build directly from sources.
### Linux
```shell
# 0) A completely clean Linux installation needs basic OpenGL libraries. The rest of the dependencies are installed with Conda and don't require elevated privileges.
$ sudo apt install libgl1-mesa-dev libegl1-mesa-dev
# 1) Install VulkanSDK from https://vulkan.lunarg.com/sdk/home#linux (download and unzip), or use the following commands:
$ wget https://sdk.lunarg.com/sdk/download/1.2.198.1/linux/vulkansdk-linux-x86_64-1.2.198.1.tar.gz
$ mkdir vulkansdk && tar -xzf vulkansdk-linux-x86_64-1.2.198.1.tar.gz --directory vulkansdk
# 2) Add Vulkan SDK binaries to PATH (might need to do it each time recompiling Megaverse is required):
$ cd vulkansdk/1.2.198.1
$ source ./setup-env.sh
# 3) Clone the repo
$ git clone https://github.com/alex-petrenko/megaverse.git
# 4) Init submodules
$ cd megaverse
$ git submodule update --init --recursive
# 5) Create a conda environment and install dependencies
$ conda create --name megaverse python=3.9
$ conda activate megaverse
(megaverse) $ conda install -c conda-forge 'opencv>=4.4,<4.5' 'cmake>=3.13' bullet cudatoolkit cudatoolkit-dev sdl2
# (alternatively you can boostrap from an environment file: conda env create -f environment.yml)
# 6) Install megaverse into a conda env
(megaverse) $ python setup.py develop
(megaverse) $ pip install -e .
# (Optional) 6.1) Build a .whl file to be installed elsewhere
(megaverse) $ python setup.py bdist_wheel
```
### macOS
Although Vulkan-powered batched rendering is not supported on macOS, a limited OpenGL version can be built for
local debugging and small-scale experiments on macOS.
Installing on mac is very similar to Linux, sans any Vulkan/CUDA dependencies.
```shell
# 1) Clone the repo
$ git clone https://github.com/alex-petrenko/megaverse.git
# 2) Init submodules
$ cd megaverse
$ git submodule update --init --recursive
# 3) Create a conda environment and install dependencies
$ conda create --name megaverse python=3.9
$ conda activate megaverse
(megaverse) $ conda install -c conda-forge 'opencv>=4.4,<4.5' 'cmake>=3.13' bullet
# 4) Install megaverse into a conda env
(megaverse) $ python setup.py develop
(megaverse) $ pip install -e .
# (Optional) 4.1) Build a .whl file to be installed elsewhere
(megaverse) $ python setup.py bdist_wheel
```
### Docker
Since installation does not require elevated priviliges, Docker setup is not required.
However, Docker-based installation is also available, see here:
[docker/README.md](https://github.com/alex-petrenko/megaverse/blob/master/docker/README.md).
## Examples
### Python API
The following script executes a random policy:
```Python
import numpy as np
from megaverse.megaverse_env import MegaverseEnv
env = MegaverseEnv(
'TowerBuilding',
num_envs=2, num_agents_per_env=2,
num_simulation_threads=4, use_vulkan=True,
params={},
)
env.reset()
while True:
actions = [env.action_space.sample() for _ in range(env.num_agents)]
obs, rewards, dones, infos = env.step(actions)
if np.any(dones):
break
env.render()
```
## RL Training
Example training script using Sample Factory RL framework. First install the prerequisite:
```
pip install "sample-factory>=2.0"
```
(this instruction was tested on version from branch `sf2`, commit f4b5e971f467fc8dcabc0adee8b1c04885412fbb,
`pip install git+https://github.com/alex-petrenko/sample-factory.git@f4b5e971f467fc8dcabc0adee8b1c04885412fbb`)
Then, to train agents in the TowerBuilding environment, execute:
```
python -m megaverse_rl.train_megaverse --train_for_seconds=360000000 --train_for_env_steps=2000000000 --algo=APPO --gamma=0.997 --use_rnn=True --rnn_num_layers=2 --num_workers=8 --num_envs_per_worker=2 --num_epochs=1 --rollout=32 --recurrence=32 --batch_size=4096 --actor_worker_gpus 0 --num_policies=1 --with_pbt=False --max_grad_norm=0.0 --exploration_loss=symmetric_kl --exploration_loss_coeff=0.001 --megaverse_num_simulation_threads=1 --megaverse_num_envs_per_instance=48 --megaverse_num_agents_per_env=1 --megaverse_use_vulkan=True --policy_workers_per_policy=2 --reward_clip=30 --env=TowerBuilding --experiment=TowerBuilding
```
Observe the behavior of agents by running:
```
python -m megaverse_rl.enjoy --algo=APPO --env=TowerBuilding --experiment=TowerBuilding --megaverse_num_envs_per_instance=1 --fps=20 --megaverse_use_vulkan=True
```
See Sample Factory 2 documentation for additional information.
## Development
### Setting up a CMake project in IDE
The core functionality of Megaverse is implemented in C++ and uses CMake build system.
The easiest way to work on Megaverse C++ codebase is to use an IDE that can import a CMake project (defined by the root CMakeLists.txt in megaverse/src).
Any such IDE would need to run `cmake` in order to build and debug the code.
Thus `cmake` needs to be able to find all the libraries installed through conda (such as Bullet and OpenCV).
The most straightforward way to make sure that libraries can be found is to start IDE directly from the conda environment we defined above (see section Installation/Linux).
Specifically, for CLion IDE it would look like this:
```shell
$ conda activate megaverse
# navigate to Vulkan SDK installation dir
(megaverse) $ cd vulkansdk-linux-x86_64-1.2.198.1/1.2.198.1/
# make sure that Vulkan env variables are initialized
(megaverse) $ source ./setup-env.sh
# start the IDE from the terminal (assuming clion is in PATH, usually you can do this with Tools->Create Command-Line Launcher)
(megaverse) $ clion &
```
Now in the IDE open megaverse/src/CMakeLists.txt as CMake project and you should be able to build and run targets.
#### Running an IDE without Conda enviroment
Alternatively, if IDE is not run from a conda environment we might need to explicitly specify paths to libraries in IDE's CMake command line
(i.e. in CLion that would be `Settings -> Build,Execution,Deployment -> CMake -> CMake options`).
Your CMake options might looks like this:
```
-DPYTHON_EXECUTABLE=/home//miniconda3/envs/megaverse/bin/python
-DCMAKE_CUDA_COMPILER=/home//miniconda3/envs/megaverse/bin/nvcc
-DOpenCV_DIR=/home//miniconda3/envs/megaverse/lib/cmake/opencv4
-DBUILD_GUI_APPS=ON
```
Additionally, an environment variable `VULKAN_SDK=/home//all/libs/vulkansdk-linux-x86_64-1.2.198.1/1.2.198.1/x86_64` must be set.
In most IDEs this can be set in the same CMake configuration dialogue.
Finally, CMake should be able to find Bullet physics library. There are three ways to accomplish this:
1. Install `libbullet-dev` and CMake will find the system-wide installation
2. To link against `bullet` installed by Conda you need to make sure your IDE also uses Conda's `cmake`,
rather than `cmake` bundled with the IDE. In CLion you can change this in `Settings -> Build,Execution,Deployment -> Toolchains -> CMake`.
This way `cmake` should be able to find Conda's Bullet CMake config `/lib/cmake/bullet/BulletConfig.cmake`
3. Alternatively, you can build Bullet from sources and add a CMake option `-DBULLET_ROOT` pointing to the correct location.
### Notable build targets
CMakeLists.txt defines many targets. The following targets are the most useful:
* `megaverse` builds the overall project and the Python bindings (see setup.py)
* `run_unit_tests` runs Google Tests (see `megaverse/src/test`)
* `viewer_app` builds an interactive application that allows you to control agents with keyboard and explore environments with an overview camera.
This one is really designed to interact with a single environment at a time, and is very useful during development and debugging phase. See details below.
* `megaverse_test_app` can use the parallel simulation engine and batch renderer to execute many environment at once. See details below.
### Using viewer_app
`viewer_app` can run any scenario in an interactive mode and offers a bunch of command line parameters:
```
Usage: viewer_app [options]
Optional arguments:
-h --help shows help message and exits [default: false]
-v --version prints version information and exits [default: false]
-l --list_scenarios list registered scenario names [default: false]
--scenario name of the scenario to run [default: "ObstaclesEasy"]
--num_agents size of the team, pass value 1 to have just a single agent [default: 2]
--desired_fps rendering framerate for human perception; RL agents percieve the world at 15 FPS to avoid frameskip, hence the default value. [default: 15]
--use_opengl Whether to use OpenGL renderer instead of fast Vulkan renderer (currently Vulkan is only supported in Linux) [default: false]
```
Once the app started, use keyboard to control the agent and the camera:
* `WASD` and arrow keys to control the agent
* `1,2,3,4,etc.` to switch between agents (if several are present in the environment)
* Press `O` to toggle the overview camera, use mouse to control view angle
* Use `UHJK` keys to control the position of the camera in the overview mode
* Press `R` to reset the episode
* Press `ENTER` to toggle Bullet collision debug view (only OpenGL version)
* `ESC` to exit the app
### Using megaverse_test_app
`megaverse_test_app` uses parallel interface and is a much easier target to debug compared to Python Gym API.
```
usage: megaverse_test_app [options]
This app is designed to test the parallel execution engine and batched renderer
by simulating multiple environments at once. This app uses pretty much the same interface
as the Python Gym environment, sans the Python bindings. Whenever there is a problem
with the environment, it is much easier to debug this app directly, rather
than debugging the same code through Python.
Example, render 12 agents at the same time:
megaverse_test_app --scenario Collect --visualize --num_envs 4 --num_simulation_threads 1 --num_agents 3 --hires
Some performance figures for future reference (on 10-core Intel i9):
megaverse_test_app --scenario Empty --performance_test --num_envs 64 --num_simulation_threads 1 --num_agents 1
yields approximately 75000 FPS
megaverse_test_app --scenario Collect --performance_test --num_envs 64 --num_simulation_threads 1 --num_agents 1
yields approximately 27000 FPS
Optional arguments:
-h --help shows help message and exits [default: false]
-v --version prints version information and exits [default: false]
-l --list_scenarios list registered scenario names [default: false]
--scenario name of the scenario to run [default: "ObstaclesEasy"]
--num_agents size of the team [default: 2]
--use_opengl Whether to use OpenGL renderer instead of fast Vulkan renderer (currently Vulkan is only supported in Linux) [default: false]
--num_envs number of parallel environments to simulate [default: 64]
--num_simulation_threads number of parallel CPU threads to use for Bullet [default: 1]
--visualize Whether to render multiple environments on screen [default: false]
--visualize Whether to render multiple environments on screen [default: false]
--delay_ms Delay between rendered frames in milliseconds. Use only with --visualize [default: 1]
--performance_test Run for a limited number of env frames (currently 200000) to test performance. Uses random actions. [default: false]
--hires Render at high resolution. Only use this parameter with --visualize and if the total number of agents is small [default: false]
--user_actions Allows the user to control agents (otherwise will use randomly generated actions). Use only with --visualize [default: false]
```
## Troubleshooting
* A crash (segfault) on startup can be caused by the incorrect initialization of Vulkan device interface. Possible fixes:
* `sudo apt remove mesa-vulkan-drivers` (unless other packages you require depend on this package)
* Set envvar `export VK_ICD_FILENAMES=/usr/share/vulkan/icd.d/nvidia_icd.json`, point to the location of `nvidia_icd.json` in your system.
## Citation
If you use this repository in your work or otherwise wish to cite it, please make reference to our ICML2021 paper.
```
@inproceedings{petrenko2021megaverse,
title={Megaverse: Simulating Embodied Agents at One Million Experiences per Second},
author={Petrenko, Aleksei and Wijmans, Erik and Shacklett, Brennan and Koltun, Vladlen},
booktitle={ICML},
year={2021}
}
```
For questions, issues, inquiries please email apetrenko1991@gmail.com.
Github issues and pull requests are welcome.
================================================
FILE: data/benchmarking.txt
================================================
July 29th, 2020
parallel -N0 './test_performance' ::: {1..20}
30x30 grid of cubes instanced, 128x72
11800 polygons
1 core: 7596 FPS
2 cores: 5815 * 2 = 11630 FPS
4 cores: 3852 * 4 = 15408 FPS
8 cores: 1950 * 8 = 15600 FPS
10 cores: 1546 * 10 = 15460 FPS
20 cores: 764 * 20 = 15280 FPS
10x10 grid of cubes instanced, 128x72
1200 polygons
1 core: 36000 FPS
2 cores: 9253 * 2 = 18506 FPS
3 cores: 6211 * 3 = 18633 FPS
4 cores: 4619 * 4 = 18476 FPS
10 cores: 1796 * 10 = 17960 FPS
parallel -N0 './test_performance --magnum-device 2 --magnum-log verbose' ::: {1..10}
30x30 grid of cubes instanced, 128x72
11800 polygons
software rendering
1 core: 440 FPS
2 cores: 481 * 2 = 962 FPS
4 cores: 468 * 4 = 1872 FPS
8 cores: 429 * 8 = 3432 FPS
10 cores: 411 * 10 = 4110 FPS
20 cores: 286 * 20 = 5720 FPS
10x10 grid of cubes instanced, 128x72
1200 polygons
software rendering
1 core: 2464 FPS
2 cores: 2047 * 2 = 4094 FPS
4 cores: 2087 * 4 = 8348 FPS
10 cores: 1706 * 10 = 17060 FPS
20 cores: 1248 * 20 = 24960 FPS
================================================
FILE: data/old_readme.md
================================================
Previous Readme
```
1) Clone the repo
git clone https://github.com/alex-petrenko/megaverse.git
2) Init submodules
git submodule update --init --recursive
3) Clone and build OpenCV (also possible to use OpenCV installed from Conda)
cd ~/lib
git clone https://github.com/opencv/opencv.git
cd opencv
mkdir build
cmake -D CMAKE_BUILD_TYPE=Release ..
make -j10
4) Install CUDA 10.2
https://developer.nvidia.com/cuda-10.2-download-archive
5) Install Vulkan
wget -qO - https://packages.lunarg.com/lunarg-signing-key-pub.asc | sudo apt-key add -
sudo wget -qO /etc/apt/sources.list.d/lunarg-vulkan-1.2.154-bionic.list https://packages.lunarg.com/vulkan/1.2.154/lunarg-vulkan-1.2.154-bionic.list
sudo apt update
sudo apt install vulkan-sdk
(or install manually from https://vulkan.lunarg.com/sdk/home#linux, then source ./setup-env.sh to set envvars)
6) Setup Python environment (TODO: add environment.yml to this repo, currently using one from Sample Factory)
(REQUIRES: opencv, cudatoolkit
conda install -c conda-forge opencv
conda install -c anaconda cudatoolkit
conda install -c conda-forge cudatoolkit-dev
)
git clone https://github.com/alex-petrenko/sample-factory.git
cd sample-factory
conda env create -f environment.yml
conda activate sample-factory
7) Install PyBullet
conda install -c conda-forge bullet
(preferred)
OR
sudo apt install libbullet-dev
8) Update CMake if necessary (version 3.13 or newer is required)
conda install -c anaconda cmake
(preferred)
OR
sudo apt remove --purge cmake
hash -r
sudo snap install cmake --classic
9) Build the repo
cd megaverse
mkdir build
cd build
# Run CMake, specify the OpenCV build dir and Python3 executable (e.g. from a conda environment)
cmake -DCMAKE_BUILD_TYPE=Release \
-DCMAKE_CUDA_COMPILER=/usr/local/cuda/bin/nvcc \
-DPYTHON_EXECUTABLE:FILEPATH=/home//miniconda3/envs//bin/python3.7 \
../src
(optionally, add -DBULLET_ROOT=/home//lib/bullet3-2.89/install if you built it from sources)
(optionally, add -DOpenCV_DIR=/home//lib/opencv/build if you built it from sources)
# Build all targets
make -j10
10) Run benchmark
cd Release/bin
./megaverse_test_app
(see global boolean flags in megaverse_test_app.cpp, they control the scenario and rendering settings
TODO: make configurable)
11) Run viewer
cd Release/bin
./viewer_app
use WASD and arrows to control agent
digits (1,2) to switch between agents in multi-agent envs
E to interact with objects
O to switch to overview camera
UHJK to control overview camera
(see global vars at the top of viewer_app.cpp file to control which environment is chosen
TODO: make configurable)
12) To build the Python package and install it in the active Python env:
python setup.py develop
pip install -e .
13) Run tests
python -m unittest
14) You are ready to use the Megaverse Python API!
```
Training:
```
Single experiment example:
python -m megaverse_rl.train_megaverse --train_for_seconds=360000000 --train_for_env_steps=2000000000 --algo=APPO --gamma=0.997 --use_rnn=True --rnn_num_layers=2 --num_workers=12 --num_envs_per_worker=2 --num_epochs=1 --rollout=32 --recurrence=32 --batch_size=2048 --actor_worker_gpus 0 --num_policies=1 --with_pbt=False --max_grad_norm=0.0 --exploration_loss=symmetric_kl --exploration_loss_coeff=0.001 --voxel_num_simulation_threads=1 --voxel_use_vulkan=True --policy_workers_per_policy=2 --reward_clip=30 --env=voxel_env_TowerBuilding --experiment=test_cli
Example runner script:
python -m sample_factory.runner.run --run=megaverse_rl.runs.megaverse_single_agent --runner=processes --max_parallel=8 --pause_between=10 --experiments_per_gpu=2 --num_gpus=4
```
Docker setup:
```
Install docker-compose:
pip install docker-compose
```
================================================
FILE: docker/Dockerfile.base
================================================
FROM nvidia/cudagl:10.2-devel-ubuntu18.04
# FROM nvidia/cudagl:11.0-devel-ubuntu20.04
# FROM nvidia/cuda:10.2-cudnn7-devel-ubuntu18.04
# Set up locale to prevent bugs with encoding
ENV LC_ALL=C.UTF-8 LANG=C.UTF-8
RUN apt-get update || true && apt-get install -y \
libcudnn8 \
libglvnd0 libgl1 libglx0 libegl1 \
libglvnd-dev libgl1-mesa-dev libegl1-mesa-dev \
wget curl git zlib1g-dev \
libglib2.0-0 libsm6 libxext6 libxrender-dev \
python3 python3-pip cmake \
&& apt-get clean \
&& rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
WORKDIR /vulkan
RUN wget https://sdk.lunarg.com/sdk/download/1.2.162.0/linux/vulkansdk-linux-x86_64-1.2.162.0.tar.gz && tar -xzf vulkansdk-linux-x86_64-1.2.162.0.tar.gz
ENV VULKAN_SDK=/vulkan/1.2.162.0/x86_64
ENV PATH=${VULKAN_SDK}/bin:${PATH}
ENV LD_LIBRARY_PATH=${VULKAN_SDK}/lib:${LD_LIBRARY_PATH:-}
ENV VK_LAYER_PATH=${VULKAN_SDK}/etc/vulkan/explicit_layer.d
RUN vulkaninfo
WORKDIR /
RUN cd /usr/bin \
&& ln -s python3 python \
&& ln -s pip3 pip
RUN curl -LO http://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh && \
bash Miniconda3-latest-Linux-x86_64.sh -p /miniconda -b && \
rm Miniconda3-latest-Linux-x86_64.sh
ENV PATH=/miniconda/bin:${PATH}
RUN conda update -y conda && conda --version
WORKDIR /workspace
RUN git clone https://github.com/alex-petrenko/sample-factory.git
RUN git clone https://github.com/alex-petrenko/megaverse.git
WORKDIR sample-factory
RUN conda env create -f environment.yml
RUN conda init bash
SHELL ["conda", "run", "-n", "sample-factory", "/bin/bash", "-c"]
RUN conda install -n sample-factory -c anaconda cudatoolkit cmake
RUN conda install -n sample-factory -c conda-forge opencv bullet cudatoolkit-dev
RUN pip install -e .
WORKDIR /workspace/megaverse
RUN git submodule update --init --recursive
RUN pip install -e .
================================================
FILE: docker/README.md
================================================
### Docker instructions
```
1) Clone the repo
$ git clone https://github.com/alex-petrenko/megaverse.git
2) Build the image
cd megaverse
docker build -t megaverse -f docker/Dockerfile.base .
3) Start megaverse
docker run --shm-size 8G --runtime=nvidia megaverse ./docker/run.sh
(Optional) 4) Launch bash in the container and enjoy
docker run -it --shm-size 8G --runtime=nvidia --entrypoint /bin/bash megaverse
```
================================================
FILE: docker-compose.yml
================================================
version: "3.3"
services:
# base
base:
image: "${REPO}-base:${BASE_TAG}"
build:
context: .
dockerfile: docker/Dockerfile.base
# dev
dev:
image: "${REPO}-dev:${BASE_TAG}"
depends_on:
- base
build:
context: .
dockerfile: docker/Dockerfile.dev
args:
REPO: ${REPO}
BASE_TAG: ${BASE_TAG}
volumes:
- ".:/workspace"
================================================
FILE: environment.yml
================================================
name: megaverse
channels:
- pytorch
- anaconda
- conda-forge
- defaults
dependencies:
- _libgcc_mutex=0.1=main
- blas=1.0=mkl
- bullet=2.89=py38hc5bc63f_1
- bzip2=1.0.8=h516909a_2
- ca-certificates=2020.10.14=0
- cairo=1.16.0=hcf35c78_1003
- certifi=2020.6.20=py38_0
- cmake=3.18.2=ha30ef3c_0
- cudatoolkit=10.2.89=hfd86e86_1
- cudatoolkit-dev=11.0.3=py38h497a2fe_2
- dbus=1.13.6=he372182_0
- expat=2.2.9=he1b5a44_2
- ffmpeg=4.3.1=h167e202_0
- fontconfig=2.13.1=h86ecdb6_1001
- freetype=2.10.2=h5ab3b9f_0
- gettext=0.19.8.1=hc5be6a0_1002
- glib=2.65.0=h6f030ca_0
- gmp=6.2.0=he1b5a44_2
- gnutls=3.6.13=h79a8f9a_0
- graphite2=1.3.13=he1b5a44_1001
- gst-plugins-base=1.14.5=h0935bb2_2
- gstreamer=1.14.5=h36ae1b5_2
- harfbuzz=2.4.0=h9f30f68_3
- hdf5=1.10.6=nompi_h3c11f04_101
- icu=64.2=he1b5a44_1
- intel-openmp=2020.1=217
- jasper=1.900.1=h07fcdf6_1006
- jpeg=9d=h516909a_0
- krb5=1.18.2=h173b8e3_0
- lame=3.100=h14c3975_1001
- lcms2=2.11=h396b838_0
- ld_impl_linux-64=2.34=hc38a660_9
- libblas=3.8.0=16_mkl
- libcblas=3.8.0=16_mkl
- libclang=9.0.1=default_hde54327_0
- libcurl=7.71.1=h20c2e04_1
- libedit=3.1.20191231=h14c3975_1
- libffi=3.2.1=he1b5a44_1007
- libgcc-ng=9.1.0=hdf63c60_0
- libgfortran-ng=7.5.0=hdf63c60_14
- libiconv=1.15=h516909a_1006
- liblapack=3.8.0=16_mkl
- liblapacke=3.8.0=16_mkl
- libllvm9=9.0.1=he513fc3_1
- libopencv=4.4.0=py38_2
- libpng=1.6.37=hbc83047_0
- libssh2=1.9.0=h1ba5d50_1
- libstdcxx-ng=9.1.0=hdf63c60_0
- libtiff=4.1.0=h2733197_1
- libuuid=2.32.1=h14c3975_1000
- libuv=1.40.0=h7b6447c_0
- libwebp-base=1.1.0=h516909a_3
- libxcb=1.13=h14c3975_1002
- libxkbcommon=0.10.0=he1b5a44_0
- libxml2=2.9.10=hee79883_0
- lz4-c=1.9.2=he6710b0_1
- mkl=2020.1=217
- mkl-service=2.3.0=py38he904b0f_0
- mkl_fft=1.1.0=py38h23d657b_0
- mkl_random=1.1.1=py38h0573a6f_0
- ncurses=6.2=he6710b0_1
- nettle=3.4.1=h1bed415_1002
- ninja=1.10.0=py38hfd86e86_0
- nspr=4.27=he1b5a44_1
- nss=3.55=he751ad9_0
- numpy=1.19.1=py38hbc911f0_0
- numpy-base=1.19.1=py38hfa32c7d_0
- olefile=0.46=py_0
- opencv=4.4.0=py38_2
- openh264=2.1.1=h8b12597_0
- openssl=1.1.1h=h7b6447c_0
- pcre=8.44=he1b5a44_0
- pillow=7.2.0=py38hb39fc2d_0
- pip=20.2.1=py38_0
- pixman=0.38.0=h516909a_1003
- pthread-stubs=0.4=h14c3975_1001
- py-opencv=4.4.0=py38h23f93f0_2
- python=3.8.5=h4d41432_2_cpython
- python_abi=3.8=1_cp38
- pytorch=1.6.0=py3.8_cuda10.2.89_cudnn7.6.5_0
- qt=5.12.5=hd8c4c69_1
- readline=8.0=h7b6447c_0
- rhash=1.4.0=h1ba5d50_0
- setuptools=49.2.0=py38_0
- six=1.15.0=py_0
- sqlite=3.32.3=h62c20be_0
- tk=8.6.10=hbc83047_0
- torchvision=0.7.0=py38_cu102
- wheel=0.34.2=py38_0
- x264=1!152.20180806=h14c3975_0
- xorg-kbproto=1.0.7=h14c3975_1002
- xorg-libice=1.0.10=h516909a_0
- xorg-libsm=1.2.3=h84519dc_1000
- xorg-libx11=1.6.11=h516909a_0
- xorg-libxau=1.0.9=h14c3975_0
- xorg-libxdmcp=1.1.3=h516909a_0
- xorg-libxext=1.3.4=h516909a_0
- xorg-libxrender=0.9.10=h516909a_1002
- xorg-renderproto=0.11.1=h14c3975_1002
- xorg-xextproto=7.3.0=h14c3975_1002
- xorg-xproto=7.0.31=h14c3975_1007
- xz=5.2.5=h7b6447c_0
- zlib=1.2.11=h7b6447c_3
- zstd=1.4.5=h9ceee32_0
- pip:
- absl-py==0.9.0
- atari-py==0.2.6
- cloudpickle==1.3.0
- colorlog==4.2.1
- cython==0.29.23
- faster-fifo==1.2.0
- filelock==3.0.12
- future==0.18.2
- grpcio==1.31.0
- gym==0.17.2
- markdown==3.2.2
- opencv-python==4.5.2.54
- protobuf==3.12.4
- psutil==5.7.2
- pyglet==1.5.0
- scipy==1.5.2
- tensorboard==1.15.0
- tensorboardx==2.0
- threadpoolctl==2.1.0
- werkzeug==1.0.1
prefix: /home/boyuan/miniconda3/envs/megaverse
================================================
FILE: megaverse/.gitignore
================================================
.idea/**
__pycache__
================================================
FILE: megaverse/__init__.py
================================================
================================================
FILE: megaverse/examples/__init__.py
================================================
================================================
FILE: megaverse/examples/random_policy.py
================================================
import numpy as np
from megaverse.megaverse_env import MegaverseEnv
env = MegaverseEnv(
'ObstaclesHard',
num_envs=2, num_agents_per_env=2,
num_simulation_threads=4, use_vulkan=True,
params={},
)
env.reset()
while True:
actions = [env.action_space.sample() for _ in range(env.num_agents)]
obs, rewards, dones, infos = env.step(actions)
if np.any(dones):
break
env.render()
env.close()
================================================
FILE: megaverse/megaverse_env.py
================================================
import cv2
import gym
import numpy as np
from gym.spaces import Discrete
# noinspection PyUnresolvedReferences
from megaverse.extension.megaverse import MegaverseGym, set_megaverse_log_level
MEGAVERSE8 = [
'TowerBuilding',
'ObstaclesEasy',
'ObstaclesHard',
'Collect',
'Sokoban',
'HexMemory',
'HexExplore',
'Rearrange',
]
OBSTACLES_MULTITASK = [
'ObstaclesWalls', 'ObstaclesSteps', 'ObstaclesLava', 'ObstaclesEasy', 'ObstaclesHard',
]
def make_env_multitask(multitask_name, task_idx, num_envs, num_agents_per_env, num_simulation_threads, use_vulkan=False, params=None):
assert 'multitask' in multitask_name
if multitask_name.endswith('megaverse8'):
tasks = MEGAVERSE8
elif multitask_name.endswith('obstacles'):
tasks = OBSTACLES_MULTITASK
else:
raise NotImplementedError()
scenario_idx = task_idx % len(tasks)
scenario = tasks[scenario_idx]
print('Multi-task, scenario', scenario_idx, scenario)
return MegaverseEnv(scenario, num_envs, num_agents_per_env, num_simulation_threads, use_vulkan, params)
class MegaverseEnv(gym.Env):
def __init__(self, scenario_name, num_envs, num_agents_per_env, num_simulation_threads, use_vulkan=False, params=None):
scenario_name = scenario_name.casefold()
self.scenario_name = scenario_name
self.is_multiagent = True
set_megaverse_log_level(2)
self.img_w = 128
self.img_h = 72
self.channels = 3
self.use_vulkan = use_vulkan
# total number of simulated agents
self.num_agents = num_envs * num_agents_per_env
self.num_envs = num_envs
self.num_agents_per_env = num_agents_per_env
float_params = {}
if params is not None:
for k, v in params.items():
if isinstance(v, float):
float_params[k] = v
else:
raise Exception('Params of type %r not supported', type(v))
# float_params['episodeLengthSec'] = 1.0
self.env = MegaverseGym(
self.scenario_name,
self.img_w, self.img_h, num_envs, num_agents_per_env, num_simulation_threads, use_vulkan, float_params,
)
# obtaining default reward shaping scheme
self.default_shaping_scheme = self.env.get_reward_shaping(0, 0)
self.action_space = self.generate_action_space(self.env.action_space_sizes())
self.observation_space = gym.spaces.Box(0, 255, (self.channels, self.img_h, self.img_w), dtype=np.uint8)
@staticmethod
def generate_action_space(action_space_sizes):
"""
Left = 1 << 1,
Right = 1 << 2,
Forward = 1 << 3,
Backward = 1 << 4,
LookLeft = 1 << 5,
LookRight = 1 << 6,
Jump = 1 << 7,
Interact = 1 << 8,
LookDown = 1 << 9,
LookUp = 1 << 10,
"""
# spaces = [
# Discrete(3), # noop, go left, go right
# Discrete(3), # noop, forward, backward
# Discrete(3), # noop, look left, look right
# Discrete(2), # noop, jump
# Discrete(2), # noop, interact
# Discrete(3), # noop, look down, look up
# ]
spaces = [Discrete(sz) for sz in action_space_sizes]
space = gym.spaces.Tuple(spaces)
return space
def seed(self, seed=None):
if seed is None:
return
assert isinstance(seed, int), 'Expect seed to be an integer'
self.env.seed(seed)
def observations(self):
obs = []
for env_i in range(self.num_envs):
for agent_i in range(self.num_agents_per_env):
o = self.env.get_observation(env_i, agent_i)
o = o[:, :, :3]
o = np.transpose(o, (2, 0, 1)) # convert to CHW for PyTorch
obs.append(o)
return obs
def reset(self):
self.env.reset()
return self.observations()
def step(self, actions):
action_idx = 0
for env_i in range(self.num_envs):
for agent_i in range(self.num_agents_per_env):
self.env.set_actions(env_i, agent_i, actions[action_idx])
action_idx += 1
self.env.step()
dones, infos = [], []
agent_i = 0
for env_i in range(self.num_envs):
done = self.env.is_done(env_i) # currently no individual done per agent
dones.extend([done for _ in range(self.num_agents_per_env)])
if done:
infos.extend([dict(true_reward=float(self.env.true_objective(env_i, j))) for j in range(self.num_agents_per_env)])
else:
infos.extend([{} for _ in range(self.num_agents_per_env)])
agent_i += self.num_agents_per_env
rewards = self.env.get_last_rewards()
obs = self.observations()
return obs, rewards, dones, infos
def convert_obs(self, obs):
if not self.use_vulkan:
obs = cv2.flip(obs, 0)
obs = cv2.cvtColor(obs, cv2.COLOR_RGB2BGR)
return obs
def render(self, mode='human'):
self.env.draw_overview()
self.env.draw_hires()
rows = []
for env_i in range(self.num_envs):
obs = [self.convert_obs(self.env.get_hires_observation(env_i, i)) for i in range(self.num_agents_per_env)]
obs_concat = np.concatenate(obs, axis=1)
rows.append(obs_concat)
obs_final = np.concatenate(rows, axis=0)
cv2.imshow(f'agent_{id(self)}', obs_final)
cv2.waitKey(1)
return obs_final
def get_default_reward_shaping(self):
return self.default_shaping_scheme
def get_current_reward_shaping(self, actor_idx: int):
env_idx = actor_idx // self.num_agents_per_env
agent_idx = actor_idx % self.num_agents_per_env
return self.env.get_reward_shaping(env_idx, agent_idx)
def set_reward_shaping(self, reward_shaping: dict, actor_idx: int):
env_idx = actor_idx // self.num_agents_per_env
agent_idx = actor_idx % self.num_agents_per_env
return self.env.set_reward_shaping(env_idx, agent_idx, reward_shaping)
def close(self):
if self.env:
self.env.close()
================================================
FILE: megaverse/tests/__init__.py
================================================
================================================
FILE: megaverse/tests/test_env.py
================================================
import copy
import os
import time
import numpy as np
from unittest import TestCase
from megaverse.megaverse_env import MegaverseEnv, make_env_multitask
def sample_actions(e):
return [e.action_space.sample() for _ in range(e.num_agents)]
def make_test_env(num_envs, num_agents_per_env, num_simulation_threads, use_vulkan=False, params=None):
"""Making env with a default scenario name."""
return MegaverseEnv('ObstaclesEasy', num_envs, num_agents_per_env, num_simulation_threads, use_vulkan, params)
class TestEnv(TestCase):
def test_env(self):
e = make_test_env(num_envs=1, num_agents_per_env=1, num_simulation_threads=1)
o = e.reset()
o = e.step(sample_actions(e))
e.close()
def test_env_close_immediately(self):
e = make_test_env(1, 1, 1)
e.close()
def test_two_envs_same_process(self):
e1 = make_test_env(1, 1, 1)
e2 = make_test_env(1, 1, 1)
e1.reset()
e2.reset()
e1.close()
e2.close()
def test_seeds(self):
e1 = make_test_env(1, 1, 1)
e1.seed(42)
e2 = make_test_env(1, 1, 1)
e2.seed(42)
obs1 = e1.reset()
obs2 = e2.reset()
self.assertTrue(np.array_equal(obs1, obs2))
e2.close()
e1.close()
# after this we have randomness due to physics?
def rendering(self, use_vulkan, episode_length_sec=60.0):
params = {'episodeLengthSec': episode_length_sec}
e1 = make_test_env(num_envs=2, num_agents_per_env=2, num_simulation_threads=2, use_vulkan=use_vulkan, params=params)
e2 = make_test_env(num_envs=1, num_agents_per_env=1, num_simulation_threads=1, use_vulkan=use_vulkan, params=params)
e1.reset()
e2.reset()
e1.render()
e2.render()
for i in range(100):
e1.step(sample_actions(e1))
e1.render()
e2.step(sample_actions(e2))
e2.render()
e2.close()
e1.close()
def test_render(self):
self.rendering(use_vulkan=False)
def test_render_vulkan(self):
self.rendering(use_vulkan=True)
def test_render_reset(self):
self.rendering(use_vulkan=False, episode_length_sec=1.0)
def test_render_vulkan_reset(self):
self.rendering(use_vulkan=True, episode_length_sec=1.0)
@staticmethod
def performance_num_envs(n, n_steps=5000):
print(f'Performance {n} {n_steps}')
envs = [make_test_env(1, 1, 1, use_vulkan=True) for _ in range(n)]
for e in envs:
e.seed(42)
e.reset()
total_reward = 0.0
actions = sample_actions(envs[0])
start = time.time()
for step in range(n_steps):
for i, e in enumerate(envs):
obs, rew, dones, infos = e.step(actions)
total_reward += sum(rew)
if all(dones):
print(f'Episode boundary env {i}')
end = time.time()
elapsed = end - start
fps = envs[0].num_agents * n * n_steps / elapsed
print(f'Time {elapsed:.3f}, fps: {fps:.1f}, total reward: {total_reward:.3f}')
for e in envs:
e.close()
return fps
def test_performance(self):
fps1 = self.performance_num_envs(1)
fps2 = self.performance_num_envs(2)
fps4 = self.performance_num_envs(4)
# print(fps1, fps2, fps4)
def test_reward_shaping(self):
e = MegaverseEnv('TowerBuilding', num_envs=3, num_agents_per_env=2, num_simulation_threads=2, use_vulkan=True)
default_reward_shaping = e.get_default_reward_shaping()
self.assertEqual(default_reward_shaping, e.get_current_reward_shaping(0))
self.assertEqual(default_reward_shaping, e.get_current_reward_shaping(1))
self.assertEqual(default_reward_shaping, e.get_current_reward_shaping(2))
self.assertEqual(default_reward_shaping, e.get_current_reward_shaping(5))
new_reward_shaping = copy.deepcopy(default_reward_shaping)
for k, v in new_reward_shaping.items():
new_reward_shaping[k] = v * 3
e.set_reward_shaping(new_reward_shaping, 3)
self.assertEqual(default_reward_shaping, e.get_current_reward_shaping(0))
self.assertEqual(default_reward_shaping, e.get_current_reward_shaping(1))
self.assertNotEqual(default_reward_shaping, e.get_current_reward_shaping(3))
e.close()
def test_memleak(self):
def mem_usage_kb():
import psutil
process = psutil.Process(os.getpid())
return process.memory_info().rss / 1024
# params = {'episodeLengthSec': 0.1}
params = {}
e = MegaverseEnv('Rearrange', num_envs=32, num_agents_per_env=1, num_simulation_threads=1, use_vulkan=True, params=params)
e.reset()
orig_mem_usage = mem_usage_kb()
for i in range(1000):
print('Mem difference: ', mem_usage_kb() - orig_mem_usage, 'kb')
e.step(sample_actions(e))
print('Final mem difference: ', mem_usage_kb() - orig_mem_usage, 'kb')
e.close()
def test_multitask(self):
import multiprocessing as mp
num_processes = 2
def run_single_task(i):
e = make_env_multitask('megaverse8', i, 1, 1, 1, use_vulkan=True, params={})
e.reset()
e.render() # TODO: if this call is omitted we have rendering bugs. Fixme!
for _ in range(1000):
e.step(sample_actions(e))
e.render()
e.close()
processes = []
for process_idx in range(num_processes):
p = mp.Process(target=run_single_task, args=(process_idx, ))
p.start()
processes.append(p)
for p in processes:
p.join()
def test_viewer(self):
params = {'episodeLengthSec': 1.0}
e1 = MegaverseEnv('ObstaclesHard', 2, 2, 2, True, params)
e1.reset()
e1.render()
for i in range(500):
e1.step(sample_actions(e1))
e1.render()
time.sleep(0.01)
e1.close()
================================================
FILE: megaverse_rl/__init__.py
================================================
================================================
FILE: megaverse_rl/enjoy_megaverse.py
================================================
import sys
from sample_factory.enjoy import enjoy
from megaverse_rl.train_megaverse import parse_megaverse_args, register_megaverse_components
def main():
"""Script entry point."""
register_megaverse_components()
cfg = parse_megaverse_args(evaluation=True)
status = enjoy(cfg)
return status
if __name__ == "__main__":
sys.exit(main())
================================================
FILE: megaverse_rl/megaverse_params.py
================================================
from sample_factory.utils.utils import str2bool
def megaverse_override_defaults(env, parser):
"""RL params specific to Megaverse envs."""
parser.set_defaults(
encoder_type="conv",
encoder_subtype="convnet_simple",
hidden_size=512,
obs_subtract_mean=0.0,
obs_scale=255.0,
actor_worker_gpus=[0], # rollout workers need GPUs to render (provide a list of GPUs to use)
env_gpu_actions=False, # but OpenAI Gym interface is entirely CPU-based
env_gpu_observations=False, # (which can actually be optimized for even higher throughput)
exploration_loss="symmetric_kl",
exploration_loss_coeff=0.001,
normalize_input=True,
normalize_returns=True,
with_vtrace=False,
)
def add_megaverse_args(env, parser):
p = parser
p.add_argument(
"--megaverse_num_envs_per_instance", default=1, type=int, help="Num simulated envs per instance of Megaverse"
)
p.add_argument(
"--megaverse_num_agents_per_env",
default=4,
type=int,
help="Number of agents in a single env withing a Megaverse instance. Total number of agents in one Megaverse = num_envs_per_instance * num_agents_per_env",
)
p.add_argument(
"--megaverse_num_simulation_threads",
default=1,
type=int,
help="Number of CPU threads to use per instance of Megaverse",
)
p.add_argument("--megaverse_use_vulkan", default=True, type=str2bool, help="Whether to use Vulkan renderer")
# Team Spirit options
p.add_argument(
"--megaverse_increase_team_spirit",
default=False,
type=str2bool,
help="Increase team spirit from 0 to 1 over max_team_spirit_steps during training. At 1, the reward will be completely selfless.",
)
p.add_argument(
"--megaverse_max_team_spirit_steps",
default=1e9,
type=float,
help="Number of training steps when team spirit will hit 1.",
)
================================================
FILE: megaverse_rl/megaverse_utils.py
================================================
from typing import Optional
import gym
from megaverse.megaverse_env import MegaverseEnv, make_env_multitask
from sample_factory.envs.env_utils import RewardShapingInterface, TrainingInfoInterface
from sample_factory.utils.utils import log
class MegaverseSpec:
def __init__(self, name):
self.name = name
MEGAVERSE_ENVS = [
MegaverseSpec("TowerBuilding"),
MegaverseSpec("ObstaclesEasy"),
MegaverseSpec("ObstaclesHard"),
MegaverseSpec("Collect"),
MegaverseSpec("Sokoban"),
MegaverseSpec("HexMemory"),
MegaverseSpec("HexExplore"),
MegaverseSpec("Rearrange"),
MegaverseSpec("multitask_Obstacles"),
MegaverseSpec("multitask_megaverse8"),
]
class Wrapper(gym.Wrapper, RewardShapingInterface, TrainingInfoInterface):
"""Sets interface for PBT reward shaping, and also extra summaries for multi-task learning."""
def __init__(self, env, increase_team_spirit, max_team_spirit_steps):
gym.Wrapper.__init__(self, env)
RewardShapingInterface.__init__(self)
TrainingInfoInterface.__init__(self)
self.num_agents = env.unwrapped.num_agents
self.is_multiagent = env.unwrapped.is_multiagent
self.episode_rewards = [0] * self.num_agents
self.increase_team_spirit = increase_team_spirit
self.max_team_spirit_steps = max_team_spirit_steps
self.approx_total_training_steps = 0
def get_default_reward_shaping(self):
return self.env.unwrapped.get_default_reward_shaping()
def get_current_reward_shaping(self, agent_idx: int):
return self.env.unwrapped.get_current_reward_shaping(agent_idx)
def set_reward_shaping(self, reward_shaping: dict, agent_idx: int):
return self.env.unwrapped.set_reward_shaping(reward_shaping, agent_idx)
def reset(self, **kwargs):
self.episode_rewards = [0] * self.num_agents
return self.env.reset(), {}
def step(self, action):
obs, rewards, dones, infos = self.env.step(action)
for i, info in enumerate(infos):
self.episode_rewards[i] += rewards[i]
if dones[i]:
if "episode_extra_stats" not in info:
info["episode_extra_stats"] = dict()
extra_stats = info["episode_extra_stats"]
info["true_objective"] = info["true_reward"]
extra_stats[f"z_{self.env.unwrapped.scenario_name.casefold()}_true_objective"] = info["true_reward"]
extra_stats[f"z_{self.env.unwrapped.scenario_name.casefold()}_reward"] = self.episode_rewards[i]
approx_total_training_steps = self.training_info.get("approx_total_training_steps", 0)
extra_stats["z_approx_total_training_steps"] = approx_total_training_steps
self.episode_rewards[i] = 0
if self.increase_team_spirit:
rew_shaping = self.get_current_reward_shaping(i)
rew_shaping["teamSpirit"] = min(approx_total_training_steps / self.max_team_spirit_steps, 1.0)
self.set_reward_shaping(rew_shaping, i)
extra_stats["teamSpirit"] = rew_shaping["teamSpirit"]
terminated = dones
truncated = [False] * len(dones)
return obs, rewards, terminated, truncated, infos
def make_megaverse(env_name, cfg=None, env_config=None, render_mode: Optional[str] = None, **kwargs):
scenario_name = env_name.casefold()
log.debug("Using scenario %s", scenario_name)
if "multitask" in scenario_name:
if env_config is not None and "worker_index" in env_config:
task_idx = env_config["worker_index"]
else:
log.warning(
"Could not find information about task id. Use task_id=0. (It is okay if this message appears once)"
)
task_idx = 0
env = make_env_multitask(
scenario_name,
task_idx,
num_envs=cfg.megaverse_num_envs_per_instance,
num_agents_per_env=cfg.megaverse_num_agents_per_env,
num_simulation_threads=cfg.megaverse_num_simulation_threads,
use_vulkan=cfg.megaverse_use_vulkan,
)
else:
env = MegaverseEnv(
scenario_name=scenario_name,
num_envs=cfg.megaverse_num_envs_per_instance,
num_agents_per_env=cfg.megaverse_num_agents_per_env,
num_simulation_threads=cfg.megaverse_num_simulation_threads,
use_vulkan=cfg.megaverse_use_vulkan,
)
env = Wrapper(env, cfg.megaverse_increase_team_spirit, cfg.megaverse_max_team_spirit_steps)
return env
================================================
FILE: megaverse_rl/runs/__init__.py
================================================
================================================
FILE: megaverse_rl/runs/megaverse_base_experiments.py
================================================
from sample_factory.launcher.run_description import Experiment, ParamGrid
_params = ParamGrid([
('env', ['TowerBuilding', 'ObstaclesEasy', 'ObstaclesHard', 'Collect', 'Sokoban', 'HexMemory', 'HexExplore', 'Rearrange']),
('seed', [11111, 22222, 33333, 44444, 55555]),
])
_cli = 'python -m megaverse_rl.train_megaverse --train_for_seconds=360000000 --train_for_env_steps=2000000000 --algo=APPO --gamma=0.997 --use_rnn=True --rnn_num_layers=2 --num_workers=1 --num_envs_per_worker=2 --num_epochs=1 --rollout=32 --recurrence=32 --batch_size=2048 --actor_worker_gpus 0 --num_policies=1 --with_pbt=False --max_grad_norm=0.0 --exploration_loss=symmetric_kl --exploration_loss_coeff=0.001 --megaverse_num_simulation_threads=1 --megaverse_use_vulkan=True --policy_workers_per_policy=2 --reward_clip=30'
EXPERIMENT_1AGENT = Experiment(
'megaverse_1ag',
_cli + ' --megaverse_num_envs_per_instance=36 --megaverse_num_agents_per_env=1',
_params.generate_params(randomize=False),
)
EXPERIMENT_2AGENTS = Experiment(
'megaverse_2ag',
_cli + ' --megaverse_num_envs_per_instance=18 --megaverse_num_agents_per_env=2',
_params.generate_params(randomize=False),
)
EXPERIMENT_4AGENTS = Experiment(
'megaverse_4ag',
_cli + ' --megaverse_num_envs_per_instance=9 --megaverse_num_agents_per_env=4',
_params.generate_params(randomize=False),
)
================================================
FILE: megaverse_rl/runs/multi_agent.py
================================================
from sample_factory.launcher.run_description import RunDescription
from megaverse_rl.runs.megaverse_base_experiments import EXPERIMENT_4AGENTS, EXPERIMENT_2AGENTS
RUN_DESCRIPTION = RunDescription('megaverse_v115_multi_agent_v55', experiments=[EXPERIMENT_2AGENTS, EXPERIMENT_4AGENTS])
================================================
FILE: megaverse_rl/runs/multitask.py
================================================
from sample_factory.launcher.run_description import RunDescription, Experiment, ParamGrid
_params = ParamGrid([
('env', ['multitask_megaverse8']),
('seed', [11111, 22222, 33333, 44444, 55555]),
])
_cli = 'python -m megaverse_rl.train_megaverse --train_for_seconds=360000000 --train_for_env_steps=2000000000 --algo=APPO --gamma=0.997 --use_rnn=True --rnn_num_layers=2 --num_workers=12 --num_envs_per_worker=2 --num_epochs=1 --rollout=32 --recurrence=32 --batch_size=2048 --actor_worker_gpus 0 --num_policies=1 --with_pbt=False --max_grad_norm=0.0 --exploration_loss=symmetric_kl --exploration_loss_coeff=0.001 --megaverse_num_simulation_threads=1 --megaverse_use_vulkan=True --policy_workers_per_policy=2 --reward_clip=30 --pbt_mix_policies_in_one_env=False'
EXPERIMENT_1AGENT = Experiment(
'megaverse_multitask_obs',
_cli + ' --megaverse_num_envs_per_instance=36 --megaverse_num_agents_per_env=1',
_params.generate_params(randomize=False),
)
RUN_DESCRIPTION = RunDescription('megaverse_v115_multitask8_v55', experiments=[EXPERIMENT_1AGENT])
================================================
FILE: megaverse_rl/runs/multitask_obstacles.py
================================================
from sample_factory.launcher.run_description import RunDescription, Experiment, ParamGrid
_params = ParamGrid([
('env', ['multitask_Obstacles']),
('seed', [11111, 22222, 33333, 44444, 55555]),
])
_cli = 'python -m megaverse_rl.train_megaverse --train_for_seconds=360000000 --train_for_env_steps=10000000000 --algo=APPO --gamma=0.997 --use_rnn=True --rnn_num_layers=2 --num_workers=12 --num_envs_per_worker=2 --num_epochs=1 --rollout=32 --recurrence=32 --batch_size=2048 --actor_worker_gpus 0 --num_policies=1 --with_pbt=False --max_grad_norm=0.0 --exploration_loss=symmetric_kl --exploration_loss_coeff=0.001 --megaverse_num_simulation_threads=1 --megaverse_use_vulkan=True --policy_workers_per_policy=2 --learner_main_loop_num_cores=2 --reward_clip=30 --pbt_mix_policies_in_one_env=False'
EXPERIMENT_1AGENT = Experiment(
'megaverse_multitask_obs',
_cli + ' --megaverse_num_envs_per_instance=36 --megaverse_num_agents_per_env=1',
_params.generate_params(randomize=False),
)
RUN_DESCRIPTION = RunDescription('megaverse_v115_multitask_obstacles_v55', experiments=[EXPERIMENT_1AGENT])
================================================
FILE: megaverse_rl/runs/performance_benchmark.py
================================================
from sample_factory.launcher.run_description import RunDescription, Experiment, ParamGrid
NUM_WORKERS = 20 # typically num logical cores
NUM_WORKERS_MEGAVERSE = 10 # typically num logical cores / 2, limited by the num of available Vulkan contexts
TIMEOUT_SECONDS = 180
SAMPLER_GPUS = '0' # replace with '0 1 2 3 4 5 6 7' for 8-GPU server
_basic_cli = f'python -m sample_factory.run_algorithm --algo=DUMMY_SAMPLER --num_workers={NUM_WORKERS} --num_envs_per_worker=1 --experiment=benchmark --timeout_seconds={TIMEOUT_SECONDS}'
_params_basic_envs = ParamGrid([
('env', ['doom_benchmark', 'atari_breakout', 'dmlab_benchmark']),
])
_experiment_basic_envs = Experiment(
'benchmark_basic_envs',
_basic_cli,
_params_basic_envs.generate_params(randomize=False),
)
_megaverse_cli = f'python -m sample_factory.run_algorithm --algo=DUMMY_SAMPLER --num_workers={NUM_WORKERS_MEGAVERSE} --num_envs_per_worker=1 --experiment=benchmark --sampler_worker_gpus {SAMPLER_GPUS} --megaverse_num_envs_per_instance=64 --megaverse_num_agents_per_env=2 --megaverse_num_simulation_threads=2 --timeout_seconds={TIMEOUT_SECONDS}'
_params_megaverse = ParamGrid([
('env', ['obstacleshard']),
('megaverse_use_vulkan', [True, False]),
])
_experiment_megaverse = Experiment(
'benchmark_megaverse',
_megaverse_cli,
_params_megaverse.generate_params(randomize=False),
)
RUN_DESCRIPTION = RunDescription('megaverse_bench_sampling', experiments=[_experiment_basic_envs, _experiment_megaverse])
================================================
FILE: megaverse_rl/runs/performance_benchmark_all_envs.py
================================================
from sample_factory.launcher.run_description import RunDescription, Experiment, ParamGrid
NUM_WORKERS_MEGAVERSE = 48 # typically num logical cores / 2, limited by the num of available Vulkan contexts
TIMEOUT_SECONDS = 180
SAMPLER_GPUS = '0 1 2 3 4 5 6 7' # replace with '0 1 2 3 4 5 6 7' for 8-GPU server
_megaverse_cli = f'python -m sample_factory.run_algorithm --algo=DUMMY_SAMPLER --num_workers={NUM_WORKERS_MEGAVERSE} --num_envs_per_worker=1 --experiment=benchmark --sampler_worker_gpus {SAMPLER_GPUS} --megaverse_num_envs_per_instance=64 --megaverse_num_agents_per_env=2 --megaverse_num_simulation_threads=2 --timeout_seconds={TIMEOUT_SECONDS}'
_params_megaverse = ParamGrid([
('env', ['TowerBuilding', 'ObstaclesEasy', 'ObstaclesHard', 'Collect', 'Sokoban', 'HexMemory', 'HexExplore', 'Rearrange']),
('megaverse_use_vulkan', [True]),
])
_experiment_megaverse = Experiment(
'benchmark_megaverse_8',
_megaverse_cli,
_params_megaverse.generate_params(randomize=False),
)
RUN_DESCRIPTION = RunDescription('megaverse_bench_sampling_all_envs', experiments=[_experiment_megaverse])
================================================
FILE: megaverse_rl/runs/single_agent.py
================================================
from sample_factory.launcher.run_description import RunDescription
from megaverse_rl.runs.megaverse_base_experiments import EXPERIMENT_1AGENT
RUN_DESCRIPTION = RunDescription('megaverse_arxiv', experiments=[EXPERIMENT_1AGENT])
================================================
FILE: megaverse_rl/runs/training_benchmark.py
================================================
from sample_factory.launcher.run_description import RunDescription, Experiment, ParamGrid
NUM_WORKERS = 20 # typically num logical cores
NUM_WORKERS_MEGAVERSE = 10 # typically num logical cores / 2, limited by the num of available Vulkan contexts
TIMEOUT_SECONDS = 180
ACTOR_GPUS = '0' # replace with '0 1 2 3 4 5 6 7' for 8-GPU server
NUM_POLICIES = 1
_basic_cli = f'python -m megaverse_rl.train_megaverse --train_for_seconds={TIMEOUT_SECONDS} --train_for_env_steps=20000000000 --algo=APPO --gamma=0.997 --use_rnn=True --rnn_num_layers=2 --num_workers={NUM_WORKERS} --num_envs_per_worker=16 --num_epochs=1 --rollout=32 --recurrence=32 --batch_size=2048 --num_policies={NUM_POLICIES} --with_pbt=False --max_grad_norm=0.0 --exploration_loss=symmetric_kl --exploration_loss_coeff=0.001 --policy_workers_per_policy=2 --learner_main_loop_num_cores=4 --reward_clip=30'
_params_basic_envs = ParamGrid([
('env', ['doom_benchmark', 'atari_breakout', 'dmlab_benchmark']),
])
_experiment_basic_envs = Experiment(
'benchmark_basic_envs',
_basic_cli,
_params_basic_envs.generate_params(randomize=False),
)
_megaverse_cli = f'python -m megaverse_rl.train_megaverse --train_for_seconds={TIMEOUT_SECONDS} --train_for_env_steps=20000000000 --algo=APPO --gamma=0.997 --use_rnn=True --rnn_num_layers=2 --num_workers={NUM_WORKERS_MEGAVERSE} --num_envs_per_worker=2 --num_epochs=1 --rollout=32 --recurrence=32 --batch_size=2048 --actor_worker_gpus {ACTOR_GPUS} --num_policies={NUM_POLICIES} --with_pbt=False --max_grad_norm=0.0 --exploration_loss=symmetric_kl --exploration_loss_coeff=0.001 --megaverse_num_simulation_threads=2 --megaverse_use_vulkan=True --policy_workers_per_policy=2 --learner_main_loop_num_cores=4 --reward_clip=30 --megaverse_num_envs_per_instance=36 --megaverse_num_agents_per_env=1 --pbt_mix_policies_in_one_env=False'
_params_megaverse = ParamGrid([
('env', ['megaverse_obstacleshard']),
('megaverse_use_vulkan', [True, False]),
])
_experiment_megaverse = Experiment(
'benchmark_megaverse',
_megaverse_cli,
_params_megaverse.generate_params(randomize=False),
)
RUN_DESCRIPTION = RunDescription('megaverse_train_benchmark', experiments=[_experiment_basic_envs, _experiment_megaverse])
================================================
FILE: megaverse_rl/sampling_benchmark.py
================================================
"""
Measure pure sampling throughput.
"""
import sys
from sample_factory.algorithms.utils.arguments import arg_parser, postprocess_args
from sample_factory.run_algorithm import run_algorithm
from sample_factory.utils.get_available_gpus import get_gpus_without_triggering_pytorch_cuda_initialization
from sample_factory.utils.utils import log
from megaverse_rl.megaverse_utils import register_env
def main():
"""Script entry point."""
gpus = get_gpus_without_triggering_pytorch_cuda_initialization()
gpus = gpus.strip().split(',')
gpus = [int(g) for g in gpus]
if len(gpus) <= 0:
log.error('Sampling benchmark requires at least one GPU')
else:
log.debug('Have %d GPUs (%r)', len(gpus), gpus)
register_env()
argv = sys.argv[1:]
argv.append('--algo=DUMMY_SAMPLER')
parser = arg_parser(argv)
parser.set_defaults(
sampler_worker_gpus=gpus,
num_workers=len(gpus) * 10,
megaverse_num_envs_per_instance=32,
megaverse_num_agents_per_env=4,
megaverse_num_simulation_threads=2,
)
# parse all the arguments (algo, env, and optionally evaluation)
cfg = parser.parse_args(argv)
cfg = postprocess_args(cfg, argv, parser)
status = run_algorithm(cfg)
return status
if __name__ == '__main__':
sys.exit(main())
================================================
FILE: megaverse_rl/slurm/sbatch_template.sh
================================================
#!/bin/bash
source /homes/petrenko/miniconda3/etc/profile.d/conda.sh
conda activate megaverse
cd ~/megaverse
================================================
FILE: megaverse_rl/slurm/slurm_cli.txt
================================================
python -m sample_factory.launcher.run --run=megaverse_rl.runs.single_agent --runner=slurm --slurm_workdir=./megaverse_single_agent --experiment_suffix=slurm --pause_between=1 --slurm_gpus_per_job=1 --slurm_cpus_per_gpu=12 --slurm_sbatch_template=./megaverse_rl/slurm/sbatch_template.sh --slurm_print_only=False
================================================
FILE: megaverse_rl/tests/__init__.py
================================================
================================================
FILE: megaverse_rl/tests/test_megaverse_env.py
================================================
from unittest import TestCase
from sample_factory.envs.create_env import create_env
from sample_factory.utils.utils import log
from megaverse_rl.train_megaverse import register_megaverse_components, parse_megaverse_args
class TestMegaverse(TestCase):
def test_megaverse(self):
register_megaverse_components()
cfg = parse_megaverse_args(['--algo=APPO', '--env=Sokoban', '--experiment=test_megaverse'])
env = create_env(cfg.env, cfg=cfg)
log.info('Env action space: %r', env.action_space)
log.info('Env obs space: %r', env.observation_space)
env.reset()
total_rew = 0
for i in range(1000):
obs, rew, terminated, truncated, info = env.step([env.action_space.sample() for _ in range(env.num_agents)])
total_rew += sum(rew)
log.info('Total rew: %.3f', total_rew)
================================================
FILE: megaverse_rl/train_megaverse.py
================================================
"""
Main script for training agents with SampleFactory.
"""
import sys
from sample_factory.cfg.arguments import parse_full_cfg, parse_sf_args
from sample_factory.envs.env_utils import register_env
from sample_factory.train import run_rl
from megaverse_rl.megaverse_params import add_megaverse_args, megaverse_override_defaults
from megaverse_rl.megaverse_utils import MEGAVERSE_ENVS, make_megaverse
def register_megaverse_envs():
for env in MEGAVERSE_ENVS:
register_env(env.name, make_megaverse)
def register_megaverse_components():
register_megaverse_envs()
def parse_megaverse_args(argv=None, evaluation=False):
parser, partial_cfg = parse_sf_args(argv=argv, evaluation=evaluation)
add_megaverse_args(partial_cfg.env, parser)
megaverse_override_defaults(partial_cfg.env, parser)
final_cfg = parse_full_cfg(parser, argv)
return final_cfg
def main():
"""Script entry point."""
register_megaverse_components()
cfg = parse_megaverse_args()
status = run_rl(cfg)
return status
if __name__ == "__main__":
sys.exit(main())
================================================
FILE: setup.cfg
================================================
[build_ext]
build_temp=build
================================================
FILE: setup.py
================================================
import os
import sys
import multiprocessing
import subprocess
from os.path import join as pjoin
from setuptools import setup, Extension, find_packages
from setuptools.command.build_ext import build_ext
supported_platforms = ["Linux", "Mac OS-X"]
def find_in_path(name, path):
"""Find a file in a search path"""
# Adapted fom http://code.activestate.com/recipes/52224
for dir in path.split(os.pathsep):
binpath = pjoin(dir, name)
if os.path.exists(binpath):
return os.path.abspath(binpath)
return None
def locate_cuda():
"""Locate the CUDA environment on the system
Starts by looking for the CUDAHOME env variable. If not found,
everything is based on finding 'nvcc' in the PATH.
"""
# First check if the CUDAHOME env variable is in use
if 'CUDAHOME' in os.environ:
home = os.environ['CUDAHOME']
nvcc = pjoin(home, 'bin', 'nvcc')
else:
# Otherwise, search the PATH for NVCC
nvcc = find_in_path('nvcc', os.environ['PATH'])
if nvcc is None:
raise EnvironmentError('The nvcc binary could not be '
'located in your $PATH. Either add it to your path, '
'or set $CUDAHOME')
return nvcc
class CMakeExtension(Extension):
def __init__(self, name, sourcedir=''):
Extension.__init__(self, name, sources=[])
self.sourcedir = os.path.abspath(sourcedir)
class CMakeBuild(build_ext):
def run(self):
try:
subprocess.check_output(['cmake', '--version'])
except OSError:
raise RuntimeError(
'CMake must be installed to build the following extensions: ' +
', '.join(e.name for e in self.extensions),
)
for ext in self.extensions:
self.build_extension(ext)
def build_extension(self, ext):
extdir = os.path.abspath(os.path.dirname(self.get_ext_fullpath(ext.name)))
# required for auto-detection of auxiliary "native" libs
if not extdir.endswith(os.path.sep):
extdir += os.path.sep
cmake_args = [
f'-DCMAKE_LIBRARY_OUTPUT_DIRECTORY={extdir}',
f'-DPYTHON_EXECUTABLE={sys.executable}',
# f'-DOpenCV_DIR =/home/alex/all/lib/opencv/build', # TODO!!!
]
if sys.platform != "darwin":
# if not on mac, look for cuda/nvcc
cmake_args.append(f'-DCMAKE_CUDA_COMPILER={locate_cuda()}')
# that's a hacky way to do it but the best idea I have at the moment
bullet_root = os.environ.get('BULLET_ROOT', None)
if bullet_root is not None:
cmake_args.append(f'-DBULLET_ROOT={bullet_root}')
cfg = 'Debug' if self.debug else 'Release'
build_args = ['--config', cfg]
if os.environ.get('MEGAVERSE_WITH_GUI') == '1':
build_gui = 'ON'
else:
build_gui = 'OFF'
cmake_args += [f'-DCMAKE_BUILD_TYPE={cfg}', f'-DBUILD_GUI_APPS={build_gui}']
build_args += ['--', f'-j{multiprocessing.cpu_count()}']
env = os.environ.copy()
if not os.path.exists(self.build_temp):
os.makedirs(self.build_temp)
print('Build temp directory is ', self.build_temp)
cmake_cmd = ['cmake', ext.sourcedir] + cmake_args
print(f'CMake command is: {" ".join(cmake_cmd)}')
subprocess.check_call(cmake_cmd, cwd=self.build_temp, env=env)
subprocess.check_call(
['cmake', '--build', '.', '--target', 'megaverse'] + build_args, cwd=self.build_temp,
)
print('Completed the build!')
def main():
setup(
name='megaverse',
version='0.0.2',
author='Aleksei Petrenko',
author_email='apetrenko1991@gmail.com',
description='Fast immersive environment',
long_description='',
platforms=supported_platforms,
packages=find_packages(exclude=['test', 'benchmarks']),
include_package_data=True,
ext_modules=[CMakeExtension('megaverse.extension.megaverse', 'src')],
cmdclass=dict(build_ext=CMakeBuild),
zip_safe=False,
install_requires=[
'gym>=0.17.1',
],
)
return 0
if __name__ == '__main__':
sys.exit(main())
================================================
FILE: src/3rdparty/CMakeLists.txt
================================================
if (NOT APPLE)
add_subdirectory(v4r EXCLUDE_FROM_ALL)
endif ()
add_subdirectory(corrade EXCLUDE_FROM_ALL)
find_package(Corrade REQUIRED Main)
if (BUILD_GUI_APPS)
set(WITH_SDL2APPLICATION ON CACHE BOOL "" FORCE)
else()
message(STATUS "Build without GUI apps!")
endif()
if (NOT CORRADE_TARGET_APPLE)
set(WITH_WINDOWLESSEGLAPPLICATION ON CACHE BOOL "" FORCE)
else ()
set(WITH_WINDOWLESSCGLAPPLICATION ON CACHE BOOL "WITH_WINDOWLESSCGLAPPLICATION" FORCE)
endif ()
set(WITH_TGAIMPORTER ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)
#find_package(Bullet REQUIRED)
set(WITH_BULLET ON CACHE BOOL "" FORCE)
add_subdirectory(magnum-integration EXCLUDE_FROM_ALL)
find_package(Magnum REQUIRED GL MeshTools Primitives SceneGraph Shaders Trade)
if (BUILD_GUI_APPS)
find_package(Magnum REQUIRED Sdl2Application)
endif()
find_package(MagnumIntegration REQUIRED Bullet)
add_subdirectory(googletest-1.10.0)
include_directories(${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR})
if (NOT CORRADE_TARGET_APPLE)
add_subdirectory(glad)
endif ()
add_subdirectory(pybind11)
================================================
FILE: src/3rdparty/glad/CMakeLists.txt
================================================
add_library_default(glad)
================================================
FILE: src/3rdparty/glad/include/KHR/khrplatform.h
================================================
#ifndef __khrplatform_h_
#define __khrplatform_h_
/*
** Copyright (c) 2008-2018 The Khronos Group Inc.
**
** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the
** "Materials"), to deal in the Materials without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Materials, and to
** permit persons to whom the Materials are 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 Materials.
**
** THE MATERIALS ARE 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
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/
/* Khronos platform-specific types and definitions.
*
* The master copy of khrplatform.h is maintained in the Khronos EGL
* Registry repository at https://github.com/KhronosGroup/EGL-Registry
* The last semantic modification to khrplatform.h was at commit ID:
* 67a3e0864c2d75ea5287b9f3d2eb74a745936692
*
* Adopters may modify this file to suit their platform. Adopters are
* encouraged to submit platform specific modifications to the Khronos
* group so that they can be included in future versions of this file.
* Please submit changes by filing pull requests or issues on
* the EGL Registry repository linked above.
*
*
* See the Implementer's Guidelines for information about where this file
* should be located on your system and for more details of its use:
* http://www.khronos.org/registry/implementers_guide.pdf
*
* This file should be included as
* #include
* by Khronos client API header files that use its types and defines.
*
* The types in khrplatform.h should only be used to define API-specific types.
*
* Types defined in khrplatform.h:
* khronos_int8_t signed 8 bit
* khronos_uint8_t unsigned 8 bit
* khronos_int16_t signed 16 bit
* khronos_uint16_t unsigned 16 bit
* khronos_int32_t signed 32 bit
* khronos_uint32_t unsigned 32 bit
* khronos_int64_t signed 64 bit
* khronos_uint64_t unsigned 64 bit
* khronos_intptr_t signed same number of bits as a pointer
* khronos_uintptr_t unsigned same number of bits as a pointer
* khronos_ssize_t signed size
* khronos_usize_t unsigned size
* khronos_float_t signed 32 bit floating point
* khronos_time_ns_t unsigned 64 bit time in nanoseconds
* khronos_utime_nanoseconds_t unsigned time interval or absolute time in
* nanoseconds
* khronos_stime_nanoseconds_t signed time interval in nanoseconds
* khronos_boolean_enum_t enumerated boolean type. This should
* only be used as a base type when a client API's boolean type is
* an enum. Client APIs which use an integer or other type for
* booleans cannot use this as the base type for their boolean.
*
* Tokens defined in khrplatform.h:
*
* KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
*
* KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
* KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
*
* Calling convention macros defined in this file:
* KHRONOS_APICALL
* KHRONOS_APIENTRY
* KHRONOS_APIATTRIBUTES
*
* These may be used in function prototypes as:
*
* KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
* int arg1,
* int arg2) KHRONOS_APIATTRIBUTES;
*/
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APICALL
*-------------------------------------------------------------------------
* This precedes the return type of the function in the function prototype.
*/
#if defined(_WIN32) && !defined(__SCITECH_SNAP__)
# define KHRONOS_APICALL __declspec(dllimport)
#elif defined (__SYMBIAN32__)
# define KHRONOS_APICALL IMPORT_C
#elif defined(__ANDROID__)
# define KHRONOS_APICALL __attribute__((visibility("default")))
#else
# define KHRONOS_APICALL
#endif
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APIENTRY
*-------------------------------------------------------------------------
* This follows the return type of the function and precedes the function
* name in the function prototype.
*/
#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
/* Win32 but not WinCE */
# define KHRONOS_APIENTRY __stdcall
#else
# define KHRONOS_APIENTRY
#endif
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APIATTRIBUTES
*-------------------------------------------------------------------------
* This follows the closing parenthesis of the function prototype arguments.
*/
#if defined (__ARMCC_2__)
#define KHRONOS_APIATTRIBUTES __softfp
#else
#define KHRONOS_APIATTRIBUTES
#endif
/*-------------------------------------------------------------------------
* basic type definitions
*-----------------------------------------------------------------------*/
#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
/*
* Using
*/
#include
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif defined(__VMS ) || defined(__sgi)
/*
* Using
*/
#include
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
/*
* Win32
*/
typedef __int32 khronos_int32_t;
typedef unsigned __int32 khronos_uint32_t;
typedef __int64 khronos_int64_t;
typedef unsigned __int64 khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif defined(__sun__) || defined(__digital__)
/*
* Sun or Digital
*/
typedef int khronos_int32_t;
typedef unsigned int khronos_uint32_t;
#if defined(__arch64__) || defined(_LP64)
typedef long int khronos_int64_t;
typedef unsigned long int khronos_uint64_t;
#else
typedef long long int khronos_int64_t;
typedef unsigned long long int khronos_uint64_t;
#endif /* __arch64__ */
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif 0
/*
* Hypothetical platform with no float or int64 support
*/
typedef int khronos_int32_t;
typedef unsigned int khronos_uint32_t;
#define KHRONOS_SUPPORT_INT64 0
#define KHRONOS_SUPPORT_FLOAT 0
#else
/*
* Generic fallback
*/
#include
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#endif
/*
* Types that are (so far) the same on all platforms
*/
typedef signed char khronos_int8_t;
typedef unsigned char khronos_uint8_t;
typedef signed short int khronos_int16_t;
typedef unsigned short int khronos_uint16_t;
/*
* Types that differ between LLP64 and LP64 architectures - in LLP64,
* pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
* to be the only LLP64 architecture in current use.
*/
#ifdef _WIN64
typedef signed long long int khronos_intptr_t;
typedef unsigned long long int khronos_uintptr_t;
typedef signed long long int khronos_ssize_t;
typedef unsigned long long int khronos_usize_t;
#else
typedef signed long int khronos_intptr_t;
typedef unsigned long int khronos_uintptr_t;
typedef signed long int khronos_ssize_t;
typedef unsigned long int khronos_usize_t;
#endif
#if KHRONOS_SUPPORT_FLOAT
/*
* Float type
*/
typedef float khronos_float_t;
#endif
#if KHRONOS_SUPPORT_INT64
/* Time types
*
* These types can be used to represent a time interval in nanoseconds or
* an absolute Unadjusted System Time. Unadjusted System Time is the number
* of nanoseconds since some arbitrary system event (e.g. since the last
* time the system booted). The Unadjusted System Time is an unsigned
* 64 bit value that wraps back to 0 every 584 years. Time intervals
* may be either signed or unsigned.
*/
typedef khronos_uint64_t khronos_utime_nanoseconds_t;
typedef khronos_int64_t khronos_stime_nanoseconds_t;
#endif
/*
* Dummy value used to pad enum types to 32 bits.
*/
#ifndef KHRONOS_MAX_ENUM
#define KHRONOS_MAX_ENUM 0x7FFFFFFF
#endif
/*
* Enumerated boolean type
*
* Values other than zero should be considered to be true. Therefore
* comparisons should not be made against KHRONOS_TRUE.
*/
typedef enum {
KHRONOS_FALSE = 0,
KHRONOS_TRUE = 1,
KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
} khronos_boolean_enum_t;
#endif /* __khrplatform_h_ */
================================================
FILE: src/3rdparty/glad/include/glad/glad_egl.h
================================================
/*
EGL loader generated by glad 0.1.25 on Mon Jan 14 16:56:21 2019.
Language/Generator: C/C++
Specification: egl
APIs: egl=1.5
Profile: -
Extensions:
EGL_ANDROID_blob_cache,
EGL_ANDROID_create_native_client_buffer,
EGL_ANDROID_framebuffer_target,
EGL_ANDROID_front_buffer_auto_refresh,
EGL_ANDROID_get_frame_timestamps,
EGL_ANDROID_get_native_client_buffer,
EGL_ANDROID_image_native_buffer,
EGL_ANDROID_native_fence_sync,
EGL_ANDROID_presentation_time,
EGL_ANDROID_recordable,
EGL_ANGLE_d3d_share_handle_client_buffer,
EGL_ANGLE_device_d3d,
EGL_ANGLE_query_surface_pointer,
EGL_ANGLE_surface_d3d_texture_2d_share_handle,
EGL_ANGLE_window_fixed_size,
EGL_ARM_implicit_external_sync,
EGL_ARM_pixmap_multisample_discard,
EGL_EXT_bind_to_front,
EGL_EXT_buffer_age,
EGL_EXT_client_extensions,
EGL_EXT_client_sync,
EGL_EXT_compositor,
EGL_EXT_create_context_robustness,
EGL_EXT_device_base,
EGL_EXT_device_drm,
EGL_EXT_device_enumeration,
EGL_EXT_device_openwf,
EGL_EXT_device_query,
EGL_EXT_gl_colorspace_bt2020_linear,
EGL_EXT_gl_colorspace_bt2020_pq,
EGL_EXT_gl_colorspace_display_p3,
EGL_EXT_gl_colorspace_display_p3_linear,
EGL_EXT_gl_colorspace_display_p3_passthrough,
EGL_EXT_gl_colorspace_scrgb,
EGL_EXT_gl_colorspace_scrgb_linear,
EGL_EXT_image_dma_buf_import,
EGL_EXT_image_dma_buf_import_modifiers,
EGL_EXT_image_gl_colorspace,
EGL_EXT_image_implicit_sync_control,
EGL_EXT_multiview_window,
EGL_EXT_output_base,
EGL_EXT_output_drm,
EGL_EXT_output_openwf,
EGL_EXT_pixel_format_float,
EGL_EXT_platform_base,
EGL_EXT_platform_device,
EGL_EXT_platform_wayland,
EGL_EXT_platform_x11,
EGL_EXT_protected_content,
EGL_EXT_protected_surface,
EGL_EXT_stream_consumer_egloutput,
EGL_EXT_surface_CTA861_3_metadata,
EGL_EXT_surface_SMPTE2086_metadata,
EGL_EXT_swap_buffers_with_damage,
EGL_EXT_sync_reuse,
EGL_EXT_yuv_surface,
EGL_HI_clientpixmap,
EGL_HI_colorformats,
EGL_IMG_context_priority,
EGL_IMG_image_plane_attribs,
EGL_KHR_cl_event,
EGL_KHR_cl_event2,
EGL_KHR_client_get_all_proc_addresses,
EGL_KHR_config_attribs,
EGL_KHR_context_flush_control,
EGL_KHR_create_context,
EGL_KHR_create_context_no_error,
EGL_KHR_debug,
EGL_KHR_display_reference,
EGL_KHR_fence_sync,
EGL_KHR_get_all_proc_addresses,
EGL_KHR_gl_colorspace,
EGL_KHR_gl_renderbuffer_image,
EGL_KHR_gl_texture_2D_image,
EGL_KHR_gl_texture_3D_image,
EGL_KHR_gl_texture_cubemap_image,
EGL_KHR_image,
EGL_KHR_image_base,
EGL_KHR_image_pixmap,
EGL_KHR_lock_surface,
EGL_KHR_lock_surface2,
EGL_KHR_lock_surface3,
EGL_KHR_mutable_render_buffer,
EGL_KHR_no_config_context,
EGL_KHR_partial_update,
EGL_KHR_platform_android,
EGL_KHR_platform_gbm,
EGL_KHR_platform_wayland,
EGL_KHR_platform_x11,
EGL_KHR_reusable_sync,
EGL_KHR_stream,
EGL_KHR_stream_attrib,
EGL_KHR_stream_consumer_gltexture,
EGL_KHR_stream_cross_process_fd,
EGL_KHR_stream_fifo,
EGL_KHR_stream_producer_aldatalocator,
EGL_KHR_stream_producer_eglsurface,
EGL_KHR_surfaceless_context,
EGL_KHR_swap_buffers_with_damage,
EGL_KHR_vg_parent_image,
EGL_KHR_wait_sync,
EGL_MESA_drm_image,
EGL_MESA_image_dma_buf_export,
EGL_MESA_platform_gbm,
EGL_MESA_platform_surfaceless,
EGL_NOK_swap_region,
EGL_NOK_swap_region2,
EGL_NOK_texture_from_pixmap,
EGL_NV_3dvision_surface,
EGL_NV_context_priority_realtime,
EGL_NV_coverage_sample,
EGL_NV_coverage_sample_resolve,
EGL_NV_cuda_event,
EGL_NV_depth_nonlinear,
EGL_NV_device_cuda,
EGL_NV_native_query,
EGL_NV_post_convert_rounding,
EGL_NV_post_sub_buffer,
EGL_NV_robustness_video_memory_purge,
EGL_NV_stream_consumer_gltexture_yuv,
EGL_NV_stream_cross_display,
EGL_NV_stream_cross_object,
EGL_NV_stream_cross_partition,
EGL_NV_stream_cross_process,
EGL_NV_stream_cross_system,
EGL_NV_stream_fifo_next,
EGL_NV_stream_fifo_synchronous,
EGL_NV_stream_flush,
EGL_NV_stream_frame_limits,
EGL_NV_stream_metadata,
EGL_NV_stream_remote,
EGL_NV_stream_reset,
EGL_NV_stream_socket,
EGL_NV_stream_socket_inet,
EGL_NV_stream_socket_unix,
EGL_NV_stream_sync,
EGL_NV_sync,
EGL_NV_system_time,
EGL_TIZEN_image_native_buffer,
EGL_TIZEN_image_native_surface
Loader: True
Local files: False
Omit khrplatform: False
Commandline:
--api="egl=1.5" --generator="c" --spec="egl" --extensions="EGL_ANDROID_blob_cache,EGL_ANDROID_create_native_client_buffer,EGL_ANDROID_framebuffer_target,EGL_ANDROID_front_buffer_auto_refresh,EGL_ANDROID_get_frame_timestamps,EGL_ANDROID_get_native_client_buffer,EGL_ANDROID_image_native_buffer,EGL_ANDROID_native_fence_sync,EGL_ANDROID_presentation_time,EGL_ANDROID_recordable,EGL_ANGLE_d3d_share_handle_client_buffer,EGL_ANGLE_device_d3d,EGL_ANGLE_query_surface_pointer,EGL_ANGLE_surface_d3d_texture_2d_share_handle,EGL_ANGLE_window_fixed_size,EGL_ARM_implicit_external_sync,EGL_ARM_pixmap_multisample_discard,EGL_EXT_bind_to_front,EGL_EXT_buffer_age,EGL_EXT_client_extensions,EGL_EXT_client_sync,EGL_EXT_compositor,EGL_EXT_create_context_robustness,EGL_EXT_device_base,EGL_EXT_device_drm,EGL_EXT_device_enumeration,EGL_EXT_device_openwf,EGL_EXT_device_query,EGL_EXT_gl_colorspace_bt2020_linear,EGL_EXT_gl_colorspace_bt2020_pq,EGL_EXT_gl_colorspace_display_p3,EGL_EXT_gl_colorspace_display_p3_linear,EGL_EXT_gl_colorspace_display_p3_passthrough,EGL_EXT_gl_colorspace_scrgb,EGL_EXT_gl_colorspace_scrgb_linear,EGL_EXT_image_dma_buf_import,EGL_EXT_image_dma_buf_import_modifiers,EGL_EXT_image_gl_colorspace,EGL_EXT_image_implicit_sync_control,EGL_EXT_multiview_window,EGL_EXT_output_base,EGL_EXT_output_drm,EGL_EXT_output_openwf,EGL_EXT_pixel_format_float,EGL_EXT_platform_base,EGL_EXT_platform_device,EGL_EXT_platform_wayland,EGL_EXT_platform_x11,EGL_EXT_protected_content,EGL_EXT_protected_surface,EGL_EXT_stream_consumer_egloutput,EGL_EXT_surface_CTA861_3_metadata,EGL_EXT_surface_SMPTE2086_metadata,EGL_EXT_swap_buffers_with_damage,EGL_EXT_sync_reuse,EGL_EXT_yuv_surface,EGL_HI_clientpixmap,EGL_HI_colorformats,EGL_IMG_context_priority,EGL_IMG_image_plane_attribs,EGL_KHR_cl_event,EGL_KHR_cl_event2,EGL_KHR_client_get_all_proc_addresses,EGL_KHR_config_attribs,EGL_KHR_context_flush_control,EGL_KHR_create_context,EGL_KHR_create_context_no_error,EGL_KHR_debug,EGL_KHR_display_reference,EGL_KHR_fence_sync,EGL_KHR_get_all_proc_addresses,EGL_KHR_gl_colorspace,EGL_KHR_gl_renderbuffer_image,EGL_KHR_gl_texture_2D_image,EGL_KHR_gl_texture_3D_image,EGL_KHR_gl_texture_cubemap_image,EGL_KHR_image,EGL_KHR_image_base,EGL_KHR_image_pixmap,EGL_KHR_lock_surface,EGL_KHR_lock_surface2,EGL_KHR_lock_surface3,EGL_KHR_mutable_render_buffer,EGL_KHR_no_config_context,EGL_KHR_partial_update,EGL_KHR_platform_android,EGL_KHR_platform_gbm,EGL_KHR_platform_wayland,EGL_KHR_platform_x11,EGL_KHR_reusable_sync,EGL_KHR_stream,EGL_KHR_stream_attrib,EGL_KHR_stream_consumer_gltexture,EGL_KHR_stream_cross_process_fd,EGL_KHR_stream_fifo,EGL_KHR_stream_producer_aldatalocator,EGL_KHR_stream_producer_eglsurface,EGL_KHR_surfaceless_context,EGL_KHR_swap_buffers_with_damage,EGL_KHR_vg_parent_image,EGL_KHR_wait_sync,EGL_MESA_drm_image,EGL_MESA_image_dma_buf_export,EGL_MESA_platform_gbm,EGL_MESA_platform_surfaceless,EGL_NOK_swap_region,EGL_NOK_swap_region2,EGL_NOK_texture_from_pixmap,EGL_NV_3dvision_surface,EGL_NV_context_priority_realtime,EGL_NV_coverage_sample,EGL_NV_coverage_sample_resolve,EGL_NV_cuda_event,EGL_NV_depth_nonlinear,EGL_NV_device_cuda,EGL_NV_native_query,EGL_NV_post_convert_rounding,EGL_NV_post_sub_buffer,EGL_NV_robustness_video_memory_purge,EGL_NV_stream_consumer_gltexture_yuv,EGL_NV_stream_cross_display,EGL_NV_stream_cross_object,EGL_NV_stream_cross_partition,EGL_NV_stream_cross_process,EGL_NV_stream_cross_system,EGL_NV_stream_fifo_next,EGL_NV_stream_fifo_synchronous,EGL_NV_stream_flush,EGL_NV_stream_frame_limits,EGL_NV_stream_metadata,EGL_NV_stream_remote,EGL_NV_stream_reset,EGL_NV_stream_socket,EGL_NV_stream_socket_inet,EGL_NV_stream_socket_unix,EGL_NV_stream_sync,EGL_NV_sync,EGL_NV_system_time,EGL_TIZEN_image_native_buffer,EGL_TIZEN_image_native_surface"
Online:
Too many extensions
*/
#ifndef __glad_egl_h_
#ifdef __egl_h_
#error EGL header already included, remove this include, glad already provides it
#endif
#define __glad_egl_h_
#define __egl_h_
#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN 1
#endif
#ifndef NOMINMAX
#define NOMINMAX 1
#endif
#include
#endif
#ifndef APIENTRY
#define APIENTRY
#endif
#ifndef APIENTRYP
#define APIENTRYP APIENTRY *
#endif
#ifndef GLAPI
#define GLAPI extern
#endif
#ifdef __cplusplus
extern "C" {
#endif
typedef void* (* GLADloadproc)(const char *name);
GLAPI int gladLoadEGL(void);
GLAPI int gladLoadEGLLoader(GLADloadproc);
#include
#include
struct AHardwareBuffer;
typedef unsigned int EGLBoolean;
typedef unsigned int EGLenum;
typedef intptr_t EGLAttribKHR;
typedef intptr_t EGLAttrib;
typedef void *EGLClientBuffer;
typedef void *EGLConfig;
typedef void *EGLContext;
typedef void *EGLDeviceEXT;
typedef void *EGLDisplay;
typedef void *EGLImage;
typedef void *EGLImageKHR;
typedef void *EGLLabelKHR;
typedef void *EGLObjectKHR;
typedef void *EGLOutputLayerEXT;
typedef void *EGLOutputPortEXT;
typedef void *EGLStreamKHR;
typedef void *EGLSurface;
typedef void *EGLSync;
typedef void *EGLSyncKHR;
typedef void *EGLSyncNV;
typedef void (*__eglMustCastToProperFunctionPointerType)(void);
typedef khronos_utime_nanoseconds_t EGLTimeKHR;
typedef khronos_utime_nanoseconds_t EGLTime;
typedef khronos_utime_nanoseconds_t EGLTimeNV;
typedef khronos_utime_nanoseconds_t EGLuint64NV;
typedef khronos_uint64_t EGLuint64KHR;
typedef khronos_stime_nanoseconds_t EGLnsecsANDROID;
typedef int EGLNativeFileDescriptorKHR;
typedef khronos_ssize_t EGLsizeiANDROID;
typedef void (*EGLSetBlobFuncANDROID) (const void *key, EGLsizeiANDROID keySize, const void *value, EGLsizeiANDROID valueSize);
typedef EGLsizeiANDROID (*EGLGetBlobFuncANDROID) (const void *key, EGLsizeiANDROID keySize, void *value, EGLsizeiANDROID valueSize);
struct EGLClientPixmapHI {
void *pData;
EGLint iWidth;
EGLint iHeight;
EGLint iStride;
};
typedef void (APIENTRY *EGLDEBUGPROCKHR)(EGLenum error,const char *command,EGLint messageType,EGLLabelKHR threadLabel,EGLLabelKHR objectLabel,const char* message);
#define EGL_ALPHA_SIZE 0x3021
#define EGL_BAD_ACCESS 0x3002
#define EGL_BAD_ALLOC 0x3003
#define EGL_BAD_ATTRIBUTE 0x3004
#define EGL_BAD_CONFIG 0x3005
#define EGL_BAD_CONTEXT 0x3006
#define EGL_BAD_CURRENT_SURFACE 0x3007
#define EGL_BAD_DISPLAY 0x3008
#define EGL_BAD_MATCH 0x3009
#define EGL_BAD_NATIVE_PIXMAP 0x300A
#define EGL_BAD_NATIVE_WINDOW 0x300B
#define EGL_BAD_PARAMETER 0x300C
#define EGL_BAD_SURFACE 0x300D
#define EGL_BLUE_SIZE 0x3022
#define EGL_BUFFER_SIZE 0x3020
#define EGL_CONFIG_CAVEAT 0x3027
#define EGL_CONFIG_ID 0x3028
#define EGL_CORE_NATIVE_ENGINE 0x305B
#define EGL_DEPTH_SIZE 0x3025
#define EGL_DONT_CARE EGL_CAST(EGLint,-1)
#define EGL_DRAW 0x3059
#define EGL_EXTENSIONS 0x3055
#define EGL_FALSE 0
#define EGL_GREEN_SIZE 0x3023
#define EGL_HEIGHT 0x3056
#define EGL_LARGEST_PBUFFER 0x3058
#define EGL_LEVEL 0x3029
#define EGL_MAX_PBUFFER_HEIGHT 0x302A
#define EGL_MAX_PBUFFER_PIXELS 0x302B
#define EGL_MAX_PBUFFER_WIDTH 0x302C
#define EGL_NATIVE_RENDERABLE 0x302D
#define EGL_NATIVE_VISUAL_ID 0x302E
#define EGL_NATIVE_VISUAL_TYPE 0x302F
#define EGL_NONE 0x3038
#define EGL_NON_CONFORMANT_CONFIG 0x3051
#define EGL_NOT_INITIALIZED 0x3001
#define EGL_NO_CONTEXT EGL_CAST(EGLContext,0)
#define EGL_NO_DISPLAY EGL_CAST(EGLDisplay,0)
#define EGL_NO_SURFACE EGL_CAST(EGLSurface,0)
#define EGL_PBUFFER_BIT 0x0001
#define EGL_PIXMAP_BIT 0x0002
#define EGL_READ 0x305A
#define EGL_RED_SIZE 0x3024
#define EGL_SAMPLES 0x3031
#define EGL_SAMPLE_BUFFERS 0x3032
#define EGL_SLOW_CONFIG 0x3050
#define EGL_STENCIL_SIZE 0x3026
#define EGL_SUCCESS 0x3000
#define EGL_SURFACE_TYPE 0x3033
#define EGL_TRANSPARENT_BLUE_VALUE 0x3035
#define EGL_TRANSPARENT_GREEN_VALUE 0x3036
#define EGL_TRANSPARENT_RED_VALUE 0x3037
#define EGL_TRANSPARENT_RGB 0x3052
#define EGL_TRANSPARENT_TYPE 0x3034
#define EGL_TRUE 1
#define EGL_VENDOR 0x3053
#define EGL_VERSION 0x3054
#define EGL_WIDTH 0x3057
#define EGL_WINDOW_BIT 0x0004
#define EGL_BACK_BUFFER 0x3084
#define EGL_BIND_TO_TEXTURE_RGB 0x3039
#define EGL_BIND_TO_TEXTURE_RGBA 0x303A
#define EGL_CONTEXT_LOST 0x300E
#define EGL_MIN_SWAP_INTERVAL 0x303B
#define EGL_MAX_SWAP_INTERVAL 0x303C
#define EGL_MIPMAP_TEXTURE 0x3082
#define EGL_MIPMAP_LEVEL 0x3083
#define EGL_NO_TEXTURE 0x305C
#define EGL_TEXTURE_2D 0x305F
#define EGL_TEXTURE_FORMAT 0x3080
#define EGL_TEXTURE_RGB 0x305D
#define EGL_TEXTURE_RGBA 0x305E
#define EGL_TEXTURE_TARGET 0x3081
#define EGL_ALPHA_FORMAT 0x3088
#define EGL_ALPHA_FORMAT_NONPRE 0x308B
#define EGL_ALPHA_FORMAT_PRE 0x308C
#define EGL_ALPHA_MASK_SIZE 0x303E
#define EGL_BUFFER_PRESERVED 0x3094
#define EGL_BUFFER_DESTROYED 0x3095
#define EGL_CLIENT_APIS 0x308D
#define EGL_COLORSPACE 0x3087
#define EGL_COLORSPACE_sRGB 0x3089
#define EGL_COLORSPACE_LINEAR 0x308A
#define EGL_COLOR_BUFFER_TYPE 0x303F
#define EGL_CONTEXT_CLIENT_TYPE 0x3097
#define EGL_DISPLAY_SCALING 10000
#define EGL_HORIZONTAL_RESOLUTION 0x3090
#define EGL_LUMINANCE_BUFFER 0x308F
#define EGL_LUMINANCE_SIZE 0x303D
#define EGL_OPENGL_ES_BIT 0x0001
#define EGL_OPENVG_BIT 0x0002
#define EGL_OPENGL_ES_API 0x30A0
#define EGL_OPENVG_API 0x30A1
#define EGL_OPENVG_IMAGE 0x3096
#define EGL_PIXEL_ASPECT_RATIO 0x3092
#define EGL_RENDERABLE_TYPE 0x3040
#define EGL_RENDER_BUFFER 0x3086
#define EGL_RGB_BUFFER 0x308E
#define EGL_SINGLE_BUFFER 0x3085
#define EGL_SWAP_BEHAVIOR 0x3093
#define EGL_UNKNOWN EGL_CAST(EGLint,-1)
#define EGL_VERTICAL_RESOLUTION 0x3091
#define EGL_CONFORMANT 0x3042
#define EGL_CONTEXT_CLIENT_VERSION 0x3098
#define EGL_MATCH_NATIVE_PIXMAP 0x3041
#define EGL_OPENGL_ES2_BIT 0x0004
#define EGL_VG_ALPHA_FORMAT 0x3088
#define EGL_VG_ALPHA_FORMAT_NONPRE 0x308B
#define EGL_VG_ALPHA_FORMAT_PRE 0x308C
#define EGL_VG_ALPHA_FORMAT_PRE_BIT 0x0040
#define EGL_VG_COLORSPACE 0x3087
#define EGL_VG_COLORSPACE_sRGB 0x3089
#define EGL_VG_COLORSPACE_LINEAR 0x308A
#define EGL_VG_COLORSPACE_LINEAR_BIT 0x0020
#define EGL_DEFAULT_DISPLAY EGL_CAST(EGLNativeDisplayType,0)
#define EGL_MULTISAMPLE_RESOLVE_BOX_BIT 0x0200
#define EGL_MULTISAMPLE_RESOLVE 0x3099
#define EGL_MULTISAMPLE_RESOLVE_DEFAULT 0x309A
#define EGL_MULTISAMPLE_RESOLVE_BOX 0x309B
#define EGL_OPENGL_API 0x30A2
#define EGL_OPENGL_BIT 0x0008
#define EGL_SWAP_BEHAVIOR_PRESERVED_BIT 0x0400
#define EGL_CONTEXT_MAJOR_VERSION 0x3098
#define EGL_CONTEXT_MINOR_VERSION 0x30FB
#define EGL_CONTEXT_OPENGL_PROFILE_MASK 0x30FD
#define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY 0x31BD
#define EGL_NO_RESET_NOTIFICATION 0x31BE
#define EGL_LOSE_CONTEXT_ON_RESET 0x31BF
#define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT 0x00000001
#define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT 0x00000002
#define EGL_CONTEXT_OPENGL_DEBUG 0x31B0
#define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE 0x31B1
#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS 0x31B2
#define EGL_OPENGL_ES3_BIT 0x00000040
#define EGL_CL_EVENT_HANDLE 0x309C
#define EGL_SYNC_CL_EVENT 0x30FE
#define EGL_SYNC_CL_EVENT_COMPLETE 0x30FF
#define EGL_SYNC_PRIOR_COMMANDS_COMPLETE 0x30F0
#define EGL_SYNC_TYPE 0x30F7
#define EGL_SYNC_STATUS 0x30F1
#define EGL_SYNC_CONDITION 0x30F8
#define EGL_SIGNALED 0x30F2
#define EGL_UNSIGNALED 0x30F3
#define EGL_SYNC_FLUSH_COMMANDS_BIT 0x0001
#define EGL_FOREVER 0xFFFFFFFFFFFFFFFF
#define EGL_TIMEOUT_EXPIRED 0x30F5
#define EGL_CONDITION_SATISFIED 0x30F6
#define EGL_NO_SYNC EGL_CAST(EGLSync,0)
#define EGL_SYNC_FENCE 0x30F9
#define EGL_GL_COLORSPACE 0x309D
#define EGL_GL_COLORSPACE_SRGB 0x3089
#define EGL_GL_COLORSPACE_LINEAR 0x308A
#define EGL_GL_RENDERBUFFER 0x30B9
#define EGL_GL_TEXTURE_2D 0x30B1
#define EGL_GL_TEXTURE_LEVEL 0x30BC
#define EGL_GL_TEXTURE_3D 0x30B2
#define EGL_GL_TEXTURE_ZOFFSET 0x30BD
#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x30B3
#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x30B4
#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x30B5
#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x30B6
#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x30B7
#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x30B8
#define EGL_IMAGE_PRESERVED 0x30D2
#define EGL_NO_IMAGE EGL_CAST(EGLImage,0)
EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config);
EGLBoolean eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target);
EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list);
EGLSurface eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list);
EGLSurface eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list);
EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list);
EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx);
EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface);
EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value);
EGLBoolean eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config);
EGLDisplay eglGetCurrentDisplay(void);
EGLSurface eglGetCurrentSurface(EGLint readdraw);
EGLDisplay eglGetDisplay(EGLNativeDisplayType display_id);
EGLint eglGetError(void);
__eglMustCastToProperFunctionPointerType eglGetProcAddress(const char *procname);
EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor);
EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
EGLBoolean eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value);
const char *eglQueryString(EGLDisplay dpy, EGLint name);
EGLBoolean eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value);
EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface surface);
EGLBoolean eglTerminate(EGLDisplay dpy);
EGLBoolean eglWaitGL(void);
EGLBoolean eglWaitNative(EGLint engine);
EGLBoolean eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
EGLBoolean eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
EGLBoolean eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval);
EGLBoolean eglBindAPI(EGLenum api);
EGLenum eglQueryAPI(void);
EGLSurface eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list);
EGLBoolean eglReleaseThread(void);
EGLBoolean eglWaitClient(void);
EGLContext eglGetCurrentContext(void);
EGLSync eglCreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list);
EGLBoolean eglDestroySync(EGLDisplay dpy, EGLSync sync);
EGLint eglClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout);
EGLBoolean eglGetSyncAttrib(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib *value);
EGLImage eglCreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLAttrib *attrib_list);
EGLBoolean eglDestroyImage(EGLDisplay dpy, EGLImage image);
EGLDisplay eglGetPlatformDisplay(EGLenum platform, void *native_display, const EGLAttrib *attrib_list);
EGLSurface eglCreatePlatformWindowSurface(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLAttrib *attrib_list);
EGLSurface eglCreatePlatformPixmapSurface(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLAttrib *attrib_list);
EGLBoolean eglWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags);
#define EGL_NATIVE_BUFFER_USAGE_ANDROID 0x3143
#define EGL_NATIVE_BUFFER_USAGE_PROTECTED_BIT_ANDROID 0x00000001
#define EGL_NATIVE_BUFFER_USAGE_RENDERBUFFER_BIT_ANDROID 0x00000002
#define EGL_NATIVE_BUFFER_USAGE_TEXTURE_BIT_ANDROID 0x00000004
#define EGL_FRAMEBUFFER_TARGET_ANDROID 0x3147
#define EGL_FRONT_BUFFER_AUTO_REFRESH_ANDROID 0x314C
#define EGL_TIMESTAMP_PENDING_ANDROID EGL_CAST(EGLnsecsANDROID,-2)
#define EGL_TIMESTAMP_INVALID_ANDROID EGL_CAST(EGLnsecsANDROID,-1)
#define EGL_TIMESTAMPS_ANDROID 0x3430
#define EGL_COMPOSITE_DEADLINE_ANDROID 0x3431
#define EGL_COMPOSITE_INTERVAL_ANDROID 0x3432
#define EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID 0x3433
#define EGL_REQUESTED_PRESENT_TIME_ANDROID 0x3434
#define EGL_RENDERING_COMPLETE_TIME_ANDROID 0x3435
#define EGL_COMPOSITION_LATCH_TIME_ANDROID 0x3436
#define EGL_FIRST_COMPOSITION_START_TIME_ANDROID 0x3437
#define EGL_LAST_COMPOSITION_START_TIME_ANDROID 0x3438
#define EGL_FIRST_COMPOSITION_GPU_FINISHED_TIME_ANDROID 0x3439
#define EGL_DISPLAY_PRESENT_TIME_ANDROID 0x343A
#define EGL_DEQUEUE_READY_TIME_ANDROID 0x343B
#define EGL_READS_DONE_TIME_ANDROID 0x343C
#define EGL_NATIVE_BUFFER_ANDROID 0x3140
#define EGL_SYNC_NATIVE_FENCE_ANDROID 0x3144
#define EGL_SYNC_NATIVE_FENCE_FD_ANDROID 0x3145
#define EGL_SYNC_NATIVE_FENCE_SIGNALED_ANDROID 0x3146
#define EGL_NO_NATIVE_FENCE_FD_ANDROID -1
#define EGL_RECORDABLE_ANDROID 0x3142
#define EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE 0x3200
#define EGL_D3D9_DEVICE_ANGLE 0x33A0
#define EGL_D3D11_DEVICE_ANGLE 0x33A1
#define EGL_FIXED_SIZE_ANGLE 0x3201
#define EGL_SYNC_PRIOR_COMMANDS_IMPLICIT_EXTERNAL_ARM 0x328A
#define EGL_DISCARD_SAMPLES_ARM 0x3286
#define EGL_FRONT_BUFFER_EXT 0x3464
#define EGL_BUFFER_AGE_EXT 0x313D
#define EGL_SYNC_CLIENT_EXT 0x3364
#define EGL_SYNC_CLIENT_SIGNAL_EXT 0x3365
#define EGL_PRIMARY_COMPOSITOR_CONTEXT_EXT 0x3460
#define EGL_EXTERNAL_REF_ID_EXT 0x3461
#define EGL_COMPOSITOR_DROP_NEWEST_FRAME_EXT 0x3462
#define EGL_COMPOSITOR_KEEP_NEWEST_FRAME_EXT 0x3463
#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT 0x30BF
#define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT 0x3138
#define EGL_NO_RESET_NOTIFICATION_EXT 0x31BE
#define EGL_LOSE_CONTEXT_ON_RESET_EXT 0x31BF
#define EGL_NO_DEVICE_EXT EGL_CAST(EGLDeviceEXT,0)
#define EGL_BAD_DEVICE_EXT 0x322B
#define EGL_DEVICE_EXT 0x322C
#define EGL_DRM_DEVICE_FILE_EXT 0x3233
#define EGL_DRM_MASTER_FD_EXT 0x333C
#define EGL_OPENWF_DEVICE_ID_EXT 0x3237
#define EGL_GL_COLORSPACE_BT2020_LINEAR_EXT 0x333F
#define EGL_GL_COLORSPACE_BT2020_PQ_EXT 0x3340
#define EGL_GL_COLORSPACE_DISPLAY_P3_EXT 0x3363
#define EGL_GL_COLORSPACE_DISPLAY_P3_LINEAR_EXT 0x3362
#define EGL_GL_COLORSPACE_DISPLAY_P3_PASSTHROUGH_EXT 0x3490
#define EGL_GL_COLORSPACE_SCRGB_EXT 0x3351
#define EGL_GL_COLORSPACE_SCRGB_LINEAR_EXT 0x3350
#define EGL_LINUX_DMA_BUF_EXT 0x3270
#define EGL_LINUX_DRM_FOURCC_EXT 0x3271
#define EGL_DMA_BUF_PLANE0_FD_EXT 0x3272
#define EGL_DMA_BUF_PLANE0_OFFSET_EXT 0x3273
#define EGL_DMA_BUF_PLANE0_PITCH_EXT 0x3274
#define EGL_DMA_BUF_PLANE1_FD_EXT 0x3275
#define EGL_DMA_BUF_PLANE1_OFFSET_EXT 0x3276
#define EGL_DMA_BUF_PLANE1_PITCH_EXT 0x3277
#define EGL_DMA_BUF_PLANE2_FD_EXT 0x3278
#define EGL_DMA_BUF_PLANE2_OFFSET_EXT 0x3279
#define EGL_DMA_BUF_PLANE2_PITCH_EXT 0x327A
#define EGL_YUV_COLOR_SPACE_HINT_EXT 0x327B
#define EGL_SAMPLE_RANGE_HINT_EXT 0x327C
#define EGL_YUV_CHROMA_HORIZONTAL_SITING_HINT_EXT 0x327D
#define EGL_YUV_CHROMA_VERTICAL_SITING_HINT_EXT 0x327E
#define EGL_ITU_REC601_EXT 0x327F
#define EGL_ITU_REC709_EXT 0x3280
#define EGL_ITU_REC2020_EXT 0x3281
#define EGL_YUV_FULL_RANGE_EXT 0x3282
#define EGL_YUV_NARROW_RANGE_EXT 0x3283
#define EGL_YUV_CHROMA_SITING_0_EXT 0x3284
#define EGL_YUV_CHROMA_SITING_0_5_EXT 0x3285
#define EGL_DMA_BUF_PLANE3_FD_EXT 0x3440
#define EGL_DMA_BUF_PLANE3_OFFSET_EXT 0x3441
#define EGL_DMA_BUF_PLANE3_PITCH_EXT 0x3442
#define EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT 0x3443
#define EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT 0x3444
#define EGL_DMA_BUF_PLANE1_MODIFIER_LO_EXT 0x3445
#define EGL_DMA_BUF_PLANE1_MODIFIER_HI_EXT 0x3446
#define EGL_DMA_BUF_PLANE2_MODIFIER_LO_EXT 0x3447
#define EGL_DMA_BUF_PLANE2_MODIFIER_HI_EXT 0x3448
#define EGL_DMA_BUF_PLANE3_MODIFIER_LO_EXT 0x3449
#define EGL_DMA_BUF_PLANE3_MODIFIER_HI_EXT 0x344A
#define EGL_GL_COLORSPACE_DEFAULT_EXT 0x314D
#define EGL_IMPORT_SYNC_TYPE_EXT 0x3470
#define EGL_IMPORT_IMPLICIT_SYNC_EXT 0x3471
#define EGL_IMPORT_EXPLICIT_SYNC_EXT 0x3472
#define EGL_MULTIVIEW_VIEW_COUNT_EXT 0x3134
#define EGL_NO_OUTPUT_LAYER_EXT EGL_CAST(EGLOutputLayerEXT,0)
#define EGL_NO_OUTPUT_PORT_EXT EGL_CAST(EGLOutputPortEXT,0)
#define EGL_BAD_OUTPUT_LAYER_EXT 0x322D
#define EGL_BAD_OUTPUT_PORT_EXT 0x322E
#define EGL_SWAP_INTERVAL_EXT 0x322F
#define EGL_DRM_CRTC_EXT 0x3234
#define EGL_DRM_PLANE_EXT 0x3235
#define EGL_DRM_CONNECTOR_EXT 0x3236
#define EGL_OPENWF_PIPELINE_ID_EXT 0x3238
#define EGL_OPENWF_PORT_ID_EXT 0x3239
#define EGL_COLOR_COMPONENT_TYPE_EXT 0x3339
#define EGL_COLOR_COMPONENT_TYPE_FIXED_EXT 0x333A
#define EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT 0x333B
#define EGL_PLATFORM_DEVICE_EXT 0x313F
#define EGL_PLATFORM_WAYLAND_EXT 0x31D8
#define EGL_PLATFORM_X11_EXT 0x31D5
#define EGL_PLATFORM_X11_SCREEN_EXT 0x31D6
#define EGL_PROTECTED_CONTENT_EXT 0x32C0
#define EGL_CTA861_3_MAX_CONTENT_LIGHT_LEVEL_EXT 0x3360
#define EGL_CTA861_3_MAX_FRAME_AVERAGE_LEVEL_EXT 0x3361
#define EGL_SMPTE2086_DISPLAY_PRIMARY_RX_EXT 0x3341
#define EGL_SMPTE2086_DISPLAY_PRIMARY_RY_EXT 0x3342
#define EGL_SMPTE2086_DISPLAY_PRIMARY_GX_EXT 0x3343
#define EGL_SMPTE2086_DISPLAY_PRIMARY_GY_EXT 0x3344
#define EGL_SMPTE2086_DISPLAY_PRIMARY_BX_EXT 0x3345
#define EGL_SMPTE2086_DISPLAY_PRIMARY_BY_EXT 0x3346
#define EGL_SMPTE2086_WHITE_POINT_X_EXT 0x3347
#define EGL_SMPTE2086_WHITE_POINT_Y_EXT 0x3348
#define EGL_SMPTE2086_MAX_LUMINANCE_EXT 0x3349
#define EGL_SMPTE2086_MIN_LUMINANCE_EXT 0x334A
#define EGL_METADATA_SCALING_EXT 50000
#define EGL_YUV_ORDER_EXT 0x3301
#define EGL_YUV_NUMBER_OF_PLANES_EXT 0x3311
#define EGL_YUV_SUBSAMPLE_EXT 0x3312
#define EGL_YUV_DEPTH_RANGE_EXT 0x3317
#define EGL_YUV_CSC_STANDARD_EXT 0x330A
#define EGL_YUV_PLANE_BPP_EXT 0x331A
#define EGL_YUV_BUFFER_EXT 0x3300
#define EGL_YUV_ORDER_YUV_EXT 0x3302
#define EGL_YUV_ORDER_YVU_EXT 0x3303
#define EGL_YUV_ORDER_YUYV_EXT 0x3304
#define EGL_YUV_ORDER_UYVY_EXT 0x3305
#define EGL_YUV_ORDER_YVYU_EXT 0x3306
#define EGL_YUV_ORDER_VYUY_EXT 0x3307
#define EGL_YUV_ORDER_AYUV_EXT 0x3308
#define EGL_YUV_SUBSAMPLE_4_2_0_EXT 0x3313
#define EGL_YUV_SUBSAMPLE_4_2_2_EXT 0x3314
#define EGL_YUV_SUBSAMPLE_4_4_4_EXT 0x3315
#define EGL_YUV_DEPTH_RANGE_LIMITED_EXT 0x3318
#define EGL_YUV_DEPTH_RANGE_FULL_EXT 0x3319
#define EGL_YUV_CSC_STANDARD_601_EXT 0x330B
#define EGL_YUV_CSC_STANDARD_709_EXT 0x330C
#define EGL_YUV_CSC_STANDARD_2020_EXT 0x330D
#define EGL_YUV_PLANE_BPP_0_EXT 0x331B
#define EGL_YUV_PLANE_BPP_8_EXT 0x331C
#define EGL_YUV_PLANE_BPP_10_EXT 0x331D
#define EGL_CLIENT_PIXMAP_POINTER_HI 0x8F74
#define EGL_COLOR_FORMAT_HI 0x8F70
#define EGL_COLOR_RGB_HI 0x8F71
#define EGL_COLOR_RGBA_HI 0x8F72
#define EGL_COLOR_ARGB_HI 0x8F73
#define EGL_CONTEXT_PRIORITY_LEVEL_IMG 0x3100
#define EGL_CONTEXT_PRIORITY_HIGH_IMG 0x3101
#define EGL_CONTEXT_PRIORITY_MEDIUM_IMG 0x3102
#define EGL_CONTEXT_PRIORITY_LOW_IMG 0x3103
#define EGL_NATIVE_BUFFER_MULTIPLANE_SEPARATE_IMG 0x3105
#define EGL_NATIVE_BUFFER_PLANE_OFFSET_IMG 0x3106
#define EGL_CL_EVENT_HANDLE_KHR 0x309C
#define EGL_SYNC_CL_EVENT_KHR 0x30FE
#define EGL_SYNC_CL_EVENT_COMPLETE_KHR 0x30FF
#define EGL_CONFORMANT_KHR 0x3042
#define EGL_VG_COLORSPACE_LINEAR_BIT_KHR 0x0020
#define EGL_VG_ALPHA_FORMAT_PRE_BIT_KHR 0x0040
#define EGL_CONTEXT_RELEASE_BEHAVIOR_NONE_KHR 0
#define EGL_CONTEXT_RELEASE_BEHAVIOR_KHR 0x2097
#define EGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR 0x2098
#define EGL_CONTEXT_MAJOR_VERSION_KHR 0x3098
#define EGL_CONTEXT_MINOR_VERSION_KHR 0x30FB
#define EGL_CONTEXT_FLAGS_KHR 0x30FC
#define EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR 0x30FD
#define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR 0x31BD
#define EGL_NO_RESET_NOTIFICATION_KHR 0x31BE
#define EGL_LOSE_CONTEXT_ON_RESET_KHR 0x31BF
#define EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR 0x00000001
#define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR 0x00000002
#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR 0x00000004
#define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR 0x00000001
#define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR 0x00000002
#define EGL_OPENGL_ES3_BIT_KHR 0x00000040
#define EGL_CONTEXT_OPENGL_NO_ERROR_KHR 0x31B3
#define EGL_OBJECT_THREAD_KHR 0x33B0
#define EGL_OBJECT_DISPLAY_KHR 0x33B1
#define EGL_OBJECT_CONTEXT_KHR 0x33B2
#define EGL_OBJECT_SURFACE_KHR 0x33B3
#define EGL_OBJECT_IMAGE_KHR 0x33B4
#define EGL_OBJECT_SYNC_KHR 0x33B5
#define EGL_OBJECT_STREAM_KHR 0x33B6
#define EGL_DEBUG_MSG_CRITICAL_KHR 0x33B9
#define EGL_DEBUG_MSG_ERROR_KHR 0x33BA
#define EGL_DEBUG_MSG_WARN_KHR 0x33BB
#define EGL_DEBUG_MSG_INFO_KHR 0x33BC
#define EGL_DEBUG_CALLBACK_KHR 0x33B8
#define EGL_TRACK_REFERENCES_KHR 0x3352
#define EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR 0x30F0
#define EGL_SYNC_CONDITION_KHR 0x30F8
#define EGL_SYNC_FENCE_KHR 0x30F9
#define EGL_GL_COLORSPACE_KHR 0x309D
#define EGL_GL_COLORSPACE_SRGB_KHR 0x3089
#define EGL_GL_COLORSPACE_LINEAR_KHR 0x308A
#define EGL_GL_RENDERBUFFER_KHR 0x30B9
#define EGL_GL_TEXTURE_2D_KHR 0x30B1
#define EGL_GL_TEXTURE_LEVEL_KHR 0x30BC
#define EGL_GL_TEXTURE_3D_KHR 0x30B2
#define EGL_GL_TEXTURE_ZOFFSET_KHR 0x30BD
#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR 0x30B3
#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR 0x30B4
#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR 0x30B5
#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR 0x30B6
#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR 0x30B7
#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR 0x30B8
#define EGL_NATIVE_PIXMAP_KHR 0x30B0
#define EGL_NO_IMAGE_KHR EGL_CAST(EGLImageKHR,0)
#define EGL_IMAGE_PRESERVED_KHR 0x30D2
#define EGL_READ_SURFACE_BIT_KHR 0x0001
#define EGL_WRITE_SURFACE_BIT_KHR 0x0002
#define EGL_LOCK_SURFACE_BIT_KHR 0x0080
#define EGL_OPTIMAL_FORMAT_BIT_KHR 0x0100
#define EGL_MATCH_FORMAT_KHR 0x3043
#define EGL_FORMAT_RGB_565_EXACT_KHR 0x30C0
#define EGL_FORMAT_RGB_565_KHR 0x30C1
#define EGL_FORMAT_RGBA_8888_EXACT_KHR 0x30C2
#define EGL_FORMAT_RGBA_8888_KHR 0x30C3
#define EGL_MAP_PRESERVE_PIXELS_KHR 0x30C4
#define EGL_LOCK_USAGE_HINT_KHR 0x30C5
#define EGL_BITMAP_POINTER_KHR 0x30C6
#define EGL_BITMAP_PITCH_KHR 0x30C7
#define EGL_BITMAP_ORIGIN_KHR 0x30C8
#define EGL_BITMAP_PIXEL_RED_OFFSET_KHR 0x30C9
#define EGL_BITMAP_PIXEL_GREEN_OFFSET_KHR 0x30CA
#define EGL_BITMAP_PIXEL_BLUE_OFFSET_KHR 0x30CB
#define EGL_BITMAP_PIXEL_ALPHA_OFFSET_KHR 0x30CC
#define EGL_BITMAP_PIXEL_LUMINANCE_OFFSET_KHR 0x30CD
#define EGL_LOWER_LEFT_KHR 0x30CE
#define EGL_UPPER_LEFT_KHR 0x30CF
#define EGL_BITMAP_PIXEL_SIZE_KHR 0x3110
#define EGL_MUTABLE_RENDER_BUFFER_BIT_KHR 0x1000
#define EGL_NO_CONFIG_KHR EGL_CAST(EGLConfig,0)
#define EGL_BUFFER_AGE_KHR 0x313D
#define EGL_PLATFORM_ANDROID_KHR 0x3141
#define EGL_PLATFORM_GBM_KHR 0x31D7
#define EGL_PLATFORM_WAYLAND_KHR 0x31D8
#define EGL_PLATFORM_X11_KHR 0x31D5
#define EGL_PLATFORM_X11_SCREEN_KHR 0x31D6
#define EGL_SYNC_STATUS_KHR 0x30F1
#define EGL_SIGNALED_KHR 0x30F2
#define EGL_UNSIGNALED_KHR 0x30F3
#define EGL_TIMEOUT_EXPIRED_KHR 0x30F5
#define EGL_CONDITION_SATISFIED_KHR 0x30F6
#define EGL_SYNC_TYPE_KHR 0x30F7
#define EGL_SYNC_REUSABLE_KHR 0x30FA
#define EGL_SYNC_FLUSH_COMMANDS_BIT_KHR 0x0001
#define EGL_FOREVER_KHR 0xFFFFFFFFFFFFFFFF
#define EGL_NO_SYNC_KHR EGL_CAST(EGLSyncKHR,0)
#define EGL_NO_STREAM_KHR EGL_CAST(EGLStreamKHR,0)
#define EGL_CONSUMER_LATENCY_USEC_KHR 0x3210
#define EGL_PRODUCER_FRAME_KHR 0x3212
#define EGL_CONSUMER_FRAME_KHR 0x3213
#define EGL_STREAM_STATE_KHR 0x3214
#define EGL_STREAM_STATE_CREATED_KHR 0x3215
#define EGL_STREAM_STATE_CONNECTING_KHR 0x3216
#define EGL_STREAM_STATE_EMPTY_KHR 0x3217
#define EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR 0x3218
#define EGL_STREAM_STATE_OLD_FRAME_AVAILABLE_KHR 0x3219
#define EGL_STREAM_STATE_DISCONNECTED_KHR 0x321A
#define EGL_BAD_STREAM_KHR 0x321B
#define EGL_BAD_STATE_KHR 0x321C
#define EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR 0x321E
#define EGL_NO_FILE_DESCRIPTOR_KHR EGL_CAST(EGLNativeFileDescriptorKHR,-1)
#define EGL_STREAM_FIFO_LENGTH_KHR 0x31FC
#define EGL_STREAM_TIME_NOW_KHR 0x31FD
#define EGL_STREAM_TIME_CONSUMER_KHR 0x31FE
#define EGL_STREAM_TIME_PRODUCER_KHR 0x31FF
#define EGL_STREAM_BIT_KHR 0x0800
#define EGL_VG_PARENT_IMAGE_KHR 0x30BA
#define EGL_DRM_BUFFER_FORMAT_MESA 0x31D0
#define EGL_DRM_BUFFER_USE_MESA 0x31D1
#define EGL_DRM_BUFFER_FORMAT_ARGB32_MESA 0x31D2
#define EGL_DRM_BUFFER_MESA 0x31D3
#define EGL_DRM_BUFFER_STRIDE_MESA 0x31D4
#define EGL_DRM_BUFFER_USE_SCANOUT_MESA 0x00000001
#define EGL_DRM_BUFFER_USE_SHARE_MESA 0x00000002
#define EGL_DRM_BUFFER_USE_CURSOR_MESA 0x00000004
#define EGL_PLATFORM_GBM_MESA 0x31D7
#define EGL_PLATFORM_SURFACELESS_MESA 0x31DD
#define EGL_Y_INVERTED_NOK 0x307F
#define EGL_AUTO_STEREO_NV 0x3136
#define EGL_CONTEXT_PRIORITY_REALTIME_NV 0x3357
#define EGL_COVERAGE_BUFFERS_NV 0x30E0
#define EGL_COVERAGE_SAMPLES_NV 0x30E1
#define EGL_COVERAGE_SAMPLE_RESOLVE_NV 0x3131
#define EGL_COVERAGE_SAMPLE_RESOLVE_DEFAULT_NV 0x3132
#define EGL_COVERAGE_SAMPLE_RESOLVE_NONE_NV 0x3133
#define EGL_CUDA_EVENT_HANDLE_NV 0x323B
#define EGL_SYNC_CUDA_EVENT_NV 0x323C
#define EGL_SYNC_CUDA_EVENT_COMPLETE_NV 0x323D
#define EGL_DEPTH_ENCODING_NV 0x30E2
#define EGL_DEPTH_ENCODING_NONE_NV 0
#define EGL_DEPTH_ENCODING_NONLINEAR_NV 0x30E3
#define EGL_CUDA_DEVICE_NV 0x323A
#define EGL_POST_SUB_BUFFER_SUPPORTED_NV 0x30BE
#define EGL_GENERATE_RESET_ON_VIDEO_MEMORY_PURGE_NV 0x334C
#define EGL_YUV_PLANE0_TEXTURE_UNIT_NV 0x332C
#define EGL_YUV_PLANE1_TEXTURE_UNIT_NV 0x332D
#define EGL_YUV_PLANE2_TEXTURE_UNIT_NV 0x332E
#define EGL_STREAM_CROSS_DISPLAY_NV 0x334E
#define EGL_STREAM_CROSS_OBJECT_NV 0x334D
#define EGL_STREAM_CROSS_PARTITION_NV 0x323F
#define EGL_STREAM_CROSS_PROCESS_NV 0x3245
#define EGL_STREAM_CROSS_SYSTEM_NV 0x334F
#define EGL_PENDING_FRAME_NV 0x3329
#define EGL_STREAM_TIME_PENDING_NV 0x332A
#define EGL_STREAM_FIFO_SYNCHRONOUS_NV 0x3336
#define EGL_PRODUCER_MAX_FRAME_HINT_NV 0x3337
#define EGL_CONSUMER_MAX_FRAME_HINT_NV 0x3338
#define EGL_MAX_STREAM_METADATA_BLOCKS_NV 0x3250
#define EGL_MAX_STREAM_METADATA_BLOCK_SIZE_NV 0x3251
#define EGL_MAX_STREAM_METADATA_TOTAL_SIZE_NV 0x3252
#define EGL_PRODUCER_METADATA_NV 0x3253
#define EGL_CONSUMER_METADATA_NV 0x3254
#define EGL_PENDING_METADATA_NV 0x3328
#define EGL_METADATA0_SIZE_NV 0x3255
#define EGL_METADATA1_SIZE_NV 0x3256
#define EGL_METADATA2_SIZE_NV 0x3257
#define EGL_METADATA3_SIZE_NV 0x3258
#define EGL_METADATA0_TYPE_NV 0x3259
#define EGL_METADATA1_TYPE_NV 0x325A
#define EGL_METADATA2_TYPE_NV 0x325B
#define EGL_METADATA3_TYPE_NV 0x325C
#define EGL_STREAM_STATE_INITIALIZING_NV 0x3240
#define EGL_STREAM_TYPE_NV 0x3241
#define EGL_STREAM_PROTOCOL_NV 0x3242
#define EGL_STREAM_ENDPOINT_NV 0x3243
#define EGL_STREAM_LOCAL_NV 0x3244
#define EGL_STREAM_PRODUCER_NV 0x3247
#define EGL_STREAM_CONSUMER_NV 0x3248
#define EGL_STREAM_PROTOCOL_FD_NV 0x3246
#define EGL_SUPPORT_RESET_NV 0x3334
#define EGL_SUPPORT_REUSE_NV 0x3335
#define EGL_STREAM_PROTOCOL_SOCKET_NV 0x324B
#define EGL_SOCKET_HANDLE_NV 0x324C
#define EGL_SOCKET_TYPE_NV 0x324D
#define EGL_SOCKET_TYPE_INET_NV 0x324F
#define EGL_SOCKET_TYPE_UNIX_NV 0x324E
#define EGL_SYNC_NEW_FRAME_NV 0x321F
#define EGL_SYNC_PRIOR_COMMANDS_COMPLETE_NV 0x30E6
#define EGL_SYNC_STATUS_NV 0x30E7
#define EGL_SIGNALED_NV 0x30E8
#define EGL_UNSIGNALED_NV 0x30E9
#define EGL_SYNC_FLUSH_COMMANDS_BIT_NV 0x0001
#define EGL_FOREVER_NV 0xFFFFFFFFFFFFFFFF
#define EGL_ALREADY_SIGNALED_NV 0x30EA
#define EGL_TIMEOUT_EXPIRED_NV 0x30EB
#define EGL_CONDITION_SATISFIED_NV 0x30EC
#define EGL_SYNC_TYPE_NV 0x30ED
#define EGL_SYNC_CONDITION_NV 0x30EE
#define EGL_SYNC_FENCE_NV 0x30EF
#define EGL_NO_SYNC_NV EGL_CAST(EGLSyncNV,0)
#define EGL_NATIVE_BUFFER_TIZEN 0x32A0
#define EGL_NATIVE_SURFACE_TIZEN 0x32A1
#ifndef EGL_ANDROID_blob_cache
#define EGL_ANDROID_blob_cache 1
typedef void (APIENTRYP PFNEGLSETBLOBCACHEFUNCSANDROIDPROC)(EGLDisplay dpy, EGLSetBlobFuncANDROID set, EGLGetBlobFuncANDROID get);
GLAPI PFNEGLSETBLOBCACHEFUNCSANDROIDPROC glad_eglSetBlobCacheFuncsANDROID;
#define eglSetBlobCacheFuncsANDROID glad_eglSetBlobCacheFuncsANDROID
#endif
#ifndef EGL_ANDROID_create_native_client_buffer
#define EGL_ANDROID_create_native_client_buffer 1
typedef EGLClientBuffer (APIENTRYP PFNEGLCREATENATIVECLIENTBUFFERANDROIDPROC)(const EGLint *attrib_list);
GLAPI PFNEGLCREATENATIVECLIENTBUFFERANDROIDPROC glad_eglCreateNativeClientBufferANDROID;
#define eglCreateNativeClientBufferANDROID glad_eglCreateNativeClientBufferANDROID
#endif
#ifndef EGL_ANDROID_framebuffer_target
#define EGL_ANDROID_framebuffer_target 1
#endif
#ifndef EGL_ANDROID_front_buffer_auto_refresh
#define EGL_ANDROID_front_buffer_auto_refresh 1
#endif
#ifndef EGL_ANDROID_get_frame_timestamps
#define EGL_ANDROID_get_frame_timestamps 1
typedef EGLBoolean (APIENTRYP PFNEGLGETCOMPOSITORTIMINGSUPPORTEDANDROIDPROC)(EGLDisplay dpy, EGLSurface surface, EGLint name);
GLAPI PFNEGLGETCOMPOSITORTIMINGSUPPORTEDANDROIDPROC glad_eglGetCompositorTimingSupportedANDROID;
#define eglGetCompositorTimingSupportedANDROID glad_eglGetCompositorTimingSupportedANDROID
typedef EGLBoolean (APIENTRYP PFNEGLGETCOMPOSITORTIMINGANDROIDPROC)(EGLDisplay dpy, EGLSurface surface, EGLint numTimestamps, const EGLint *names, EGLnsecsANDROID *values);
GLAPI PFNEGLGETCOMPOSITORTIMINGANDROIDPROC glad_eglGetCompositorTimingANDROID;
#define eglGetCompositorTimingANDROID glad_eglGetCompositorTimingANDROID
typedef EGLBoolean (APIENTRYP PFNEGLGETNEXTFRAMEIDANDROIDPROC)(EGLDisplay dpy, EGLSurface surface, EGLuint64KHR *frameId);
GLAPI PFNEGLGETNEXTFRAMEIDANDROIDPROC glad_eglGetNextFrameIdANDROID;
#define eglGetNextFrameIdANDROID glad_eglGetNextFrameIdANDROID
typedef EGLBoolean (APIENTRYP PFNEGLGETFRAMETIMESTAMPSUPPORTEDANDROIDPROC)(EGLDisplay dpy, EGLSurface surface, EGLint timestamp);
GLAPI PFNEGLGETFRAMETIMESTAMPSUPPORTEDANDROIDPROC glad_eglGetFrameTimestampSupportedANDROID;
#define eglGetFrameTimestampSupportedANDROID glad_eglGetFrameTimestampSupportedANDROID
typedef EGLBoolean (APIENTRYP PFNEGLGETFRAMETIMESTAMPSANDROIDPROC)(EGLDisplay dpy, EGLSurface surface, EGLuint64KHR frameId, EGLint numTimestamps, const EGLint *timestamps, EGLnsecsANDROID *values);
GLAPI PFNEGLGETFRAMETIMESTAMPSANDROIDPROC glad_eglGetFrameTimestampsANDROID;
#define eglGetFrameTimestampsANDROID glad_eglGetFrameTimestampsANDROID
#endif
#ifndef EGL_ANDROID_get_native_client_buffer
#define EGL_ANDROID_get_native_client_buffer 1
typedef EGLClientBuffer (APIENTRYP PFNEGLGETNATIVECLIENTBUFFERANDROIDPROC)(const struct AHardwareBuffer *buffer);
GLAPI PFNEGLGETNATIVECLIENTBUFFERANDROIDPROC glad_eglGetNativeClientBufferANDROID;
#define eglGetNativeClientBufferANDROID glad_eglGetNativeClientBufferANDROID
#endif
#ifndef EGL_ANDROID_image_native_buffer
#define EGL_ANDROID_image_native_buffer 1
#endif
#ifndef EGL_ANDROID_native_fence_sync
#define EGL_ANDROID_native_fence_sync 1
typedef EGLint (APIENTRYP PFNEGLDUPNATIVEFENCEFDANDROIDPROC)(EGLDisplay dpy, EGLSyncKHR sync);
GLAPI PFNEGLDUPNATIVEFENCEFDANDROIDPROC glad_eglDupNativeFenceFDANDROID;
#define eglDupNativeFenceFDANDROID glad_eglDupNativeFenceFDANDROID
#endif
#ifndef EGL_ANDROID_presentation_time
#define EGL_ANDROID_presentation_time 1
typedef EGLBoolean (APIENTRYP PFNEGLPRESENTATIONTIMEANDROIDPROC)(EGLDisplay dpy, EGLSurface surface, EGLnsecsANDROID time);
GLAPI PFNEGLPRESENTATIONTIMEANDROIDPROC glad_eglPresentationTimeANDROID;
#define eglPresentationTimeANDROID glad_eglPresentationTimeANDROID
#endif
#ifndef EGL_ANDROID_recordable
#define EGL_ANDROID_recordable 1
#endif
#ifndef EGL_ANGLE_d3d_share_handle_client_buffer
#define EGL_ANGLE_d3d_share_handle_client_buffer 1
#endif
#ifndef EGL_ANGLE_device_d3d
#define EGL_ANGLE_device_d3d 1
#endif
#ifndef EGL_ANGLE_query_surface_pointer
#define EGL_ANGLE_query_surface_pointer 1
typedef EGLBoolean (APIENTRYP PFNEGLQUERYSURFACEPOINTERANGLEPROC)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, void **value);
GLAPI PFNEGLQUERYSURFACEPOINTERANGLEPROC glad_eglQuerySurfacePointerANGLE;
#define eglQuerySurfacePointerANGLE glad_eglQuerySurfacePointerANGLE
#endif
#ifndef EGL_ANGLE_surface_d3d_texture_2d_share_handle
#define EGL_ANGLE_surface_d3d_texture_2d_share_handle 1
#endif
#ifndef EGL_ANGLE_window_fixed_size
#define EGL_ANGLE_window_fixed_size 1
#endif
#ifndef EGL_ARM_implicit_external_sync
#define EGL_ARM_implicit_external_sync 1
#endif
#ifndef EGL_ARM_pixmap_multisample_discard
#define EGL_ARM_pixmap_multisample_discard 1
#endif
#ifndef EGL_EXT_bind_to_front
#define EGL_EXT_bind_to_front 1
#endif
#ifndef EGL_EXT_buffer_age
#define EGL_EXT_buffer_age 1
#endif
#ifndef EGL_EXT_client_extensions
#define EGL_EXT_client_extensions 1
#endif
#ifndef EGL_EXT_client_sync
#define EGL_EXT_client_sync 1
typedef EGLBoolean (APIENTRYP PFNEGLCLIENTSIGNALSYNCEXTPROC)(EGLDisplay dpy, EGLSync sync, const EGLAttrib *attrib_list);
GLAPI PFNEGLCLIENTSIGNALSYNCEXTPROC glad_eglClientSignalSyncEXT;
#define eglClientSignalSyncEXT glad_eglClientSignalSyncEXT
#endif
#ifndef EGL_EXT_compositor
#define EGL_EXT_compositor 1
typedef EGLBoolean (APIENTRYP PFNEGLCOMPOSITORSETCONTEXTLISTEXTPROC)(const EGLint *external_ref_ids, EGLint num_entries);
GLAPI PFNEGLCOMPOSITORSETCONTEXTLISTEXTPROC glad_eglCompositorSetContextListEXT;
#define eglCompositorSetContextListEXT glad_eglCompositorSetContextListEXT
typedef EGLBoolean (APIENTRYP PFNEGLCOMPOSITORSETCONTEXTATTRIBUTESEXTPROC)(EGLint external_ref_id, const EGLint *context_attributes, EGLint num_entries);
GLAPI PFNEGLCOMPOSITORSETCONTEXTATTRIBUTESEXTPROC glad_eglCompositorSetContextAttributesEXT;
#define eglCompositorSetContextAttributesEXT glad_eglCompositorSetContextAttributesEXT
typedef EGLBoolean (APIENTRYP PFNEGLCOMPOSITORSETWINDOWLISTEXTPROC)(EGLint external_ref_id, const EGLint *external_win_ids, EGLint num_entries);
GLAPI PFNEGLCOMPOSITORSETWINDOWLISTEXTPROC glad_eglCompositorSetWindowListEXT;
#define eglCompositorSetWindowListEXT glad_eglCompositorSetWindowListEXT
typedef EGLBoolean (APIENTRYP PFNEGLCOMPOSITORSETWINDOWATTRIBUTESEXTPROC)(EGLint external_win_id, const EGLint *window_attributes, EGLint num_entries);
GLAPI PFNEGLCOMPOSITORSETWINDOWATTRIBUTESEXTPROC glad_eglCompositorSetWindowAttributesEXT;
#define eglCompositorSetWindowAttributesEXT glad_eglCompositorSetWindowAttributesEXT
typedef EGLBoolean (APIENTRYP PFNEGLCOMPOSITORBINDTEXWINDOWEXTPROC)(EGLint external_win_id);
GLAPI PFNEGLCOMPOSITORBINDTEXWINDOWEXTPROC glad_eglCompositorBindTexWindowEXT;
#define eglCompositorBindTexWindowEXT glad_eglCompositorBindTexWindowEXT
typedef EGLBoolean (APIENTRYP PFNEGLCOMPOSITORSETSIZEEXTPROC)(EGLint external_win_id, EGLint width, EGLint height);
GLAPI PFNEGLCOMPOSITORSETSIZEEXTPROC glad_eglCompositorSetSizeEXT;
#define eglCompositorSetSizeEXT glad_eglCompositorSetSizeEXT
typedef EGLBoolean (APIENTRYP PFNEGLCOMPOSITORSWAPPOLICYEXTPROC)(EGLint external_win_id, EGLint policy);
GLAPI PFNEGLCOMPOSITORSWAPPOLICYEXTPROC glad_eglCompositorSwapPolicyEXT;
#define eglCompositorSwapPolicyEXT glad_eglCompositorSwapPolicyEXT
#endif
#ifndef EGL_EXT_create_context_robustness
#define EGL_EXT_create_context_robustness 1
#endif
#ifndef EGL_EXT_device_base
#define EGL_EXT_device_base 1
typedef EGLBoolean (APIENTRYP PFNEGLQUERYDEVICEATTRIBEXTPROC)(EGLDeviceEXT device, EGLint attribute, EGLAttrib *value);
GLAPI PFNEGLQUERYDEVICEATTRIBEXTPROC glad_eglQueryDeviceAttribEXT;
#define eglQueryDeviceAttribEXT glad_eglQueryDeviceAttribEXT
typedef const char * (APIENTRYP PFNEGLQUERYDEVICESTRINGEXTPROC)(EGLDeviceEXT device, EGLint name);
GLAPI PFNEGLQUERYDEVICESTRINGEXTPROC glad_eglQueryDeviceStringEXT;
#define eglQueryDeviceStringEXT glad_eglQueryDeviceStringEXT
typedef EGLBoolean (APIENTRYP PFNEGLQUERYDEVICESEXTPROC)(EGLint max_devices, EGLDeviceEXT *devices, EGLint *num_devices);
GLAPI PFNEGLQUERYDEVICESEXTPROC glad_eglQueryDevicesEXT;
#define eglQueryDevicesEXT glad_eglQueryDevicesEXT
typedef EGLBoolean (APIENTRYP PFNEGLQUERYDISPLAYATTRIBEXTPROC)(EGLDisplay dpy, EGLint attribute, EGLAttrib *value);
GLAPI PFNEGLQUERYDISPLAYATTRIBEXTPROC glad_eglQueryDisplayAttribEXT;
#define eglQueryDisplayAttribEXT glad_eglQueryDisplayAttribEXT
#endif
#ifndef EGL_EXT_device_drm
#define EGL_EXT_device_drm 1
#endif
#ifndef EGL_EXT_device_enumeration
#define EGL_EXT_device_enumeration 1
#endif
#ifndef EGL_EXT_device_openwf
#define EGL_EXT_device_openwf 1
#endif
#ifndef EGL_EXT_device_query
#define EGL_EXT_device_query 1
#endif
#ifndef EGL_EXT_gl_colorspace_bt2020_linear
#define EGL_EXT_gl_colorspace_bt2020_linear 1
#endif
#ifndef EGL_EXT_gl_colorspace_bt2020_pq
#define EGL_EXT_gl_colorspace_bt2020_pq 1
#endif
#ifndef EGL_EXT_gl_colorspace_display_p3
#define EGL_EXT_gl_colorspace_display_p3 1
#endif
#ifndef EGL_EXT_gl_colorspace_display_p3_linear
#define EGL_EXT_gl_colorspace_display_p3_linear 1
#endif
#ifndef EGL_EXT_gl_colorspace_display_p3_passthrough
#define EGL_EXT_gl_colorspace_display_p3_passthrough 1
#endif
#ifndef EGL_EXT_gl_colorspace_scrgb
#define EGL_EXT_gl_colorspace_scrgb 1
#endif
#ifndef EGL_EXT_gl_colorspace_scrgb_linear
#define EGL_EXT_gl_colorspace_scrgb_linear 1
#endif
#ifndef EGL_EXT_image_dma_buf_import
#define EGL_EXT_image_dma_buf_import 1
#endif
#ifndef EGL_EXT_image_dma_buf_import_modifiers
#define EGL_EXT_image_dma_buf_import_modifiers 1
typedef EGLBoolean (APIENTRYP PFNEGLQUERYDMABUFFORMATSEXTPROC)(EGLDisplay dpy, EGLint max_formats, EGLint *formats, EGLint *num_formats);
GLAPI PFNEGLQUERYDMABUFFORMATSEXTPROC glad_eglQueryDmaBufFormatsEXT;
#define eglQueryDmaBufFormatsEXT glad_eglQueryDmaBufFormatsEXT
typedef EGLBoolean (APIENTRYP PFNEGLQUERYDMABUFMODIFIERSEXTPROC)(EGLDisplay dpy, EGLint format, EGLint max_modifiers, EGLuint64KHR *modifiers, EGLBoolean *external_only, EGLint *num_modifiers);
GLAPI PFNEGLQUERYDMABUFMODIFIERSEXTPROC glad_eglQueryDmaBufModifiersEXT;
#define eglQueryDmaBufModifiersEXT glad_eglQueryDmaBufModifiersEXT
#endif
#ifndef EGL_EXT_image_gl_colorspace
#define EGL_EXT_image_gl_colorspace 1
#endif
#ifndef EGL_EXT_image_implicit_sync_control
#define EGL_EXT_image_implicit_sync_control 1
#endif
#ifndef EGL_EXT_multiview_window
#define EGL_EXT_multiview_window 1
#endif
#ifndef EGL_EXT_output_base
#define EGL_EXT_output_base 1
typedef EGLBoolean (APIENTRYP PFNEGLGETOUTPUTLAYERSEXTPROC)(EGLDisplay dpy, const EGLAttrib *attrib_list, EGLOutputLayerEXT *layers, EGLint max_layers, EGLint *num_layers);
GLAPI PFNEGLGETOUTPUTLAYERSEXTPROC glad_eglGetOutputLayersEXT;
#define eglGetOutputLayersEXT glad_eglGetOutputLayersEXT
typedef EGLBoolean (APIENTRYP PFNEGLGETOUTPUTPORTSEXTPROC)(EGLDisplay dpy, const EGLAttrib *attrib_list, EGLOutputPortEXT *ports, EGLint max_ports, EGLint *num_ports);
GLAPI PFNEGLGETOUTPUTPORTSEXTPROC glad_eglGetOutputPortsEXT;
#define eglGetOutputPortsEXT glad_eglGetOutputPortsEXT
typedef EGLBoolean (APIENTRYP PFNEGLOUTPUTLAYERATTRIBEXTPROC)(EGLDisplay dpy, EGLOutputLayerEXT layer, EGLint attribute, EGLAttrib value);
GLAPI PFNEGLOUTPUTLAYERATTRIBEXTPROC glad_eglOutputLayerAttribEXT;
#define eglOutputLayerAttribEXT glad_eglOutputLayerAttribEXT
typedef EGLBoolean (APIENTRYP PFNEGLQUERYOUTPUTLAYERATTRIBEXTPROC)(EGLDisplay dpy, EGLOutputLayerEXT layer, EGLint attribute, EGLAttrib *value);
GLAPI PFNEGLQUERYOUTPUTLAYERATTRIBEXTPROC glad_eglQueryOutputLayerAttribEXT;
#define eglQueryOutputLayerAttribEXT glad_eglQueryOutputLayerAttribEXT
typedef const char * (APIENTRYP PFNEGLQUERYOUTPUTLAYERSTRINGEXTPROC)(EGLDisplay dpy, EGLOutputLayerEXT layer, EGLint name);
GLAPI PFNEGLQUERYOUTPUTLAYERSTRINGEXTPROC glad_eglQueryOutputLayerStringEXT;
#define eglQueryOutputLayerStringEXT glad_eglQueryOutputLayerStringEXT
typedef EGLBoolean (APIENTRYP PFNEGLOUTPUTPORTATTRIBEXTPROC)(EGLDisplay dpy, EGLOutputPortEXT port, EGLint attribute, EGLAttrib value);
GLAPI PFNEGLOUTPUTPORTATTRIBEXTPROC glad_eglOutputPortAttribEXT;
#define eglOutputPortAttribEXT glad_eglOutputPortAttribEXT
typedef EGLBoolean (APIENTRYP PFNEGLQUERYOUTPUTPORTATTRIBEXTPROC)(EGLDisplay dpy, EGLOutputPortEXT port, EGLint attribute, EGLAttrib *value);
GLAPI PFNEGLQUERYOUTPUTPORTATTRIBEXTPROC glad_eglQueryOutputPortAttribEXT;
#define eglQueryOutputPortAttribEXT glad_eglQueryOutputPortAttribEXT
typedef const char * (APIENTRYP PFNEGLQUERYOUTPUTPORTSTRINGEXTPROC)(EGLDisplay dpy, EGLOutputPortEXT port, EGLint name);
GLAPI PFNEGLQUERYOUTPUTPORTSTRINGEXTPROC glad_eglQueryOutputPortStringEXT;
#define eglQueryOutputPortStringEXT glad_eglQueryOutputPortStringEXT
#endif
#ifndef EGL_EXT_output_drm
#define EGL_EXT_output_drm 1
#endif
#ifndef EGL_EXT_output_openwf
#define EGL_EXT_output_openwf 1
#endif
#ifndef EGL_EXT_pixel_format_float
#define EGL_EXT_pixel_format_float 1
#endif
#ifndef EGL_EXT_platform_base
#define EGL_EXT_platform_base 1
typedef EGLDisplay (APIENTRYP PFNEGLGETPLATFORMDISPLAYEXTPROC)(EGLenum platform, void *native_display, const EGLint *attrib_list);
GLAPI PFNEGLGETPLATFORMDISPLAYEXTPROC glad_eglGetPlatformDisplayEXT;
#define eglGetPlatformDisplayEXT glad_eglGetPlatformDisplayEXT
typedef EGLSurface (APIENTRYP PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC)(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLint *attrib_list);
GLAPI PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC glad_eglCreatePlatformWindowSurfaceEXT;
#define eglCreatePlatformWindowSurfaceEXT glad_eglCreatePlatformWindowSurfaceEXT
typedef EGLSurface (APIENTRYP PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC)(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLint *attrib_list);
GLAPI PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC glad_eglCreatePlatformPixmapSurfaceEXT;
#define eglCreatePlatformPixmapSurfaceEXT glad_eglCreatePlatformPixmapSurfaceEXT
#endif
#ifndef EGL_EXT_platform_device
#define EGL_EXT_platform_device 1
#endif
#ifndef EGL_EXT_platform_wayland
#define EGL_EXT_platform_wayland 1
#endif
#ifndef EGL_EXT_platform_x11
#define EGL_EXT_platform_x11 1
#endif
#ifndef EGL_EXT_protected_content
#define EGL_EXT_protected_content 1
#endif
#ifndef EGL_EXT_protected_surface
#define EGL_EXT_protected_surface 1
#endif
#ifndef EGL_EXT_stream_consumer_egloutput
#define EGL_EXT_stream_consumer_egloutput 1
typedef EGLBoolean (APIENTRYP PFNEGLSTREAMCONSUMEROUTPUTEXTPROC)(EGLDisplay dpy, EGLStreamKHR stream, EGLOutputLayerEXT layer);
GLAPI PFNEGLSTREAMCONSUMEROUTPUTEXTPROC glad_eglStreamConsumerOutputEXT;
#define eglStreamConsumerOutputEXT glad_eglStreamConsumerOutputEXT
#endif
#ifndef EGL_EXT_surface_CTA861_3_metadata
#define EGL_EXT_surface_CTA861_3_metadata 1
#endif
#ifndef EGL_EXT_surface_SMPTE2086_metadata
#define EGL_EXT_surface_SMPTE2086_metadata 1
#endif
#ifndef EGL_EXT_swap_buffers_with_damage
#define EGL_EXT_swap_buffers_with_damage 1
typedef EGLBoolean (APIENTRYP PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC)(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
GLAPI PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC glad_eglSwapBuffersWithDamageEXT;
#define eglSwapBuffersWithDamageEXT glad_eglSwapBuffersWithDamageEXT
#endif
#ifndef EGL_EXT_sync_reuse
#define EGL_EXT_sync_reuse 1
typedef EGLBoolean (APIENTRYP PFNEGLUNSIGNALSYNCEXTPROC)(EGLDisplay dpy, EGLSync sync, const EGLAttrib *attrib_list);
GLAPI PFNEGLUNSIGNALSYNCEXTPROC glad_eglUnsignalSyncEXT;
#define eglUnsignalSyncEXT glad_eglUnsignalSyncEXT
#endif
#ifndef EGL_EXT_yuv_surface
#define EGL_EXT_yuv_surface 1
#endif
#ifndef EGL_HI_clientpixmap
#define EGL_HI_clientpixmap 1
typedef EGLSurface (APIENTRYP PFNEGLCREATEPIXMAPSURFACEHIPROC)(EGLDisplay dpy, EGLConfig config, struct EGLClientPixmapHI *pixmap);
GLAPI PFNEGLCREATEPIXMAPSURFACEHIPROC glad_eglCreatePixmapSurfaceHI;
#define eglCreatePixmapSurfaceHI glad_eglCreatePixmapSurfaceHI
#endif
#ifndef EGL_HI_colorformats
#define EGL_HI_colorformats 1
#endif
#ifndef EGL_IMG_context_priority
#define EGL_IMG_context_priority 1
#endif
#ifndef EGL_IMG_image_plane_attribs
#define EGL_IMG_image_plane_attribs 1
#endif
#ifndef EGL_KHR_cl_event
#define EGL_KHR_cl_event 1
#endif
#ifndef EGL_KHR_cl_event2
#define EGL_KHR_cl_event2 1
typedef EGLSyncKHR (APIENTRYP PFNEGLCREATESYNC64KHRPROC)(EGLDisplay dpy, EGLenum type, const EGLAttribKHR *attrib_list);
GLAPI PFNEGLCREATESYNC64KHRPROC glad_eglCreateSync64KHR;
#define eglCreateSync64KHR glad_eglCreateSync64KHR
#endif
#ifndef EGL_KHR_client_get_all_proc_addresses
#define EGL_KHR_client_get_all_proc_addresses 1
#endif
#ifndef EGL_KHR_config_attribs
#define EGL_KHR_config_attribs 1
#endif
#ifndef EGL_KHR_context_flush_control
#define EGL_KHR_context_flush_control 1
#endif
#ifndef EGL_KHR_create_context
#define EGL_KHR_create_context 1
#endif
#ifndef EGL_KHR_create_context_no_error
#define EGL_KHR_create_context_no_error 1
#endif
#ifndef EGL_KHR_debug
#define EGL_KHR_debug 1
typedef EGLint (APIENTRYP PFNEGLDEBUGMESSAGECONTROLKHRPROC)(EGLDEBUGPROCKHR callback, const EGLAttrib *attrib_list);
GLAPI PFNEGLDEBUGMESSAGECONTROLKHRPROC glad_eglDebugMessageControlKHR;
#define eglDebugMessageControlKHR glad_eglDebugMessageControlKHR
typedef EGLBoolean (APIENTRYP PFNEGLQUERYDEBUGKHRPROC)(EGLint attribute, EGLAttrib *value);
GLAPI PFNEGLQUERYDEBUGKHRPROC glad_eglQueryDebugKHR;
#define eglQueryDebugKHR glad_eglQueryDebugKHR
typedef EGLint (APIENTRYP PFNEGLLABELOBJECTKHRPROC)(EGLDisplay display, EGLenum objectType, EGLObjectKHR object, EGLLabelKHR label);
GLAPI PFNEGLLABELOBJECTKHRPROC glad_eglLabelObjectKHR;
#define eglLabelObjectKHR glad_eglLabelObjectKHR
#endif
#ifndef EGL_KHR_display_reference
#define EGL_KHR_display_reference 1
typedef EGLBoolean (APIENTRYP PFNEGLQUERYDISPLAYATTRIBKHRPROC)(EGLDisplay dpy, EGLint name, EGLAttrib *value);
GLAPI PFNEGLQUERYDISPLAYATTRIBKHRPROC glad_eglQueryDisplayAttribKHR;
#define eglQueryDisplayAttribKHR glad_eglQueryDisplayAttribKHR
#endif
#ifndef EGL_KHR_fence_sync
#define EGL_KHR_fence_sync 1
typedef EGLSyncKHR (APIENTRYP PFNEGLCREATESYNCKHRPROC)(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list);
GLAPI PFNEGLCREATESYNCKHRPROC glad_eglCreateSyncKHR;
#define eglCreateSyncKHR glad_eglCreateSyncKHR
typedef EGLBoolean (APIENTRYP PFNEGLDESTROYSYNCKHRPROC)(EGLDisplay dpy, EGLSyncKHR sync);
GLAPI PFNEGLDESTROYSYNCKHRPROC glad_eglDestroySyncKHR;
#define eglDestroySyncKHR glad_eglDestroySyncKHR
typedef EGLint (APIENTRYP PFNEGLCLIENTWAITSYNCKHRPROC)(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout);
GLAPI PFNEGLCLIENTWAITSYNCKHRPROC glad_eglClientWaitSyncKHR;
#define eglClientWaitSyncKHR glad_eglClientWaitSyncKHR
typedef EGLBoolean (APIENTRYP PFNEGLGETSYNCATTRIBKHRPROC)(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value);
GLAPI PFNEGLGETSYNCATTRIBKHRPROC glad_eglGetSyncAttribKHR;
#define eglGetSyncAttribKHR glad_eglGetSyncAttribKHR
#endif
#ifndef EGL_KHR_get_all_proc_addresses
#define EGL_KHR_get_all_proc_addresses 1
#endif
#ifndef EGL_KHR_gl_colorspace
#define EGL_KHR_gl_colorspace 1
#endif
#ifndef EGL_KHR_gl_renderbuffer_image
#define EGL_KHR_gl_renderbuffer_image 1
#endif
#ifndef EGL_KHR_gl_texture_2D_image
#define EGL_KHR_gl_texture_2D_image 1
#endif
#ifndef EGL_KHR_gl_texture_3D_image
#define EGL_KHR_gl_texture_3D_image 1
#endif
#ifndef EGL_KHR_gl_texture_cubemap_image
#define EGL_KHR_gl_texture_cubemap_image 1
#endif
#ifndef EGL_KHR_image
#define EGL_KHR_image 1
typedef EGLImageKHR (APIENTRYP PFNEGLCREATEIMAGEKHRPROC)(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list);
GLAPI PFNEGLCREATEIMAGEKHRPROC glad_eglCreateImageKHR;
#define eglCreateImageKHR glad_eglCreateImageKHR
typedef EGLBoolean (APIENTRYP PFNEGLDESTROYIMAGEKHRPROC)(EGLDisplay dpy, EGLImageKHR image);
GLAPI PFNEGLDESTROYIMAGEKHRPROC glad_eglDestroyImageKHR;
#define eglDestroyImageKHR glad_eglDestroyImageKHR
#endif
#ifndef EGL_KHR_image_base
#define EGL_KHR_image_base 1
#endif
#ifndef EGL_KHR_image_pixmap
#define EGL_KHR_image_pixmap 1
#endif
#ifndef EGL_KHR_lock_surface
#define EGL_KHR_lock_surface 1
typedef EGLBoolean (APIENTRYP PFNEGLLOCKSURFACEKHRPROC)(EGLDisplay dpy, EGLSurface surface, const EGLint *attrib_list);
GLAPI PFNEGLLOCKSURFACEKHRPROC glad_eglLockSurfaceKHR;
#define eglLockSurfaceKHR glad_eglLockSurfaceKHR
typedef EGLBoolean (APIENTRYP PFNEGLUNLOCKSURFACEKHRPROC)(EGLDisplay dpy, EGLSurface surface);
GLAPI PFNEGLUNLOCKSURFACEKHRPROC glad_eglUnlockSurfaceKHR;
#define eglUnlockSurfaceKHR glad_eglUnlockSurfaceKHR
#endif
#ifndef EGL_KHR_lock_surface2
#define EGL_KHR_lock_surface2 1
#endif
#ifndef EGL_KHR_lock_surface3
#define EGL_KHR_lock_surface3 1
typedef EGLBoolean (APIENTRYP PFNEGLQUERYSURFACE64KHRPROC)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLAttribKHR *value);
GLAPI PFNEGLQUERYSURFACE64KHRPROC glad_eglQuerySurface64KHR;
#define eglQuerySurface64KHR glad_eglQuerySurface64KHR
#endif
#ifndef EGL_KHR_mutable_render_buffer
#define EGL_KHR_mutable_render_buffer 1
#endif
#ifndef EGL_KHR_no_config_context
#define EGL_KHR_no_config_context 1
#endif
#ifndef EGL_KHR_partial_update
#define EGL_KHR_partial_update 1
typedef EGLBoolean (APIENTRYP PFNEGLSETDAMAGEREGIONKHRPROC)(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
GLAPI PFNEGLSETDAMAGEREGIONKHRPROC glad_eglSetDamageRegionKHR;
#define eglSetDamageRegionKHR glad_eglSetDamageRegionKHR
#endif
#ifndef EGL_KHR_platform_android
#define EGL_KHR_platform_android 1
#endif
#ifndef EGL_KHR_platform_gbm
#define EGL_KHR_platform_gbm 1
#endif
#ifndef EGL_KHR_platform_wayland
#define EGL_KHR_platform_wayland 1
#endif
#ifndef EGL_KHR_platform_x11
#define EGL_KHR_platform_x11 1
#endif
#ifndef EGL_KHR_reusable_sync
#define EGL_KHR_reusable_sync 1
typedef EGLBoolean (APIENTRYP PFNEGLSIGNALSYNCKHRPROC)(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode);
GLAPI PFNEGLSIGNALSYNCKHRPROC glad_eglSignalSyncKHR;
#define eglSignalSyncKHR glad_eglSignalSyncKHR
#endif
#ifndef EGL_KHR_stream
#define EGL_KHR_stream 1
typedef EGLStreamKHR (APIENTRYP PFNEGLCREATESTREAMKHRPROC)(EGLDisplay dpy, const EGLint *attrib_list);
GLAPI PFNEGLCREATESTREAMKHRPROC glad_eglCreateStreamKHR;
#define eglCreateStreamKHR glad_eglCreateStreamKHR
typedef EGLBoolean (APIENTRYP PFNEGLDESTROYSTREAMKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream);
GLAPI PFNEGLDESTROYSTREAMKHRPROC glad_eglDestroyStreamKHR;
#define eglDestroyStreamKHR glad_eglDestroyStreamKHR
typedef EGLBoolean (APIENTRYP PFNEGLSTREAMATTRIBKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint value);
GLAPI PFNEGLSTREAMATTRIBKHRPROC glad_eglStreamAttribKHR;
#define eglStreamAttribKHR glad_eglStreamAttribKHR
typedef EGLBoolean (APIENTRYP PFNEGLQUERYSTREAMKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint *value);
GLAPI PFNEGLQUERYSTREAMKHRPROC glad_eglQueryStreamKHR;
#define eglQueryStreamKHR glad_eglQueryStreamKHR
typedef EGLBoolean (APIENTRYP PFNEGLQUERYSTREAMU64KHRPROC)(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLuint64KHR *value);
GLAPI PFNEGLQUERYSTREAMU64KHRPROC glad_eglQueryStreamu64KHR;
#define eglQueryStreamu64KHR glad_eglQueryStreamu64KHR
#endif
#ifndef EGL_KHR_stream_attrib
#define EGL_KHR_stream_attrib 1
typedef EGLStreamKHR (APIENTRYP PFNEGLCREATESTREAMATTRIBKHRPROC)(EGLDisplay dpy, const EGLAttrib *attrib_list);
GLAPI PFNEGLCREATESTREAMATTRIBKHRPROC glad_eglCreateStreamAttribKHR;
#define eglCreateStreamAttribKHR glad_eglCreateStreamAttribKHR
typedef EGLBoolean (APIENTRYP PFNEGLSETSTREAMATTRIBKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLAttrib value);
GLAPI PFNEGLSETSTREAMATTRIBKHRPROC glad_eglSetStreamAttribKHR;
#define eglSetStreamAttribKHR glad_eglSetStreamAttribKHR
typedef EGLBoolean (APIENTRYP PFNEGLQUERYSTREAMATTRIBKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLAttrib *value);
GLAPI PFNEGLQUERYSTREAMATTRIBKHRPROC glad_eglQueryStreamAttribKHR;
#define eglQueryStreamAttribKHR glad_eglQueryStreamAttribKHR
typedef EGLBoolean (APIENTRYP PFNEGLSTREAMCONSUMERACQUIREATTRIBKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib *attrib_list);
GLAPI PFNEGLSTREAMCONSUMERACQUIREATTRIBKHRPROC glad_eglStreamConsumerAcquireAttribKHR;
#define eglStreamConsumerAcquireAttribKHR glad_eglStreamConsumerAcquireAttribKHR
typedef EGLBoolean (APIENTRYP PFNEGLSTREAMCONSUMERRELEASEATTRIBKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib *attrib_list);
GLAPI PFNEGLSTREAMCONSUMERRELEASEATTRIBKHRPROC glad_eglStreamConsumerReleaseAttribKHR;
#define eglStreamConsumerReleaseAttribKHR glad_eglStreamConsumerReleaseAttribKHR
#endif
#ifndef EGL_KHR_stream_consumer_gltexture
#define EGL_KHR_stream_consumer_gltexture 1
typedef EGLBoolean (APIENTRYP PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream);
GLAPI PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC glad_eglStreamConsumerGLTextureExternalKHR;
#define eglStreamConsumerGLTextureExternalKHR glad_eglStreamConsumerGLTextureExternalKHR
typedef EGLBoolean (APIENTRYP PFNEGLSTREAMCONSUMERACQUIREKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream);
GLAPI PFNEGLSTREAMCONSUMERACQUIREKHRPROC glad_eglStreamConsumerAcquireKHR;
#define eglStreamConsumerAcquireKHR glad_eglStreamConsumerAcquireKHR
typedef EGLBoolean (APIENTRYP PFNEGLSTREAMCONSUMERRELEASEKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream);
GLAPI PFNEGLSTREAMCONSUMERRELEASEKHRPROC glad_eglStreamConsumerReleaseKHR;
#define eglStreamConsumerReleaseKHR glad_eglStreamConsumerReleaseKHR
#endif
#ifndef EGL_KHR_stream_cross_process_fd
#define EGL_KHR_stream_cross_process_fd 1
typedef EGLNativeFileDescriptorKHR (APIENTRYP PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream);
GLAPI PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC glad_eglGetStreamFileDescriptorKHR;
#define eglGetStreamFileDescriptorKHR glad_eglGetStreamFileDescriptorKHR
typedef EGLStreamKHR (APIENTRYP PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC)(EGLDisplay dpy, EGLNativeFileDescriptorKHR file_descriptor);
GLAPI PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC glad_eglCreateStreamFromFileDescriptorKHR;
#define eglCreateStreamFromFileDescriptorKHR glad_eglCreateStreamFromFileDescriptorKHR
#endif
#ifndef EGL_KHR_stream_fifo
#define EGL_KHR_stream_fifo 1
typedef EGLBoolean (APIENTRYP PFNEGLQUERYSTREAMTIMEKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLTimeKHR *value);
GLAPI PFNEGLQUERYSTREAMTIMEKHRPROC glad_eglQueryStreamTimeKHR;
#define eglQueryStreamTimeKHR glad_eglQueryStreamTimeKHR
#endif
#ifndef EGL_KHR_stream_producer_aldatalocator
#define EGL_KHR_stream_producer_aldatalocator 1
#endif
#ifndef EGL_KHR_stream_producer_eglsurface
#define EGL_KHR_stream_producer_eglsurface 1
typedef EGLSurface (APIENTRYP PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC)(EGLDisplay dpy, EGLConfig config, EGLStreamKHR stream, const EGLint *attrib_list);
GLAPI PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC glad_eglCreateStreamProducerSurfaceKHR;
#define eglCreateStreamProducerSurfaceKHR glad_eglCreateStreamProducerSurfaceKHR
#endif
#ifndef EGL_KHR_surfaceless_context
#define EGL_KHR_surfaceless_context 1
#endif
#ifndef EGL_KHR_swap_buffers_with_damage
#define EGL_KHR_swap_buffers_with_damage 1
typedef EGLBoolean (APIENTRYP PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC)(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
GLAPI PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC glad_eglSwapBuffersWithDamageKHR;
#define eglSwapBuffersWithDamageKHR glad_eglSwapBuffersWithDamageKHR
#endif
#ifndef EGL_KHR_vg_parent_image
#define EGL_KHR_vg_parent_image 1
#endif
#ifndef EGL_KHR_wait_sync
#define EGL_KHR_wait_sync 1
typedef EGLint (APIENTRYP PFNEGLWAITSYNCKHRPROC)(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags);
GLAPI PFNEGLWAITSYNCKHRPROC glad_eglWaitSyncKHR;
#define eglWaitSyncKHR glad_eglWaitSyncKHR
#endif
#ifndef EGL_MESA_drm_image
#define EGL_MESA_drm_image 1
typedef EGLImageKHR (APIENTRYP PFNEGLCREATEDRMIMAGEMESAPROC)(EGLDisplay dpy, const EGLint *attrib_list);
GLAPI PFNEGLCREATEDRMIMAGEMESAPROC glad_eglCreateDRMImageMESA;
#define eglCreateDRMImageMESA glad_eglCreateDRMImageMESA
typedef EGLBoolean (APIENTRYP PFNEGLEXPORTDRMIMAGEMESAPROC)(EGLDisplay dpy, EGLImageKHR image, EGLint *name, EGLint *handle, EGLint *stride);
GLAPI PFNEGLEXPORTDRMIMAGEMESAPROC glad_eglExportDRMImageMESA;
#define eglExportDRMImageMESA glad_eglExportDRMImageMESA
#endif
#ifndef EGL_MESA_image_dma_buf_export
#define EGL_MESA_image_dma_buf_export 1
typedef EGLBoolean (APIENTRYP PFNEGLEXPORTDMABUFIMAGEQUERYMESAPROC)(EGLDisplay dpy, EGLImageKHR image, int *fourcc, int *num_planes, EGLuint64KHR *modifiers);
GLAPI PFNEGLEXPORTDMABUFIMAGEQUERYMESAPROC glad_eglExportDMABUFImageQueryMESA;
#define eglExportDMABUFImageQueryMESA glad_eglExportDMABUFImageQueryMESA
typedef EGLBoolean (APIENTRYP PFNEGLEXPORTDMABUFIMAGEMESAPROC)(EGLDisplay dpy, EGLImageKHR image, int *fds, EGLint *strides, EGLint *offsets);
GLAPI PFNEGLEXPORTDMABUFIMAGEMESAPROC glad_eglExportDMABUFImageMESA;
#define eglExportDMABUFImageMESA glad_eglExportDMABUFImageMESA
#endif
#ifndef EGL_MESA_platform_gbm
#define EGL_MESA_platform_gbm 1
#endif
#ifndef EGL_MESA_platform_surfaceless
#define EGL_MESA_platform_surfaceless 1
#endif
#ifndef EGL_NOK_swap_region
#define EGL_NOK_swap_region 1
typedef EGLBoolean (APIENTRYP PFNEGLSWAPBUFFERSREGIONNOKPROC)(EGLDisplay dpy, EGLSurface surface, EGLint numRects, const EGLint *rects);
GLAPI PFNEGLSWAPBUFFERSREGIONNOKPROC glad_eglSwapBuffersRegionNOK;
#define eglSwapBuffersRegionNOK glad_eglSwapBuffersRegionNOK
#endif
#ifndef EGL_NOK_swap_region2
#define EGL_NOK_swap_region2 1
typedef EGLBoolean (APIENTRYP PFNEGLSWAPBUFFERSREGION2NOKPROC)(EGLDisplay dpy, EGLSurface surface, EGLint numRects, const EGLint *rects);
GLAPI PFNEGLSWAPBUFFERSREGION2NOKPROC glad_eglSwapBuffersRegion2NOK;
#define eglSwapBuffersRegion2NOK glad_eglSwapBuffersRegion2NOK
#endif
#ifndef EGL_NOK_texture_from_pixmap
#define EGL_NOK_texture_from_pixmap 1
#endif
#ifndef EGL_NV_3dvision_surface
#define EGL_NV_3dvision_surface 1
#endif
#ifndef EGL_NV_context_priority_realtime
#define EGL_NV_context_priority_realtime 1
#endif
#ifndef EGL_NV_coverage_sample
#define EGL_NV_coverage_sample 1
#endif
#ifndef EGL_NV_coverage_sample_resolve
#define EGL_NV_coverage_sample_resolve 1
#endif
#ifndef EGL_NV_cuda_event
#define EGL_NV_cuda_event 1
#endif
#ifndef EGL_NV_depth_nonlinear
#define EGL_NV_depth_nonlinear 1
#endif
#ifndef EGL_NV_device_cuda
#define EGL_NV_device_cuda 1
#endif
#ifndef EGL_NV_native_query
#define EGL_NV_native_query 1
typedef EGLBoolean (APIENTRYP PFNEGLQUERYNATIVEDISPLAYNVPROC)(EGLDisplay dpy, EGLNativeDisplayType *display_id);
GLAPI PFNEGLQUERYNATIVEDISPLAYNVPROC glad_eglQueryNativeDisplayNV;
#define eglQueryNativeDisplayNV glad_eglQueryNativeDisplayNV
typedef EGLBoolean (APIENTRYP PFNEGLQUERYNATIVEWINDOWNVPROC)(EGLDisplay dpy, EGLSurface surf, EGLNativeWindowType *window);
GLAPI PFNEGLQUERYNATIVEWINDOWNVPROC glad_eglQueryNativeWindowNV;
#define eglQueryNativeWindowNV glad_eglQueryNativeWindowNV
typedef EGLBoolean (APIENTRYP PFNEGLQUERYNATIVEPIXMAPNVPROC)(EGLDisplay dpy, EGLSurface surf, EGLNativePixmapType *pixmap);
GLAPI PFNEGLQUERYNATIVEPIXMAPNVPROC glad_eglQueryNativePixmapNV;
#define eglQueryNativePixmapNV glad_eglQueryNativePixmapNV
#endif
#ifndef EGL_NV_post_convert_rounding
#define EGL_NV_post_convert_rounding 1
#endif
#ifndef EGL_NV_post_sub_buffer
#define EGL_NV_post_sub_buffer 1
typedef EGLBoolean (APIENTRYP PFNEGLPOSTSUBBUFFERNVPROC)(EGLDisplay dpy, EGLSurface surface, EGLint x, EGLint y, EGLint width, EGLint height);
GLAPI PFNEGLPOSTSUBBUFFERNVPROC glad_eglPostSubBufferNV;
#define eglPostSubBufferNV glad_eglPostSubBufferNV
#endif
#ifndef EGL_NV_robustness_video_memory_purge
#define EGL_NV_robustness_video_memory_purge 1
#endif
#ifndef EGL_NV_stream_consumer_gltexture_yuv
#define EGL_NV_stream_consumer_gltexture_yuv 1
typedef EGLBoolean (APIENTRYP PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC)(EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib *attrib_list);
GLAPI PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC glad_eglStreamConsumerGLTextureExternalAttribsNV;
#define eglStreamConsumerGLTextureExternalAttribsNV glad_eglStreamConsumerGLTextureExternalAttribsNV
#endif
#ifndef EGL_NV_stream_cross_display
#define EGL_NV_stream_cross_display 1
#endif
#ifndef EGL_NV_stream_cross_object
#define EGL_NV_stream_cross_object 1
#endif
#ifndef EGL_NV_stream_cross_partition
#define EGL_NV_stream_cross_partition 1
#endif
#ifndef EGL_NV_stream_cross_process
#define EGL_NV_stream_cross_process 1
#endif
#ifndef EGL_NV_stream_cross_system
#define EGL_NV_stream_cross_system 1
#endif
#ifndef EGL_NV_stream_fifo_next
#define EGL_NV_stream_fifo_next 1
#endif
#ifndef EGL_NV_stream_fifo_synchronous
#define EGL_NV_stream_fifo_synchronous 1
#endif
#ifndef EGL_NV_stream_flush
#define EGL_NV_stream_flush 1
typedef EGLBoolean (APIENTRYP PFNEGLSTREAMFLUSHNVPROC)(EGLDisplay dpy, EGLStreamKHR stream);
GLAPI PFNEGLSTREAMFLUSHNVPROC glad_eglStreamFlushNV;
#define eglStreamFlushNV glad_eglStreamFlushNV
#endif
#ifndef EGL_NV_stream_frame_limits
#define EGL_NV_stream_frame_limits 1
#endif
#ifndef EGL_NV_stream_metadata
#define EGL_NV_stream_metadata 1
typedef EGLBoolean (APIENTRYP PFNEGLQUERYDISPLAYATTRIBNVPROC)(EGLDisplay dpy, EGLint attribute, EGLAttrib *value);
GLAPI PFNEGLQUERYDISPLAYATTRIBNVPROC glad_eglQueryDisplayAttribNV;
#define eglQueryDisplayAttribNV glad_eglQueryDisplayAttribNV
typedef EGLBoolean (APIENTRYP PFNEGLSETSTREAMMETADATANVPROC)(EGLDisplay dpy, EGLStreamKHR stream, EGLint n, EGLint offset, EGLint size, const void *data);
GLAPI PFNEGLSETSTREAMMETADATANVPROC glad_eglSetStreamMetadataNV;
#define eglSetStreamMetadataNV glad_eglSetStreamMetadataNV
typedef EGLBoolean (APIENTRYP PFNEGLQUERYSTREAMMETADATANVPROC)(EGLDisplay dpy, EGLStreamKHR stream, EGLenum name, EGLint n, EGLint offset, EGLint size, void *data);
GLAPI PFNEGLQUERYSTREAMMETADATANVPROC glad_eglQueryStreamMetadataNV;
#define eglQueryStreamMetadataNV glad_eglQueryStreamMetadataNV
#endif
#ifndef EGL_NV_stream_remote
#define EGL_NV_stream_remote 1
#endif
#ifndef EGL_NV_stream_reset
#define EGL_NV_stream_reset 1
typedef EGLBoolean (APIENTRYP PFNEGLRESETSTREAMNVPROC)(EGLDisplay dpy, EGLStreamKHR stream);
GLAPI PFNEGLRESETSTREAMNVPROC glad_eglResetStreamNV;
#define eglResetStreamNV glad_eglResetStreamNV
#endif
#ifndef EGL_NV_stream_socket
#define EGL_NV_stream_socket 1
#endif
#ifndef EGL_NV_stream_socket_inet
#define EGL_NV_stream_socket_inet 1
#endif
#ifndef EGL_NV_stream_socket_unix
#define EGL_NV_stream_socket_unix 1
#endif
#ifndef EGL_NV_stream_sync
#define EGL_NV_stream_sync 1
typedef EGLSyncKHR (APIENTRYP PFNEGLCREATESTREAMSYNCNVPROC)(EGLDisplay dpy, EGLStreamKHR stream, EGLenum type, const EGLint *attrib_list);
GLAPI PFNEGLCREATESTREAMSYNCNVPROC glad_eglCreateStreamSyncNV;
#define eglCreateStreamSyncNV glad_eglCreateStreamSyncNV
#endif
#ifndef EGL_NV_sync
#define EGL_NV_sync 1
typedef EGLSyncNV (APIENTRYP PFNEGLCREATEFENCESYNCNVPROC)(EGLDisplay dpy, EGLenum condition, const EGLint *attrib_list);
GLAPI PFNEGLCREATEFENCESYNCNVPROC glad_eglCreateFenceSyncNV;
#define eglCreateFenceSyncNV glad_eglCreateFenceSyncNV
typedef EGLBoolean (APIENTRYP PFNEGLDESTROYSYNCNVPROC)(EGLSyncNV sync);
GLAPI PFNEGLDESTROYSYNCNVPROC glad_eglDestroySyncNV;
#define eglDestroySyncNV glad_eglDestroySyncNV
typedef EGLBoolean (APIENTRYP PFNEGLFENCENVPROC)(EGLSyncNV sync);
GLAPI PFNEGLFENCENVPROC glad_eglFenceNV;
#define eglFenceNV glad_eglFenceNV
typedef EGLint (APIENTRYP PFNEGLCLIENTWAITSYNCNVPROC)(EGLSyncNV sync, EGLint flags, EGLTimeNV timeout);
GLAPI PFNEGLCLIENTWAITSYNCNVPROC glad_eglClientWaitSyncNV;
#define eglClientWaitSyncNV glad_eglClientWaitSyncNV
typedef EGLBoolean (APIENTRYP PFNEGLSIGNALSYNCNVPROC)(EGLSyncNV sync, EGLenum mode);
GLAPI PFNEGLSIGNALSYNCNVPROC glad_eglSignalSyncNV;
#define eglSignalSyncNV glad_eglSignalSyncNV
typedef EGLBoolean (APIENTRYP PFNEGLGETSYNCATTRIBNVPROC)(EGLSyncNV sync, EGLint attribute, EGLint *value);
GLAPI PFNEGLGETSYNCATTRIBNVPROC glad_eglGetSyncAttribNV;
#define eglGetSyncAttribNV glad_eglGetSyncAttribNV
#endif
#ifndef EGL_NV_system_time
#define EGL_NV_system_time 1
typedef EGLuint64NV (APIENTRYP PFNEGLGETSYSTEMTIMEFREQUENCYNVPROC)(void);
GLAPI PFNEGLGETSYSTEMTIMEFREQUENCYNVPROC glad_eglGetSystemTimeFrequencyNV;
#define eglGetSystemTimeFrequencyNV glad_eglGetSystemTimeFrequencyNV
typedef EGLuint64NV (APIENTRYP PFNEGLGETSYSTEMTIMENVPROC)(void);
GLAPI PFNEGLGETSYSTEMTIMENVPROC glad_eglGetSystemTimeNV;
#define eglGetSystemTimeNV glad_eglGetSystemTimeNV
#endif
#ifndef EGL_TIZEN_image_native_buffer
#define EGL_TIZEN_image_native_buffer 1
#endif
#ifndef EGL_TIZEN_image_native_surface
#define EGL_TIZEN_image_native_surface 1
#endif
#ifdef __cplusplus
}
#endif
#endif
================================================
FILE: src/3rdparty/glad/src/glad_egl.c
================================================
/*
EGL loader generated by glad 0.1.25 on Mon Jan 14 16:56:21 2019.
Language/Generator: C/C++
Specification: egl
APIs: egl=1.5
Profile: -
Extensions:
EGL_ANDROID_blob_cache,
EGL_ANDROID_create_native_client_buffer,
EGL_ANDROID_framebuffer_target,
EGL_ANDROID_front_buffer_auto_refresh,
EGL_ANDROID_get_frame_timestamps,
EGL_ANDROID_get_native_client_buffer,
EGL_ANDROID_image_native_buffer,
EGL_ANDROID_native_fence_sync,
EGL_ANDROID_presentation_time,
EGL_ANDROID_recordable,
EGL_ANGLE_d3d_share_handle_client_buffer,
EGL_ANGLE_device_d3d,
EGL_ANGLE_query_surface_pointer,
EGL_ANGLE_surface_d3d_texture_2d_share_handle,
EGL_ANGLE_window_fixed_size,
EGL_ARM_implicit_external_sync,
EGL_ARM_pixmap_multisample_discard,
EGL_EXT_bind_to_front,
EGL_EXT_buffer_age,
EGL_EXT_client_extensions,
EGL_EXT_client_sync,
EGL_EXT_compositor,
EGL_EXT_create_context_robustness,
EGL_EXT_device_base,
EGL_EXT_device_drm,
EGL_EXT_device_enumeration,
EGL_EXT_device_openwf,
EGL_EXT_device_query,
EGL_EXT_gl_colorspace_bt2020_linear,
EGL_EXT_gl_colorspace_bt2020_pq,
EGL_EXT_gl_colorspace_display_p3,
EGL_EXT_gl_colorspace_display_p3_linear,
EGL_EXT_gl_colorspace_display_p3_passthrough,
EGL_EXT_gl_colorspace_scrgb,
EGL_EXT_gl_colorspace_scrgb_linear,
EGL_EXT_image_dma_buf_import,
EGL_EXT_image_dma_buf_import_modifiers,
EGL_EXT_image_gl_colorspace,
EGL_EXT_image_implicit_sync_control,
EGL_EXT_multiview_window,
EGL_EXT_output_base,
EGL_EXT_output_drm,
EGL_EXT_output_openwf,
EGL_EXT_pixel_format_float,
EGL_EXT_platform_base,
EGL_EXT_platform_device,
EGL_EXT_platform_wayland,
EGL_EXT_platform_x11,
EGL_EXT_protected_content,
EGL_EXT_protected_surface,
EGL_EXT_stream_consumer_egloutput,
EGL_EXT_surface_CTA861_3_metadata,
EGL_EXT_surface_SMPTE2086_metadata,
EGL_EXT_swap_buffers_with_damage,
EGL_EXT_sync_reuse,
EGL_EXT_yuv_surface,
EGL_HI_clientpixmap,
EGL_HI_colorformats,
EGL_IMG_context_priority,
EGL_IMG_image_plane_attribs,
EGL_KHR_cl_event,
EGL_KHR_cl_event2,
EGL_KHR_client_get_all_proc_addresses,
EGL_KHR_config_attribs,
EGL_KHR_context_flush_control,
EGL_KHR_create_context,
EGL_KHR_create_context_no_error,
EGL_KHR_debug,
EGL_KHR_display_reference,
EGL_KHR_fence_sync,
EGL_KHR_get_all_proc_addresses,
EGL_KHR_gl_colorspace,
EGL_KHR_gl_renderbuffer_image,
EGL_KHR_gl_texture_2D_image,
EGL_KHR_gl_texture_3D_image,
EGL_KHR_gl_texture_cubemap_image,
EGL_KHR_image,
EGL_KHR_image_base,
EGL_KHR_image_pixmap,
EGL_KHR_lock_surface,
EGL_KHR_lock_surface2,
EGL_KHR_lock_surface3,
EGL_KHR_mutable_render_buffer,
EGL_KHR_no_config_context,
EGL_KHR_partial_update,
EGL_KHR_platform_android,
EGL_KHR_platform_gbm,
EGL_KHR_platform_wayland,
EGL_KHR_platform_x11,
EGL_KHR_reusable_sync,
EGL_KHR_stream,
EGL_KHR_stream_attrib,
EGL_KHR_stream_consumer_gltexture,
EGL_KHR_stream_cross_process_fd,
EGL_KHR_stream_fifo,
EGL_KHR_stream_producer_aldatalocator,
EGL_KHR_stream_producer_eglsurface,
EGL_KHR_surfaceless_context,
EGL_KHR_swap_buffers_with_damage,
EGL_KHR_vg_parent_image,
EGL_KHR_wait_sync,
EGL_MESA_drm_image,
EGL_MESA_image_dma_buf_export,
EGL_MESA_platform_gbm,
EGL_MESA_platform_surfaceless,
EGL_NOK_swap_region,
EGL_NOK_swap_region2,
EGL_NOK_texture_from_pixmap,
EGL_NV_3dvision_surface,
EGL_NV_context_priority_realtime,
EGL_NV_coverage_sample,
EGL_NV_coverage_sample_resolve,
EGL_NV_cuda_event,
EGL_NV_depth_nonlinear,
EGL_NV_device_cuda,
EGL_NV_native_query,
EGL_NV_post_convert_rounding,
EGL_NV_post_sub_buffer,
EGL_NV_robustness_video_memory_purge,
EGL_NV_stream_consumer_gltexture_yuv,
EGL_NV_stream_cross_display,
EGL_NV_stream_cross_object,
EGL_NV_stream_cross_partition,
EGL_NV_stream_cross_process,
EGL_NV_stream_cross_system,
EGL_NV_stream_fifo_next,
EGL_NV_stream_fifo_synchronous,
EGL_NV_stream_flush,
EGL_NV_stream_frame_limits,
EGL_NV_stream_metadata,
EGL_NV_stream_remote,
EGL_NV_stream_reset,
EGL_NV_stream_socket,
EGL_NV_stream_socket_inet,
EGL_NV_stream_socket_unix,
EGL_NV_stream_sync,
EGL_NV_sync,
EGL_NV_system_time,
EGL_TIZEN_image_native_buffer,
EGL_TIZEN_image_native_surface
Loader: True
Local files: False
Omit khrplatform: False
Commandline:
--api="egl=1.5" --generator="c" --spec="egl" --extensions="EGL_ANDROID_blob_cache,EGL_ANDROID_create_native_client_buffer,EGL_ANDROID_framebuffer_target,EGL_ANDROID_front_buffer_auto_refresh,EGL_ANDROID_get_frame_timestamps,EGL_ANDROID_get_native_client_buffer,EGL_ANDROID_image_native_buffer,EGL_ANDROID_native_fence_sync,EGL_ANDROID_presentation_time,EGL_ANDROID_recordable,EGL_ANGLE_d3d_share_handle_client_buffer,EGL_ANGLE_device_d3d,EGL_ANGLE_query_surface_pointer,EGL_ANGLE_surface_d3d_texture_2d_share_handle,EGL_ANGLE_window_fixed_size,EGL_ARM_implicit_external_sync,EGL_ARM_pixmap_multisample_discard,EGL_EXT_bind_to_front,EGL_EXT_buffer_age,EGL_EXT_client_extensions,EGL_EXT_client_sync,EGL_EXT_compositor,EGL_EXT_create_context_robustness,EGL_EXT_device_base,EGL_EXT_device_drm,EGL_EXT_device_enumeration,EGL_EXT_device_openwf,EGL_EXT_device_query,EGL_EXT_gl_colorspace_bt2020_linear,EGL_EXT_gl_colorspace_bt2020_pq,EGL_EXT_gl_colorspace_display_p3,EGL_EXT_gl_colorspace_display_p3_linear,EGL_EXT_gl_colorspace_display_p3_passthrough,EGL_EXT_gl_colorspace_scrgb,EGL_EXT_gl_colorspace_scrgb_linear,EGL_EXT_image_dma_buf_import,EGL_EXT_image_dma_buf_import_modifiers,EGL_EXT_image_gl_colorspace,EGL_EXT_image_implicit_sync_control,EGL_EXT_multiview_window,EGL_EXT_output_base,EGL_EXT_output_drm,EGL_EXT_output_openwf,EGL_EXT_pixel_format_float,EGL_EXT_platform_base,EGL_EXT_platform_device,EGL_EXT_platform_wayland,EGL_EXT_platform_x11,EGL_EXT_protected_content,EGL_EXT_protected_surface,EGL_EXT_stream_consumer_egloutput,EGL_EXT_surface_CTA861_3_metadata,EGL_EXT_surface_SMPTE2086_metadata,EGL_EXT_swap_buffers_with_damage,EGL_EXT_sync_reuse,EGL_EXT_yuv_surface,EGL_HI_clientpixmap,EGL_HI_colorformats,EGL_IMG_context_priority,EGL_IMG_image_plane_attribs,EGL_KHR_cl_event,EGL_KHR_cl_event2,EGL_KHR_client_get_all_proc_addresses,EGL_KHR_config_attribs,EGL_KHR_context_flush_control,EGL_KHR_create_context,EGL_KHR_create_context_no_error,EGL_KHR_debug,EGL_KHR_display_reference,EGL_KHR_fence_sync,EGL_KHR_get_all_proc_addresses,EGL_KHR_gl_colorspace,EGL_KHR_gl_renderbuffer_image,EGL_KHR_gl_texture_2D_image,EGL_KHR_gl_texture_3D_image,EGL_KHR_gl_texture_cubemap_image,EGL_KHR_image,EGL_KHR_image_base,EGL_KHR_image_pixmap,EGL_KHR_lock_surface,EGL_KHR_lock_surface2,EGL_KHR_lock_surface3,EGL_KHR_mutable_render_buffer,EGL_KHR_no_config_context,EGL_KHR_partial_update,EGL_KHR_platform_android,EGL_KHR_platform_gbm,EGL_KHR_platform_wayland,EGL_KHR_platform_x11,EGL_KHR_reusable_sync,EGL_KHR_stream,EGL_KHR_stream_attrib,EGL_KHR_stream_consumer_gltexture,EGL_KHR_stream_cross_process_fd,EGL_KHR_stream_fifo,EGL_KHR_stream_producer_aldatalocator,EGL_KHR_stream_producer_eglsurface,EGL_KHR_surfaceless_context,EGL_KHR_swap_buffers_with_damage,EGL_KHR_vg_parent_image,EGL_KHR_wait_sync,EGL_MESA_drm_image,EGL_MESA_image_dma_buf_export,EGL_MESA_platform_gbm,EGL_MESA_platform_surfaceless,EGL_NOK_swap_region,EGL_NOK_swap_region2,EGL_NOK_texture_from_pixmap,EGL_NV_3dvision_surface,EGL_NV_context_priority_realtime,EGL_NV_coverage_sample,EGL_NV_coverage_sample_resolve,EGL_NV_cuda_event,EGL_NV_depth_nonlinear,EGL_NV_device_cuda,EGL_NV_native_query,EGL_NV_post_convert_rounding,EGL_NV_post_sub_buffer,EGL_NV_robustness_video_memory_purge,EGL_NV_stream_consumer_gltexture_yuv,EGL_NV_stream_cross_display,EGL_NV_stream_cross_object,EGL_NV_stream_cross_partition,EGL_NV_stream_cross_process,EGL_NV_stream_cross_system,EGL_NV_stream_fifo_next,EGL_NV_stream_fifo_synchronous,EGL_NV_stream_flush,EGL_NV_stream_frame_limits,EGL_NV_stream_metadata,EGL_NV_stream_remote,EGL_NV_stream_reset,EGL_NV_stream_socket,EGL_NV_stream_socket_inet,EGL_NV_stream_socket_unix,EGL_NV_stream_sync,EGL_NV_sync,EGL_NV_system_time,EGL_TIZEN_image_native_buffer,EGL_TIZEN_image_native_surface"
Online:
Too many extensions
*/
#include
#include
#include
#include
int gladLoadEGL(void) {
return gladLoadEGLLoader((GLADloadproc)eglGetProcAddress);
}
PFNEGLSETBLOBCACHEFUNCSANDROIDPROC glad_eglSetBlobCacheFuncsANDROID;
PFNEGLCREATENATIVECLIENTBUFFERANDROIDPROC glad_eglCreateNativeClientBufferANDROID;
PFNEGLGETCOMPOSITORTIMINGSUPPORTEDANDROIDPROC glad_eglGetCompositorTimingSupportedANDROID;
PFNEGLGETCOMPOSITORTIMINGANDROIDPROC glad_eglGetCompositorTimingANDROID;
PFNEGLGETNEXTFRAMEIDANDROIDPROC glad_eglGetNextFrameIdANDROID;
PFNEGLGETFRAMETIMESTAMPSUPPORTEDANDROIDPROC glad_eglGetFrameTimestampSupportedANDROID;
PFNEGLGETFRAMETIMESTAMPSANDROIDPROC glad_eglGetFrameTimestampsANDROID;
PFNEGLGETNATIVECLIENTBUFFERANDROIDPROC glad_eglGetNativeClientBufferANDROID;
PFNEGLDUPNATIVEFENCEFDANDROIDPROC glad_eglDupNativeFenceFDANDROID;
PFNEGLPRESENTATIONTIMEANDROIDPROC glad_eglPresentationTimeANDROID;
PFNEGLQUERYSURFACEPOINTERANGLEPROC glad_eglQuerySurfacePointerANGLE;
PFNEGLCLIENTSIGNALSYNCEXTPROC glad_eglClientSignalSyncEXT;
PFNEGLCOMPOSITORSETCONTEXTLISTEXTPROC glad_eglCompositorSetContextListEXT;
PFNEGLCOMPOSITORSETCONTEXTATTRIBUTESEXTPROC glad_eglCompositorSetContextAttributesEXT;
PFNEGLCOMPOSITORSETWINDOWLISTEXTPROC glad_eglCompositorSetWindowListEXT;
PFNEGLCOMPOSITORSETWINDOWATTRIBUTESEXTPROC glad_eglCompositorSetWindowAttributesEXT;
PFNEGLCOMPOSITORBINDTEXWINDOWEXTPROC glad_eglCompositorBindTexWindowEXT;
PFNEGLCOMPOSITORSETSIZEEXTPROC glad_eglCompositorSetSizeEXT;
PFNEGLCOMPOSITORSWAPPOLICYEXTPROC glad_eglCompositorSwapPolicyEXT;
PFNEGLQUERYDEVICEATTRIBEXTPROC glad_eglQueryDeviceAttribEXT;
PFNEGLQUERYDEVICESTRINGEXTPROC glad_eglQueryDeviceStringEXT;
PFNEGLQUERYDEVICESEXTPROC glad_eglQueryDevicesEXT;
PFNEGLQUERYDISPLAYATTRIBEXTPROC glad_eglQueryDisplayAttribEXT;
PFNEGLQUERYDMABUFFORMATSEXTPROC glad_eglQueryDmaBufFormatsEXT;
PFNEGLQUERYDMABUFMODIFIERSEXTPROC glad_eglQueryDmaBufModifiersEXT;
PFNEGLGETOUTPUTLAYERSEXTPROC glad_eglGetOutputLayersEXT;
PFNEGLGETOUTPUTPORTSEXTPROC glad_eglGetOutputPortsEXT;
PFNEGLOUTPUTLAYERATTRIBEXTPROC glad_eglOutputLayerAttribEXT;
PFNEGLQUERYOUTPUTLAYERATTRIBEXTPROC glad_eglQueryOutputLayerAttribEXT;
PFNEGLQUERYOUTPUTLAYERSTRINGEXTPROC glad_eglQueryOutputLayerStringEXT;
PFNEGLOUTPUTPORTATTRIBEXTPROC glad_eglOutputPortAttribEXT;
PFNEGLQUERYOUTPUTPORTATTRIBEXTPROC glad_eglQueryOutputPortAttribEXT;
PFNEGLQUERYOUTPUTPORTSTRINGEXTPROC glad_eglQueryOutputPortStringEXT;
PFNEGLGETPLATFORMDISPLAYEXTPROC glad_eglGetPlatformDisplayEXT;
PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC glad_eglCreatePlatformWindowSurfaceEXT;
PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC glad_eglCreatePlatformPixmapSurfaceEXT;
PFNEGLSTREAMCONSUMEROUTPUTEXTPROC glad_eglStreamConsumerOutputEXT;
PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC glad_eglSwapBuffersWithDamageEXT;
PFNEGLUNSIGNALSYNCEXTPROC glad_eglUnsignalSyncEXT;
PFNEGLCREATEPIXMAPSURFACEHIPROC glad_eglCreatePixmapSurfaceHI;
PFNEGLCREATESYNC64KHRPROC glad_eglCreateSync64KHR;
PFNEGLDEBUGMESSAGECONTROLKHRPROC glad_eglDebugMessageControlKHR;
PFNEGLQUERYDEBUGKHRPROC glad_eglQueryDebugKHR;
PFNEGLLABELOBJECTKHRPROC glad_eglLabelObjectKHR;
PFNEGLQUERYDISPLAYATTRIBKHRPROC glad_eglQueryDisplayAttribKHR;
PFNEGLCREATESYNCKHRPROC glad_eglCreateSyncKHR;
PFNEGLDESTROYSYNCKHRPROC glad_eglDestroySyncKHR;
PFNEGLCLIENTWAITSYNCKHRPROC glad_eglClientWaitSyncKHR;
PFNEGLGETSYNCATTRIBKHRPROC glad_eglGetSyncAttribKHR;
PFNEGLCREATEIMAGEKHRPROC glad_eglCreateImageKHR;
PFNEGLDESTROYIMAGEKHRPROC glad_eglDestroyImageKHR;
PFNEGLLOCKSURFACEKHRPROC glad_eglLockSurfaceKHR;
PFNEGLUNLOCKSURFACEKHRPROC glad_eglUnlockSurfaceKHR;
PFNEGLQUERYSURFACE64KHRPROC glad_eglQuerySurface64KHR;
PFNEGLSETDAMAGEREGIONKHRPROC glad_eglSetDamageRegionKHR;
PFNEGLSIGNALSYNCKHRPROC glad_eglSignalSyncKHR;
PFNEGLCREATESTREAMKHRPROC glad_eglCreateStreamKHR;
PFNEGLDESTROYSTREAMKHRPROC glad_eglDestroyStreamKHR;
PFNEGLSTREAMATTRIBKHRPROC glad_eglStreamAttribKHR;
PFNEGLQUERYSTREAMKHRPROC glad_eglQueryStreamKHR;
PFNEGLQUERYSTREAMU64KHRPROC glad_eglQueryStreamu64KHR;
PFNEGLCREATESTREAMATTRIBKHRPROC glad_eglCreateStreamAttribKHR;
PFNEGLSETSTREAMATTRIBKHRPROC glad_eglSetStreamAttribKHR;
PFNEGLQUERYSTREAMATTRIBKHRPROC glad_eglQueryStreamAttribKHR;
PFNEGLSTREAMCONSUMERACQUIREATTRIBKHRPROC glad_eglStreamConsumerAcquireAttribKHR;
PFNEGLSTREAMCONSUMERRELEASEATTRIBKHRPROC glad_eglStreamConsumerReleaseAttribKHR;
PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC glad_eglStreamConsumerGLTextureExternalKHR;
PFNEGLSTREAMCONSUMERACQUIREKHRPROC glad_eglStreamConsumerAcquireKHR;
PFNEGLSTREAMCONSUMERRELEASEKHRPROC glad_eglStreamConsumerReleaseKHR;
PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC glad_eglGetStreamFileDescriptorKHR;
PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC glad_eglCreateStreamFromFileDescriptorKHR;
PFNEGLQUERYSTREAMTIMEKHRPROC glad_eglQueryStreamTimeKHR;
PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC glad_eglCreateStreamProducerSurfaceKHR;
PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC glad_eglSwapBuffersWithDamageKHR;
PFNEGLWAITSYNCKHRPROC glad_eglWaitSyncKHR;
PFNEGLCREATEDRMIMAGEMESAPROC glad_eglCreateDRMImageMESA;
PFNEGLEXPORTDRMIMAGEMESAPROC glad_eglExportDRMImageMESA;
PFNEGLEXPORTDMABUFIMAGEQUERYMESAPROC glad_eglExportDMABUFImageQueryMESA;
PFNEGLEXPORTDMABUFIMAGEMESAPROC glad_eglExportDMABUFImageMESA;
PFNEGLSWAPBUFFERSREGIONNOKPROC glad_eglSwapBuffersRegionNOK;
PFNEGLSWAPBUFFERSREGION2NOKPROC glad_eglSwapBuffersRegion2NOK;
PFNEGLQUERYNATIVEDISPLAYNVPROC glad_eglQueryNativeDisplayNV;
PFNEGLQUERYNATIVEWINDOWNVPROC glad_eglQueryNativeWindowNV;
PFNEGLQUERYNATIVEPIXMAPNVPROC glad_eglQueryNativePixmapNV;
PFNEGLPOSTSUBBUFFERNVPROC glad_eglPostSubBufferNV;
PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC glad_eglStreamConsumerGLTextureExternalAttribsNV;
PFNEGLSTREAMFLUSHNVPROC glad_eglStreamFlushNV;
PFNEGLQUERYDISPLAYATTRIBNVPROC glad_eglQueryDisplayAttribNV;
PFNEGLSETSTREAMMETADATANVPROC glad_eglSetStreamMetadataNV;
PFNEGLQUERYSTREAMMETADATANVPROC glad_eglQueryStreamMetadataNV;
PFNEGLRESETSTREAMNVPROC glad_eglResetStreamNV;
PFNEGLCREATESTREAMSYNCNVPROC glad_eglCreateStreamSyncNV;
PFNEGLCREATEFENCESYNCNVPROC glad_eglCreateFenceSyncNV;
PFNEGLDESTROYSYNCNVPROC glad_eglDestroySyncNV;
PFNEGLFENCENVPROC glad_eglFenceNV;
PFNEGLCLIENTWAITSYNCNVPROC glad_eglClientWaitSyncNV;
PFNEGLSIGNALSYNCNVPROC glad_eglSignalSyncNV;
PFNEGLGETSYNCATTRIBNVPROC glad_eglGetSyncAttribNV;
PFNEGLGETSYSTEMTIMEFREQUENCYNVPROC glad_eglGetSystemTimeFrequencyNV;
PFNEGLGETSYSTEMTIMENVPROC glad_eglGetSystemTimeNV;
static void load_EGL_ANDROID_blob_cache(GLADloadproc load) {
glad_eglSetBlobCacheFuncsANDROID = (PFNEGLSETBLOBCACHEFUNCSANDROIDPROC)load("eglSetBlobCacheFuncsANDROID");
}
static void load_EGL_ANDROID_create_native_client_buffer(GLADloadproc load) {
glad_eglCreateNativeClientBufferANDROID = (PFNEGLCREATENATIVECLIENTBUFFERANDROIDPROC)load("eglCreateNativeClientBufferANDROID");
}
static void load_EGL_ANDROID_get_frame_timestamps(GLADloadproc load) {
glad_eglGetCompositorTimingSupportedANDROID = (PFNEGLGETCOMPOSITORTIMINGSUPPORTEDANDROIDPROC)load("eglGetCompositorTimingSupportedANDROID");
glad_eglGetCompositorTimingANDROID = (PFNEGLGETCOMPOSITORTIMINGANDROIDPROC)load("eglGetCompositorTimingANDROID");
glad_eglGetNextFrameIdANDROID = (PFNEGLGETNEXTFRAMEIDANDROIDPROC)load("eglGetNextFrameIdANDROID");
glad_eglGetFrameTimestampSupportedANDROID = (PFNEGLGETFRAMETIMESTAMPSUPPORTEDANDROIDPROC)load("eglGetFrameTimestampSupportedANDROID");
glad_eglGetFrameTimestampsANDROID = (PFNEGLGETFRAMETIMESTAMPSANDROIDPROC)load("eglGetFrameTimestampsANDROID");
}
static void load_EGL_ANDROID_get_native_client_buffer(GLADloadproc load) {
glad_eglGetNativeClientBufferANDROID = (PFNEGLGETNATIVECLIENTBUFFERANDROIDPROC)load("eglGetNativeClientBufferANDROID");
}
static void load_EGL_ANDROID_native_fence_sync(GLADloadproc load) {
glad_eglDupNativeFenceFDANDROID = (PFNEGLDUPNATIVEFENCEFDANDROIDPROC)load("eglDupNativeFenceFDANDROID");
}
static void load_EGL_ANDROID_presentation_time(GLADloadproc load) {
glad_eglPresentationTimeANDROID = (PFNEGLPRESENTATIONTIMEANDROIDPROC)load("eglPresentationTimeANDROID");
}
static void load_EGL_ANGLE_query_surface_pointer(GLADloadproc load) {
glad_eglQuerySurfacePointerANGLE = (PFNEGLQUERYSURFACEPOINTERANGLEPROC)load("eglQuerySurfacePointerANGLE");
}
static void load_EGL_EXT_client_sync(GLADloadproc load) {
glad_eglClientSignalSyncEXT = (PFNEGLCLIENTSIGNALSYNCEXTPROC)load("eglClientSignalSyncEXT");
}
static void load_EGL_EXT_compositor(GLADloadproc load) {
glad_eglCompositorSetContextListEXT = (PFNEGLCOMPOSITORSETCONTEXTLISTEXTPROC)load("eglCompositorSetContextListEXT");
glad_eglCompositorSetContextAttributesEXT = (PFNEGLCOMPOSITORSETCONTEXTATTRIBUTESEXTPROC)load("eglCompositorSetContextAttributesEXT");
glad_eglCompositorSetWindowListEXT = (PFNEGLCOMPOSITORSETWINDOWLISTEXTPROC)load("eglCompositorSetWindowListEXT");
glad_eglCompositorSetWindowAttributesEXT = (PFNEGLCOMPOSITORSETWINDOWATTRIBUTESEXTPROC)load("eglCompositorSetWindowAttributesEXT");
glad_eglCompositorBindTexWindowEXT = (PFNEGLCOMPOSITORBINDTEXWINDOWEXTPROC)load("eglCompositorBindTexWindowEXT");
glad_eglCompositorSetSizeEXT = (PFNEGLCOMPOSITORSETSIZEEXTPROC)load("eglCompositorSetSizeEXT");
glad_eglCompositorSwapPolicyEXT = (PFNEGLCOMPOSITORSWAPPOLICYEXTPROC)load("eglCompositorSwapPolicyEXT");
}
static void load_EGL_EXT_device_base(GLADloadproc load) {
glad_eglQueryDeviceAttribEXT = (PFNEGLQUERYDEVICEATTRIBEXTPROC)load("eglQueryDeviceAttribEXT");
glad_eglQueryDeviceStringEXT = (PFNEGLQUERYDEVICESTRINGEXTPROC)load("eglQueryDeviceStringEXT");
glad_eglQueryDevicesEXT = (PFNEGLQUERYDEVICESEXTPROC)load("eglQueryDevicesEXT");
glad_eglQueryDisplayAttribEXT = (PFNEGLQUERYDISPLAYATTRIBEXTPROC)load("eglQueryDisplayAttribEXT");
}
static void load_EGL_EXT_device_enumeration(GLADloadproc load) {
glad_eglQueryDevicesEXT = (PFNEGLQUERYDEVICESEXTPROC)load("eglQueryDevicesEXT");
}
static void load_EGL_EXT_device_query(GLADloadproc load) {
glad_eglQueryDeviceAttribEXT = (PFNEGLQUERYDEVICEATTRIBEXTPROC)load("eglQueryDeviceAttribEXT");
glad_eglQueryDeviceStringEXT = (PFNEGLQUERYDEVICESTRINGEXTPROC)load("eglQueryDeviceStringEXT");
glad_eglQueryDisplayAttribEXT = (PFNEGLQUERYDISPLAYATTRIBEXTPROC)load("eglQueryDisplayAttribEXT");
}
static void load_EGL_EXT_image_dma_buf_import_modifiers(GLADloadproc load) {
glad_eglQueryDmaBufFormatsEXT = (PFNEGLQUERYDMABUFFORMATSEXTPROC)load("eglQueryDmaBufFormatsEXT");
glad_eglQueryDmaBufModifiersEXT = (PFNEGLQUERYDMABUFMODIFIERSEXTPROC)load("eglQueryDmaBufModifiersEXT");
}
static void load_EGL_EXT_output_base(GLADloadproc load) {
glad_eglGetOutputLayersEXT = (PFNEGLGETOUTPUTLAYERSEXTPROC)load("eglGetOutputLayersEXT");
glad_eglGetOutputPortsEXT = (PFNEGLGETOUTPUTPORTSEXTPROC)load("eglGetOutputPortsEXT");
glad_eglOutputLayerAttribEXT = (PFNEGLOUTPUTLAYERATTRIBEXTPROC)load("eglOutputLayerAttribEXT");
glad_eglQueryOutputLayerAttribEXT = (PFNEGLQUERYOUTPUTLAYERATTRIBEXTPROC)load("eglQueryOutputLayerAttribEXT");
glad_eglQueryOutputLayerStringEXT = (PFNEGLQUERYOUTPUTLAYERSTRINGEXTPROC)load("eglQueryOutputLayerStringEXT");
glad_eglOutputPortAttribEXT = (PFNEGLOUTPUTPORTATTRIBEXTPROC)load("eglOutputPortAttribEXT");
glad_eglQueryOutputPortAttribEXT = (PFNEGLQUERYOUTPUTPORTATTRIBEXTPROC)load("eglQueryOutputPortAttribEXT");
glad_eglQueryOutputPortStringEXT = (PFNEGLQUERYOUTPUTPORTSTRINGEXTPROC)load("eglQueryOutputPortStringEXT");
}
static void load_EGL_EXT_platform_base(GLADloadproc load) {
glad_eglGetPlatformDisplayEXT = (PFNEGLGETPLATFORMDISPLAYEXTPROC)load("eglGetPlatformDisplayEXT");
glad_eglCreatePlatformWindowSurfaceEXT = (PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC)load("eglCreatePlatformWindowSurfaceEXT");
glad_eglCreatePlatformPixmapSurfaceEXT = (PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC)load("eglCreatePlatformPixmapSurfaceEXT");
}
static void load_EGL_EXT_stream_consumer_egloutput(GLADloadproc load) {
glad_eglStreamConsumerOutputEXT = (PFNEGLSTREAMCONSUMEROUTPUTEXTPROC)load("eglStreamConsumerOutputEXT");
}
static void load_EGL_EXT_swap_buffers_with_damage(GLADloadproc load) {
glad_eglSwapBuffersWithDamageEXT = (PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC)load("eglSwapBuffersWithDamageEXT");
}
static void load_EGL_EXT_sync_reuse(GLADloadproc load) {
glad_eglUnsignalSyncEXT = (PFNEGLUNSIGNALSYNCEXTPROC)load("eglUnsignalSyncEXT");
}
static void load_EGL_HI_clientpixmap(GLADloadproc load) {
glad_eglCreatePixmapSurfaceHI = (PFNEGLCREATEPIXMAPSURFACEHIPROC)load("eglCreatePixmapSurfaceHI");
}
static void load_EGL_KHR_cl_event2(GLADloadproc load) {
glad_eglCreateSync64KHR = (PFNEGLCREATESYNC64KHRPROC)load("eglCreateSync64KHR");
}
static void load_EGL_KHR_debug(GLADloadproc load) {
glad_eglDebugMessageControlKHR = (PFNEGLDEBUGMESSAGECONTROLKHRPROC)load("eglDebugMessageControlKHR");
glad_eglQueryDebugKHR = (PFNEGLQUERYDEBUGKHRPROC)load("eglQueryDebugKHR");
glad_eglLabelObjectKHR = (PFNEGLLABELOBJECTKHRPROC)load("eglLabelObjectKHR");
}
static void load_EGL_KHR_display_reference(GLADloadproc load) {
glad_eglQueryDisplayAttribKHR = (PFNEGLQUERYDISPLAYATTRIBKHRPROC)load("eglQueryDisplayAttribKHR");
}
static void load_EGL_KHR_fence_sync(GLADloadproc load) {
glad_eglCreateSyncKHR = (PFNEGLCREATESYNCKHRPROC)load("eglCreateSyncKHR");
glad_eglDestroySyncKHR = (PFNEGLDESTROYSYNCKHRPROC)load("eglDestroySyncKHR");
glad_eglClientWaitSyncKHR = (PFNEGLCLIENTWAITSYNCKHRPROC)load("eglClientWaitSyncKHR");
glad_eglGetSyncAttribKHR = (PFNEGLGETSYNCATTRIBKHRPROC)load("eglGetSyncAttribKHR");
}
static void load_EGL_KHR_image(GLADloadproc load) {
glad_eglCreateImageKHR = (PFNEGLCREATEIMAGEKHRPROC)load("eglCreateImageKHR");
glad_eglDestroyImageKHR = (PFNEGLDESTROYIMAGEKHRPROC)load("eglDestroyImageKHR");
}
static void load_EGL_KHR_image_base(GLADloadproc load) {
glad_eglCreateImageKHR = (PFNEGLCREATEIMAGEKHRPROC)load("eglCreateImageKHR");
glad_eglDestroyImageKHR = (PFNEGLDESTROYIMAGEKHRPROC)load("eglDestroyImageKHR");
}
static void load_EGL_KHR_lock_surface(GLADloadproc load) {
glad_eglLockSurfaceKHR = (PFNEGLLOCKSURFACEKHRPROC)load("eglLockSurfaceKHR");
glad_eglUnlockSurfaceKHR = (PFNEGLUNLOCKSURFACEKHRPROC)load("eglUnlockSurfaceKHR");
}
static void load_EGL_KHR_lock_surface3(GLADloadproc load) {
glad_eglLockSurfaceKHR = (PFNEGLLOCKSURFACEKHRPROC)load("eglLockSurfaceKHR");
glad_eglUnlockSurfaceKHR = (PFNEGLUNLOCKSURFACEKHRPROC)load("eglUnlockSurfaceKHR");
glad_eglQuerySurface64KHR = (PFNEGLQUERYSURFACE64KHRPROC)load("eglQuerySurface64KHR");
}
static void load_EGL_KHR_partial_update(GLADloadproc load) {
glad_eglSetDamageRegionKHR = (PFNEGLSETDAMAGEREGIONKHRPROC)load("eglSetDamageRegionKHR");
}
static void load_EGL_KHR_reusable_sync(GLADloadproc load) {
glad_eglCreateSyncKHR = (PFNEGLCREATESYNCKHRPROC)load("eglCreateSyncKHR");
glad_eglDestroySyncKHR = (PFNEGLDESTROYSYNCKHRPROC)load("eglDestroySyncKHR");
glad_eglClientWaitSyncKHR = (PFNEGLCLIENTWAITSYNCKHRPROC)load("eglClientWaitSyncKHR");
glad_eglSignalSyncKHR = (PFNEGLSIGNALSYNCKHRPROC)load("eglSignalSyncKHR");
glad_eglGetSyncAttribKHR = (PFNEGLGETSYNCATTRIBKHRPROC)load("eglGetSyncAttribKHR");
}
static void load_EGL_KHR_stream(GLADloadproc load) {
glad_eglCreateStreamKHR = (PFNEGLCREATESTREAMKHRPROC)load("eglCreateStreamKHR");
glad_eglDestroyStreamKHR = (PFNEGLDESTROYSTREAMKHRPROC)load("eglDestroyStreamKHR");
glad_eglStreamAttribKHR = (PFNEGLSTREAMATTRIBKHRPROC)load("eglStreamAttribKHR");
glad_eglQueryStreamKHR = (PFNEGLQUERYSTREAMKHRPROC)load("eglQueryStreamKHR");
glad_eglQueryStreamu64KHR = (PFNEGLQUERYSTREAMU64KHRPROC)load("eglQueryStreamu64KHR");
}
static void load_EGL_KHR_stream_attrib(GLADloadproc load) {
glad_eglCreateStreamAttribKHR = (PFNEGLCREATESTREAMATTRIBKHRPROC)load("eglCreateStreamAttribKHR");
glad_eglSetStreamAttribKHR = (PFNEGLSETSTREAMATTRIBKHRPROC)load("eglSetStreamAttribKHR");
glad_eglQueryStreamAttribKHR = (PFNEGLQUERYSTREAMATTRIBKHRPROC)load("eglQueryStreamAttribKHR");
glad_eglStreamConsumerAcquireAttribKHR = (PFNEGLSTREAMCONSUMERACQUIREATTRIBKHRPROC)load("eglStreamConsumerAcquireAttribKHR");
glad_eglStreamConsumerReleaseAttribKHR = (PFNEGLSTREAMCONSUMERRELEASEATTRIBKHRPROC)load("eglStreamConsumerReleaseAttribKHR");
}
static void load_EGL_KHR_stream_consumer_gltexture(GLADloadproc load) {
glad_eglStreamConsumerGLTextureExternalKHR = (PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC)load("eglStreamConsumerGLTextureExternalKHR");
glad_eglStreamConsumerAcquireKHR = (PFNEGLSTREAMCONSUMERACQUIREKHRPROC)load("eglStreamConsumerAcquireKHR");
glad_eglStreamConsumerReleaseKHR = (PFNEGLSTREAMCONSUMERRELEASEKHRPROC)load("eglStreamConsumerReleaseKHR");
}
static void load_EGL_KHR_stream_cross_process_fd(GLADloadproc load) {
glad_eglGetStreamFileDescriptorKHR = (PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC)load("eglGetStreamFileDescriptorKHR");
glad_eglCreateStreamFromFileDescriptorKHR = (PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC)load("eglCreateStreamFromFileDescriptorKHR");
}
static void load_EGL_KHR_stream_fifo(GLADloadproc load) {
glad_eglQueryStreamTimeKHR = (PFNEGLQUERYSTREAMTIMEKHRPROC)load("eglQueryStreamTimeKHR");
}
static void load_EGL_KHR_stream_producer_eglsurface(GLADloadproc load) {
glad_eglCreateStreamProducerSurfaceKHR = (PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC)load("eglCreateStreamProducerSurfaceKHR");
}
static void load_EGL_KHR_swap_buffers_with_damage(GLADloadproc load) {
glad_eglSwapBuffersWithDamageKHR = (PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC)load("eglSwapBuffersWithDamageKHR");
}
static void load_EGL_KHR_wait_sync(GLADloadproc load) {
glad_eglWaitSyncKHR = (PFNEGLWAITSYNCKHRPROC)load("eglWaitSyncKHR");
}
static void load_EGL_MESA_drm_image(GLADloadproc load) {
glad_eglCreateDRMImageMESA = (PFNEGLCREATEDRMIMAGEMESAPROC)load("eglCreateDRMImageMESA");
glad_eglExportDRMImageMESA = (PFNEGLEXPORTDRMIMAGEMESAPROC)load("eglExportDRMImageMESA");
}
static void load_EGL_MESA_image_dma_buf_export(GLADloadproc load) {
glad_eglExportDMABUFImageQueryMESA = (PFNEGLEXPORTDMABUFIMAGEQUERYMESAPROC)load("eglExportDMABUFImageQueryMESA");
glad_eglExportDMABUFImageMESA = (PFNEGLEXPORTDMABUFIMAGEMESAPROC)load("eglExportDMABUFImageMESA");
}
static void load_EGL_NOK_swap_region(GLADloadproc load) {
glad_eglSwapBuffersRegionNOK = (PFNEGLSWAPBUFFERSREGIONNOKPROC)load("eglSwapBuffersRegionNOK");
}
static void load_EGL_NOK_swap_region2(GLADloadproc load) {
glad_eglSwapBuffersRegion2NOK = (PFNEGLSWAPBUFFERSREGION2NOKPROC)load("eglSwapBuffersRegion2NOK");
}
static void load_EGL_NV_native_query(GLADloadproc load) {
glad_eglQueryNativeDisplayNV = (PFNEGLQUERYNATIVEDISPLAYNVPROC)load("eglQueryNativeDisplayNV");
glad_eglQueryNativeWindowNV = (PFNEGLQUERYNATIVEWINDOWNVPROC)load("eglQueryNativeWindowNV");
glad_eglQueryNativePixmapNV = (PFNEGLQUERYNATIVEPIXMAPNVPROC)load("eglQueryNativePixmapNV");
}
static void load_EGL_NV_post_sub_buffer(GLADloadproc load) {
glad_eglPostSubBufferNV = (PFNEGLPOSTSUBBUFFERNVPROC)load("eglPostSubBufferNV");
}
static void load_EGL_NV_stream_consumer_gltexture_yuv(GLADloadproc load) {
glad_eglStreamConsumerGLTextureExternalAttribsNV = (PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC)load("eglStreamConsumerGLTextureExternalAttribsNV");
}
static void load_EGL_NV_stream_flush(GLADloadproc load) {
glad_eglStreamFlushNV = (PFNEGLSTREAMFLUSHNVPROC)load("eglStreamFlushNV");
}
static void load_EGL_NV_stream_metadata(GLADloadproc load) {
glad_eglQueryDisplayAttribNV = (PFNEGLQUERYDISPLAYATTRIBNVPROC)load("eglQueryDisplayAttribNV");
glad_eglSetStreamMetadataNV = (PFNEGLSETSTREAMMETADATANVPROC)load("eglSetStreamMetadataNV");
glad_eglQueryStreamMetadataNV = (PFNEGLQUERYSTREAMMETADATANVPROC)load("eglQueryStreamMetadataNV");
}
static void load_EGL_NV_stream_reset(GLADloadproc load) {
glad_eglResetStreamNV = (PFNEGLRESETSTREAMNVPROC)load("eglResetStreamNV");
}
static void load_EGL_NV_stream_sync(GLADloadproc load) {
glad_eglCreateStreamSyncNV = (PFNEGLCREATESTREAMSYNCNVPROC)load("eglCreateStreamSyncNV");
}
static void load_EGL_NV_sync(GLADloadproc load) {
glad_eglCreateFenceSyncNV = (PFNEGLCREATEFENCESYNCNVPROC)load("eglCreateFenceSyncNV");
glad_eglDestroySyncNV = (PFNEGLDESTROYSYNCNVPROC)load("eglDestroySyncNV");
glad_eglFenceNV = (PFNEGLFENCENVPROC)load("eglFenceNV");
glad_eglClientWaitSyncNV = (PFNEGLCLIENTWAITSYNCNVPROC)load("eglClientWaitSyncNV");
glad_eglSignalSyncNV = (PFNEGLSIGNALSYNCNVPROC)load("eglSignalSyncNV");
glad_eglGetSyncAttribNV = (PFNEGLGETSYNCATTRIBNVPROC)load("eglGetSyncAttribNV");
}
static void load_EGL_NV_system_time(GLADloadproc load) {
glad_eglGetSystemTimeFrequencyNV = (PFNEGLGETSYSTEMTIMEFREQUENCYNVPROC)load("eglGetSystemTimeFrequencyNV");
glad_eglGetSystemTimeNV = (PFNEGLGETSYSTEMTIMENVPROC)load("eglGetSystemTimeNV");
}
static int find_extensionsEGL(void) {
return 1;
}
static void find_coreEGL(void) {
}
int gladLoadEGLLoader(GLADloadproc load) {
(void) load;
find_coreEGL();
if (!find_extensionsEGL()) return 0;
load_EGL_ANDROID_blob_cache(load);
load_EGL_ANDROID_create_native_client_buffer(load);
load_EGL_ANDROID_get_frame_timestamps(load);
load_EGL_ANDROID_get_native_client_buffer(load);
load_EGL_ANDROID_native_fence_sync(load);
load_EGL_ANDROID_presentation_time(load);
load_EGL_ANGLE_query_surface_pointer(load);
load_EGL_EXT_client_sync(load);
load_EGL_EXT_compositor(load);
load_EGL_EXT_device_base(load);
load_EGL_EXT_device_enumeration(load);
load_EGL_EXT_device_query(load);
load_EGL_EXT_image_dma_buf_import_modifiers(load);
load_EGL_EXT_output_base(load);
load_EGL_EXT_platform_base(load);
load_EGL_EXT_stream_consumer_egloutput(load);
load_EGL_EXT_swap_buffers_with_damage(load);
load_EGL_EXT_sync_reuse(load);
load_EGL_HI_clientpixmap(load);
load_EGL_KHR_cl_event2(load);
load_EGL_KHR_debug(load);
load_EGL_KHR_display_reference(load);
load_EGL_KHR_fence_sync(load);
load_EGL_KHR_image(load);
load_EGL_KHR_image_base(load);
load_EGL_KHR_lock_surface(load);
load_EGL_KHR_lock_surface3(load);
load_EGL_KHR_partial_update(load);
load_EGL_KHR_reusable_sync(load);
load_EGL_KHR_stream(load);
load_EGL_KHR_stream_attrib(load);
load_EGL_KHR_stream_consumer_gltexture(load);
load_EGL_KHR_stream_cross_process_fd(load);
load_EGL_KHR_stream_fifo(load);
load_EGL_KHR_stream_producer_eglsurface(load);
load_EGL_KHR_swap_buffers_with_damage(load);
load_EGL_KHR_wait_sync(load);
load_EGL_MESA_drm_image(load);
load_EGL_MESA_image_dma_buf_export(load);
load_EGL_NOK_swap_region(load);
load_EGL_NOK_swap_region2(load);
load_EGL_NV_native_query(load);
load_EGL_NV_post_sub_buffer(load);
load_EGL_NV_stream_consumer_gltexture_yuv(load);
load_EGL_NV_stream_flush(load);
load_EGL_NV_stream_metadata(load);
load_EGL_NV_stream_reset(load);
load_EGL_NV_stream_sync(load);
load_EGL_NV_sync(load);
load_EGL_NV_system_time(load);
return 1;
}
================================================
FILE: src/CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.13)
project(megaverse)
add_definitions(-DGLM_ENABLE_EXPERIMENTAL)
option(BUILD_GUI_APPS "Whether to build apps that require GUI (things like SDL2)" ON)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/modules/" ${CMAKE_MODULE_PATH})
include(cmake/util.cmake)
common_settings()
add_subdirectory(3rdparty)
add_compile_options(-Wall -Wextra -Wdelete-non-virtual-dtor -pedantic -Werror)
add_subdirectory(libs)
add_subdirectory(apps)
add_subdirectory(examples)
add_subdirectory(test)
================================================
FILE: src/apps/CMakeLists.txt
================================================
find_package(Corrade REQUIRED Main)
set(MAGNUM_DEPENDENCIES
Corrade::Main
Magnum::GL
Magnum::Magnum
Magnum::MeshTools
Magnum::Primitives
Magnum::SceneGraph
Magnum::Shaders
)
if (BUILD_GUI_APPS)
set(VIEWER_APP_SOURCES viewer_app.cpp viewer_args.cpp)
add_app_default(viewer_app "${VIEWER_APP_SOURCES}") # list of sources gotta be in quites
target_link_libraries(viewer_app PRIVATE scenarios viewer Magnum::Application)
endif()
find_package(ZLIB)
set(MEGAVERSE_TEST_APP_SOURCES megaverse_test_app.cpp viewer_args.cpp)
add_app_default(megaverse_test_app "${MEGAVERSE_TEST_APP_SOURCES}")
target_link_libraries(megaverse_test_app PRIVATE scenarios magnum_rendering ${MAGNUM_DEPENDENCIES} ${OpenCV_LIBS})
if (ZLIB_FOUND)
target_link_libraries(megaverse_test_app PRIVATE ${ZLIB_LIBRARIES})
endif ()
if (NOT CORRADE_TARGET_APPLE)
target_link_libraries(megaverse_test_app PRIVATE v4r_rendering)
endif ()
# Make the executable a default target to build & run in Visual Studio
set_property(DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT viewer)
add_app_default(mazegen mazegen.cpp)
target_link_libraries(mazegen PRIVATE mazes)
================================================
FILE: src/apps/mazegen.cpp
================================================
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include